Shared policy location: docs/DISCOVERY.md, docs/WORKFLOW.md,
docs/LAUNCH-MIGRATION.md, docs/STANDALONE-ENTRY.md, docs/PROCESS.md and docs/SURFACES.md belong to the resolved Hatsu plugin
root, not the consuming repository. On an installed surface, use the absolute root printed by ten to read
those files (re-resolve through that skill if unavailable). Relative links below identify source
locations; a missing consumer docs/ copy is not a missing policy and must not trigger a duplicate
filing. Never copy or invent a second policy in the target repository.

Third Hand — the chairman's last look at the sitting

Nature: Manipulator. The harvest is GitHub-side filing under
`claude/agents/netero.md`. Name Conjurer alongside it when a proposal
is constitution or canon prose, Transmuter when it is machinery. Never blend two under one
header (claude/agents/kurapika.md).

Before this sitting closes, have Netero look at what actually slowed us — fold the same
problems together, show me at most three issues, file only the ones I pick, then stop.

Third-Hand is its own phase on the regular Kurapika pipeline
(ren → aka → mukai → en → third-hand). It runs once En has completed — Ready and the
retained final report already exist, or En ended at a sitting-ending terminus. It is not a step
of En. En's protocol ends at the human gate; this phase begins after that run has returned. The
report may already be in the maintainer's hands while Netero reads the sitting. The human merge
remains G2 and has no skill — this file does not describe a merge and does not wait for one.

Netero files. He never implements the filed work. Landing a solution is a later Kurapika or
Nen effort, never this skill.

This file composes. It does not re-specify. Filing, labels, four-pass reconciliation, and
completeness live in `hatsu:file`, `docs/DISCOVERY.md`
and Netero's definition. What is genuinely this skill's own is the wrap-up trigger, the parallel
summon, the 0–3 fold-and-priority cap, the picker, and the session-over rule.

---

0. Standalone entry — when no composite is holding the run

Third-Hand is already a separate phase rather than a step of anything — § 1 says so, and En does
not start it. The contract is `docs/STANDALONE-ENTRY.md`, and
this section covers the one fact § 1 leaves to context. Started by the maintainer right after En has
returned, that context exists and this section is a formality; say so and move on.

P1 · Warm up, unconditionally. `hatsu:ten third-hand` (ten § 6 catches up the prerequisites) — the contract's
first step, and it is not waived by this phase being terminal. Everything below reaches for the Nen
parser and the surface's picker, so a direct call on an unwarmed host fails before the harvest
starts, with D10 unsatisfied and nothing to show for it. Skipped when a composite is holding the
run, which has already warmed.

The state class Third-Hand inherits is S3 — "this sitting". § 1 resolves a clause-less
invocation to the PR En is holding, or the branch this session cut. Typed by hand into a checkout
that never ran En, neither exists until they are read off the checkout.

P2 · Resolve the sitting, in this order, and name what it resolved to. The table is total —
every checkout lands on exactly one row, and none falls through to the harvest with its sitting
unnamed. git fetch origin runs before any row that compares against the base, and the resolved
ref is named; a fetch that cannot run is a stop, per
`docs/STANDALONE-ENTRY.md` § 3 · P3, because a sitting selected
off a stale tracking ref is a sitting selected off somebody else's tree.

Signal	The sitting
An on <CODE>#<N> clause	That reference. It always wins
A PR En held in this session	That PR
Exactly one open PR for the current branch (gh pr list --head <branch> --state open)	That PR
Two or more open PRs for the current branch	Ambiguity stop. Ask through the surface's own picker which one, listing number, title and base — or for on <CODE>#<N>. Never the newest, never a fall-through: a harvest attributed to the wrong PR is worse than no harvest
A feature branch with commits since the fetched origin/<branch.base> and no PR	That branch, named with its commit count and the base it was compared against. A harvest does not require a PR
A feature branch with no commits since that base, dirty	The uncommitted work is the sitting. Name every path. Friction observed while writing them is still friction observed
A feature branch with no commits since that base, clean	Stop — nothing was executed here to observe
The trunk, dirty	The uncommitted work is the sitting, named by path — and say that it is on the trunk, because that is itself worth harvesting
The trunk, clean, no session history	Stop. There is no sitting to harvest. Say so — do not harvest the repository in general, which is `hatsu:file`'s and `hatsu:backlog-synthesis`'s work, not this skill's
Detached HEAD	Classified, not refused. Report the commits it holds and ask what the sitting is — a detached checkout names no branch, so nothing below can be derived from one

The friction being harvested is this sitting's, and a cold entry narrows rather than widens it.
Netero observes Hunters in execution; where the session did not execute anything, there is nothing
observed, and proposing issues from a reading of the repository is a different discipline wearing this
one's name.

P4 · Nothing new to ask. The harvest pick is § 2's own question through the surface's own picker,
unchanged — the proposals plus File none. Where the session has no observed execution, propose
zero and say so; zero is a valid harvest and padding it to reach three is the failure this phase
is most exposed to.

What does not change. 0–3 folded proposals, never more. Only what the maintainer picks is filed.
Netero files; he never implements the filed work. And Third-Hand still ends the session — it
is terminal in its own pipeline, so its hand-back line names no successor and says that instead.

---

1. Invocation

hatsu:third-hand [on <CODE>#<N>]

nen parse third-hand --grammar "on [<ref>]" --line "<the invocation, minus the hatsu:third-hand prefix>"

Verified live at nen 0.10.0 (docs/ab/third-hand.md § 2.1): on HA#62 → ref: HA#62 at exit
0; a bare on and an empty line both parse with the clause absent, also exit 0. No clause
means this sitting — the PR En is holding, or the branch this session cut, named out loud.

A missing argument or configuration item is asked for and set up inline (missing-argument,
missing-configuration; `WORKFLOW.md` § 4 Ask, set up, continue).

En does not start this skill. Echoing a parse of a line nobody typed is theatre, the same
reason `hatsu:en` § 1 does not parse Mukai's handoff. The caller starts
Third-Hand after En has returned; the parse runs when, and only when, the maintainer typed a
clause.

---

2. When it runs — wrap-up, not merge

Started after En completes. Kurapika, holding the regular pipeline, starts this phase when
`hatsu:en`'s run has returned. En does not compose it and does not start it from
inside En's step table. The retained report may already have been presented; Netero still runs as
a parallel subagent of this phase.

Also invocable by the maintainer when wrapping a sitting whose En already ended (they merged
on GitHub and came back; they re-opened the conversation after Ready).

Never a sixth human-called phase, and never a prompt for the merge. The five phases only the
maintainer calls stay aka, mukai, the merge, kagutsuchi, mugetsu. Asking "shall I run
third-hand?" at the end of En is how a composed close becomes an agent-prompted one by attrition —
when En has completed, start this phase; a direct call is wrap-up, not a suggestion at the end of
a Ren turn.

Never auto-starts from a Ren turn or from Aka, and never from inside En. Those sittings are
not over, or they are still En's. A G5 that the pipeline still owns is not wrap-up.

Once per sitting. If .nen/third-hand/<slug>.json already carries a completed harvest for
this PR (or this branch, when no PR was named), skip, say already-harvested, and still end the
session. Do not re-ask. <slug> is <CODE>-<N> from nen ref format when a PR is in play,
otherwise the branch slug.

---

3. Raise Netero in parallel

On a surface with in-session subagents, raise one delegate titled
third-hand · netero · <model alias>, on Netero's own pin (model: opus, effort high in
the definition — do not pass model, the same reconciliation `hatsu:hanten`
§ 4 records: the harness model parameter would silently overrule the frontmatter). Never the
frontier tier.

Surface	How he is raised	Isolation
Claude Code	the harness Agent tool, subagent_type the Netero persona (hatsu:netero)	omitted — he needs this sitting's report, last-stop, cycle ledger and transcript, not an isolated checkout of the plugin
Cursor	the netero definition under .cursor/agents/netero.md, invoked as that surface documents; if the harness only offers a generic worker, load the definition into it and keep the title	omitted, same reason
Antigravity	invoke_subagent: TypeName netero (the registered agent), Role the title, Prompt pass 1's harvest brief, Workspace: "inherit"	inherit, never "branch". branch cuts an isolated worktree that hides this sitting's .nen/ and Reports/. "share" is acceptable only when it is the same checkout. Model pro, never ultra
Codex (ChatGPT app, CLI, IDE)	spawn one in-session subagent — current Codex releases enable this by default; a skill instruction is a documented trigger. Invoke spawn_agent (or the session's equivalent spawn tool) titled third-hand · netero · <model alias>. Load Netero's definition from AGENTS.override.md / the mirrored persona. Never a second codex exec process for this harvest	Codex V2 agents share the parent's working directory — that is what this harvest needs. Never astra

Two passes, one persona.

1. Harvest (parallel with the retained report). Netero reads the sitting and returns 0–3
   complete drafts. He files nothing on this pass.
2. File (after the pick). Only the drafts the maintainer selected, through
   `hatsu:file` under Netero's completeness. Reconciliation still runs; a
   duplicate is updated / folded / unchanged, never double-created.

Pass 1's prompt names: the PR or branch, the retained report path if it exists, .nen/last-stop.json
if present, .nen/hanten/<branch-slug>.cycle.json if present, the En loop ledger if present, this
skill's § 4 inputs and § 5 output shape, and "file nothing until the maintainer picks".

A second-process codex exec is not this harvest. Hanten's isolated reviewer run exists because
reviewers must not share the author's tree. Netero must share the sitting. Do not repurpose that
mechanism. Codex in-session spawn is the raise for this phase.

---

4. What he reads — the sitting, not the backlog

Every class in Netero's observation table is in play, including ones the maintainer did not name:

Input	Where	What it is for
Session challenges, not delivered, decisions	the retained final report, else Reports/current.html	what the Hunter already admitted was hard
Duration	turn times, watch length, suite length, warm-up seats	jobs that cost more than they returned
Redundancy	the same hand pipeline run more than once this sitting	work a verb should own
Autonomy gaps	G5 stops, extra asks, midwifed steps the maintainer expected to run unattended	bottlenecks against autonomous delivery
Determinism	improvised shell standing in for a Nen verb; residue sections actually exercised	predictability
Toolchain	nen shu tools seats, missing versions, utilities the agent lacked	provisioning
Other roster friction	Hanten budgets exhausted, En cap pressure, missing verbs named in residue	fold into the classes above when they are the same problem

Sanitize. No credentials, no private logs, no personal-device identifiers, no unrelated consumer
data. Do not invent a finding from another sitting. Do not file a UI finding as the chairman's
(Hisoka), a security finding (Feitan), architecture (Chrollo), a number-without-method-block
(Uvogin), or a long-watch provision (Illumi) — note it in one line and skip.

---

5. Zero to three proposals — fold similar, drop the rest

Cap: 0, 1, 2 or 3. Zero is a valid harvest: the sitting was clean enough that nothing rises
to an issue. Say so, skip the picker, write the marker, end the session.

Fold. Similar problems of the same owner and the same missing capability become one
proposal — repeated warm-up seats, the same improvised pipeline, the same missing verb hit three
times. That is the wrap-up exception to Netero's in-execution rule "one finding, one issue".
Distinct owners stay distinct (Hatsu prose and Nen machinery are still two issues, cross-linked).
Distinct classes stay distinct until the cap forces a drop.

Prioritize. Rank by how much they blocked autonomous delivery this sitting, then by how
cheaply a verb or a skill-prose fix would remove the class, then by recurrence. Drop what does
not make the three. Dropped findings are listed in the harvest marker as not_proposed with one
line why — they are not silently filed later.

Each proposal is a complete draft, not a title:

1. id — p1 / p2 / p3 in priority order
2. owner — Hatsu or Nen, resolved with nen repo resolve, never guessed
3. class — duration / redundancy / autonomy-gap / determinism / toolchain / other
4. title
5. why — one line for the picker label
6. the full issue body Netero's completeness owes (problem, sanitized evidence, who it matters
   to, observable acceptance criteria, scope boundaries, deployment / fan-out / provisioning
   cross-references)
7. labels from the target nen/labels.json, none invented

Return them in that shape. Do not file them on pass 1.

---

6. The picker — then file only the pick

The question is the harvest, not a G5 stop and not the merge. Do not call nen stop. Do not
re-render `hatsu:file` § 4's DECIDE banner. The pick is the confirmation
for those drafts.

Present one harvest through the surface's own native option picker. Never lettered options
in the reply when that picker exists.

Surface	Picker — invoke this, not prose
Claude Code	AskUserQuestion, multiple selection
Cursor	AskQuestion, allow_multiple: true
Antigravity	ask_question with is_multi_select: true on one harvest question. Options are the proposals plus File none. At least two options.
Codex (ChatGPT app, CLI, IDE)	request_user_input — that is the native tool. questions 1–3, isBlocking: true. Do not include an Other option; the client adds it. ChatGPT app: one harvest question whose options are the proposals plus File none, collecting every ticked answer. CLI TUI: the overlay is one selected option per question; emit one question per proposal (file / skip), at most three, which is the tool's documented cap. Headless or a stripped tool set: do not file, say the picker could not run.

Prompt: Netero folded this sitting's process findings into N proposal(s). Pick which to file.
Unselected are not filed. File none ends the session with no new issue.

Options: one per proposal, label [Hatsu|Nen] <title> — <why>, plus none: File none —
session over without new issues.

none wins over every other selection. If the maintainer ticks proposals and none, file
nothing.

Zero proposals: no question. Do not ask them to confirm the empty set.

After the answer, pass 2 files each selected draft through hatsu:file under Netero's
completeness and DISCOVERY standing authority. Four-pass reconciliation still runs immediately
before each write. Unselected drafts are not filed, not parked as pending issues, not offered as
hatsu:build.

Do not offer hatsu:build after a harvest filing. File's § 6 offer starts a new effort; this
sitting is over. Report each created or updated URL in the target's object notation and stop.

---

7. The harvest marker, and session over

Write (or overwrite only when this sitting had not completed) .nen/third-hand/<slug>.json:

{
  "contract": "hatsu.third-hand.harvest/v0.1",
  "at": "<ISO-8601>",
  "ref": "<CODE>#<N or branch slug>",
  "proposed": [{ "id": "p1", "owner": "Hatsu", "class": "determinism", "title": "…" }],
  "not_proposed": [{ "why": "dropped under the cap" }],
  "picked": ["p1"],
  "filed": ["<url>"],
  "result": "filed"
}

result is one of filed · none-proposed · none-picked · already-harvested. The directory
is gitignored with the rest of .nen/; `ten` never deletes
it. This is Hatsu residue, not a Nen verb.

Then the session is officially over. Say the object notation of anything filed (or that
nothing was), the harvest result, and that the sitting is closed. Do not wait for the merge.
Do not start the next Ren turn. Do not prompt for aka, mukai, merge, kagutsuchi or
mugetsu. A later human request is a later sitting.

---

Residue

1. Raising Netero has no nen verb, and is not expected to get one. nen owns operations, not
   conversations (docs/ab/ren.md § 2.2). Named here, the same class as Hanten's Agent-tool raise
   and En's Illumi hand-off.
2. The harvest marker is Hatsu-owned JSON at .nen/third-hand/<slug>.json, contract
   hatsu.third-hand.harvest/v0.1. No verb writes it. A missing file means "not yet harvested",
   never "no findings".
3. The picker is the surface's, never nen's (docs/ab/jutaisho.md). Codex's tool is
   request_user_input; Antigravity's is ask_question. A lettered paragraph is not a pick.
4. The composition itself has no verb. Filing inside pass 2 is hatsu:file's verbs; owner
   resolve is nen repo resolve; ref formatting is nen ref format.

Authority

• Permitted: raise Netero under § 3; read the sitting's report and .nen/ inputs; present
  the picker; file only picked drafts through hatsu:file under Netero's completeness.
• Not permitted: any merge; any review vote; any implementation of a filed issue; any
  hatsu:build started from this skill; any stage or release label; any push, tag, or deploy;
  inventing a finding, a label, a slug, or a fourth proposal.
• Standing discovery authority covers the writes the maintainer picked. It does not cover
  filing unselected drafts "because they were good".

Hard limits

• Never merges, never votes, never implements the filed work.
• Never files more than three issues from one harvest, and never files a draft the
  maintainer did not pick.
• Never prompts for the merge, and never waits for it to close the sitting.
• Never raises Netero on the frontier tier, and never omits the title
  third-hand · netero · <model alias>.
• Never isolates him from this sitting's evidence in a worktree that hides Reports/ or
  .nen/.
• Never skips the four-pass reconciliation because the draft was already written on pass 1.
• Never offers hatsu:build, and never starts one.
• Never auto-starts from Ren, Aka, or from inside En, and never asks "shall I run third-hand?"
  to smuggle a composed close into a human-called phase. Start it when En has completed.
• Never restates file or Netero's completeness. If this file and those disagree, those
  are right and this file is the bug.