@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/.claude/skills/workflow-commands/chain-rule.md

@@ -5,74 +5,76 @@
 This is the execution contract for `fullrun` and `backlogrun`, and for `prrun` up to the pull request: a `prrun` never issues `pnpm josh ship` or a merging `pnpm josh followup` — it opens the pull request with `pnpm josh git -y` and ends by `prrun.md` → "The difference — the end of the run". The record below is reference only.
 Review results and successful pushes are never turn boundaries.
 
-0. **A lane child** (no `main:merge`: ship's sync merges main, stopping `conflict`): the self-check (`prompts/review.md` → "Before round 1 —
-   the implementer's self-check"), `pnpm josh check:related` (a metrics notice → its verdict line), `pnpm josh run:review` — its `--join`'s `test:pinned` lines
-   answer the self-check's question 1 — the ship body draft filled in beside the gate (`report-format.md` → "PR
-   本文の受け入れ条件の対応表"), then its `/code-review` subagent (as `run:review` prints) — on two briefs, two `reviewer`s side by side, the second recorded with `review:record --interaction --issue <N>` — not backgrounded — a turn end kills it — then `run:review --join`, `review:attest --check`, the
-   round's fixes, no `check:related` after them unless a brief follows (one before `--join` is refused, `round-one-check-related`), `pnpm josh review:record --issue <N> [<finding> ...]` (round 2 stays ship's; it stamps the fixed tree, so ship reuses this round 1 and round 2 reads what moved since, unless round 2 would skip a move — never reopen `run:review`, which refuses it; on `Interaction review now due`, record that pass before the ship, running it first if none ran beside round 1; on `test:pinned restarted`, go on to the ship without waiting — its pre-detach reads that check), `pnpm josh ship --detach --review "<title> #<N>"`
-   (`--cite <N>`; `--unpinned-ok "<reason>"` when `run:review` needed it). On `launched` with
-   `pnpm josh cost --cut` `under`, run `pnpm josh ship:wait <N>` (`timeout` 600000) and follow
-   it (`docs/josh-commands-run.md` → "`josh ship:wait`"); else, or on `busy`, **end the turn**. No `pnpm josh gate`,
-   `check:related`, `check` or `metrics` before it or a re-detach, by hand: ship reuses the scoped
-   pair green on this tree and base (no fix, main unmoved) and runs the gate after its sync (`scripts/run/ship/run-ship-steps.ts`); a standalone `check` or
-   `metrics` leaves no record it reuses. A stop no session waits on relaunches a child
-   whose prompt carries the failed output's tail and the changed files (`pnpm josh ship --log <N>` when
-   the stage printed nothing), on a review stop the sweep of each finding's other sites the stop note
-   directs, and (Anthropic lane) the re-detach to run after the fix — `pnpm josh ship --detach`, `--review` only if the stopped ship carried it and stopped before
-   round 2, which is final, or the review went stale (`scripts/run/ship/run-ship-next.ts`).
-   A preflight stop `unplanned: <files>` → take one of the two ways out it prints, then re-detach
-   — unless its `lane:plan` answers `yield` (`docs/josh-commands-run.md` → "`josh ship`").
-   `failed` → step 1.
-1. Run `pnpm josh main:merge`. **Then issue `pnpm josh run:cut <N>` alone, before `check:related` and
-   the gate** — the pre-gate cut (a no-op outside a lane). Then answer the self-check
-   (`prompts/review.md` → "Before round 1 — the implementer's self-check"), its question 1 left to
-   `run:review --join`, run the final scoped lint/test pair with `pnpm josh check:related` and
-   `pnpm josh run:review`: it starts `pnpm josh test:pinned` and `pnpm josh gate` in the background
-   and writes the `/code-review` brief to a file, printing its path and prompt, in one call, so they overlap; two briefs take two `reviewer`s side by side, the second recorded with
-   `review:record --interaction`. Launch the `/code-review` subagent as the `reviewer`
-   agent type (`kit:reviewer` in a consumer) with that prompt verbatim and its `model` — the alias of the `model=` id the brief prints (`claude-opus-5-5` → `opus`)
+1. **Issue `pnpm josh run:cut <N>` alone first** — the pre-gate cut (a no-op outside a lane). Then
+   `pnpm josh run:chain <N>` in one Bash call (`timeout` 600000), the self-check (`prompts/review.md` →
+   "Before round 1 — the implementer's self-check") answered before the scoped lint/test pair it runs;
+   follow what it prints — its stages
+   (`scripts/run/review/run-chain.ts`), a stop's `next:` line (`--from <stage>` resumes) and
+   `run:review`'s brief paths and prompts (`scripts/run/review/run-review-cli.ts`). Launch the
+   `/code-review` subagent as the `reviewer` agent type (`kit:reviewer` in a consumer) with that prompt
+   verbatim and its `model` — the alias the brief prints beside its `model=` id (`(opus)` → `opus`)
    (`.claude/agents/reviewer.md`; never a guessed type name).
    Never load the review skill in the main line.
-2. Once the review returns, run `pnpm josh run:review --join` to join and read the gate before
-   committing (`--join --fixing` if round 1 has fixes to make); it exits non-zero on a red gate, `3` on an `unpinned` line (its note names the `--unpinned-ok` call). Fix any red check, then rerun the affected scoped check
-   and gate. Never version-bump a child (`pnpm josh release` decides).
-3. Before acting on any review round, run `pnpm josh review:attest --check`. `missing` or `mismatch`
-   discards it without counting; rerun against the brief's checkout. A review error receives a
-   `confirmation` Telegram and stops.
+2. Once the review returns, `pnpm josh run:chain <N> --join` (`--fixing`: round-1 fixes); follow what
+   it prints (`scripts/run/review/run-chain-join.ts`). A complete green gate and pinned answer with no
+   unplanned files on the same tree return without waiting; every miss uses the normal join and its
+   exit codes. Attestation and finding disposition still follow. `lane:breakdown` counts the halves as
+   `run:chain open` and `run:chain join`. Never version-bump a child (`pnpm josh release` decides).
+3. A round for which `review:attest --check` answers `missing` or `mismatch` is discarded uncounted; rerun
+   against the brief's checkout. A review error receives a `confirmation` Telegram and stops.
 4. Route the attested verdict mechanically:
+   - Full-change final brief: apply round 2's disposition; record with `--comment`.
+     Interaction stays independent.
    - Clean or Low-only round 1: no second round. Fix, file, or drop each Low with a one-line reason.
-   - High/Medium round 1: fix and record it (below), then ask `pnpm josh review:round2 --record <N>`
-     (it comments a skip). On `required`, open the PR first and run round 2 from
-     `pnpm josh review:brief --round 2` beside CI as `reviewer-verification` (`kit:` in a consumer).
+   - High/Medium round 1: fix and record it (below), then `ship --review` (step 5) asks
+     `review:round2 --record <N>` and runs a due round 2 as `reviewer-verification`.
    - Round 2 is final. Fix a branch-1 finding, run its scoped check, push it, then run the gate. Dispose
      of remaining non-High findings; a confirmed High blocks and receives a `confirmation` Telegram.
-   Outside step 0, round-1 fixes run one scoped check and the gate before `git -y`.
-   Once a round's verdict is attested, record its findings with `pnpm josh review:record --issue <N>
-   ['[<disposition> ]<category>:<severity>:<file> — <reason>' ...]` (each one quoted argument; none if
-   clean; dispositions: its usage). **A round 2 that
+   After the last pre-commit review fix: `pnpm josh test:related --touched` once.
+   Record an attested round's findings with `pnpm josh review:record --from-slot
+   --issue <N>` (dispositions: its usage). **A round 2 that
    passes takes `--comment`** (`observation-ledger.md` → "The commit path").
-   **`pnpm josh followup` refuses the merge until the round is recorded**
-   (`pnpm josh review:record --check --issue <N>`).
 5. **The clean path ships in one call** — with no second round due, background
-   `pnpm josh ship "<title> #<N>" --body-file <evidence.md>` — the file carries `## 実機証跡` and
-   `## 受け入れ条件の対応` (`report-format.md`), both asked at the preflight: PR preflight → gate → `git -y` →
-   `followup` → `run:tail`, stopping at the first failure. `--review` runs both rounds. **Else a due
-   round 2 does not fit `ship`**: the PR opens between the rounds — background
-   `pnpm josh git -y "<title> #<N>"`, round 2 beside CI, then `pnpm josh followup`.
+   `pnpm josh ship "<title> #<N>"` — its body draft carries `## 実機証跡`
+   (`pnpm josh ship:evidence` fills it) and `## 受け入れ条件の対応` (`report-format.md`), both asked at the preflight: PR preflight → gate → `git -y` →
+   `followup` → `run:tail`, stopping at the first failure. With a due round 2, use `ship --review`:
+   after sync and round 1, round 2 runs beside the gate and joins before the commit opens the PR.
 
-A lane child may end once, at step 0 or the pre-gate cut (`pre-gate-cut.md`); never at the push. The chain otherwise stops only when the PR is merged, the completion Telegram was sent, and
+A lane child session ends at step 0, a pre-gate cut (`pre-gate-cut.md`) or a review-fix cut; never at the push. The chain otherwise stops only when the PR is merged, the completion Telegram was sent, and
 `run:tail` returned to the default branch, or when user judgment is required by an unverifiable
 CodeRabbit/Claude Review finding or a CI failure. In a lane the parent closes it. Managed config claims are reported by `followup` and do not stop the merge.
 
 Recommendations are informational; severity decides. A CodeRabbit rate-limit warning is not a finding.
 
+## A lane child — step 0
+
+0. **A lane child** (no `main:merge`: ship's sync merges main, stopping `conflict`): the self-check (`prompts/review.md` → "Before round 1 —
+   the implementer's self-check"; 1: `--join`'s `test:pinned`, 2/4/10: `review:selfcheck`), `pnpm josh run:chain <N>` (a metrics notice → its verdict line) —
+   the ship body draft's rows a green `test:related` left pending filled in beside the gate (`report-format.md` → "PR
+   本文の受け入れ条件の対応表"), then its `/code-review` subagent (as `run:review` prints) — on two briefs, two `reviewer`s side by side, the second recorded with `review:record --from-slot --interaction --issue <N>` before the join that ships — not backgrounded — a turn end kills it — then `pnpm josh run:chain <N> --join --ship "<title> #<N>"` (step 2; clean records and ships with `--detach --review`; every finding holds before recording or shipping, fixed in a fresh session: the hold's `run:cut --impl`), the
+   round's fixes, no `check:related` after them unless a brief follows (one before `--join` is refused, `round-one-check-related`), on a held finding `pnpm josh review:record --from-slot --issue <N>` (round 2 stays ship's; it stamps the fixed tree, so ship reuses this round 1 and round 2 reads what moved since, unless round 2 would skip a move — never reopen `run:review`, which refuses it; a `lane:plan` widened after round 1 → the ship, whose `--review` reads the widened files (`review-lane-handover.ts`); on `Interaction review now due`, record that pass before the ship, running it first if none ran beside round 1; on `test:pinned restarted`, go on to the ship without waiting — its pre-detach reads that check), `pnpm josh ship --detach --review "<title> #<N>"`
+   only after that hold is settled; use plain `--join` then this ship when additional ship options are needed
+   (`--cite <N>`; `--unpinned-ok "<reason>"` when `run:review` needed it; `timeout` 600000 for either shipping call). On either shipping path, `launched` runs
+   `cost --cut` and, on `under`, one `ship:wait <N>` chunk; follow it
+   (`docs/josh-commands-run.md` → "`josh ship:wait`"); on `busy`, **end the turn**. No `pnpm josh gate`,
+   `check:related`, `check` or `metrics` before it or a re-detach, by hand: ship reuses the scoped
+   pair green on this tree and base (no fix, main unmoved) and runs the gate after its sync (`scripts/run/ship/run-ship-steps.ts`); a standalone `check` or
+   `metrics` leaves no record it reuses. A stop no session waits on relaunches a child
+   whose prompt carries the failed output's tail and the changed files (`pnpm josh ship --log <N>` when
+   the stage printed nothing), on a review stop the sweep of each finding's other sites the stop note
+   directs, and (Anthropic lane) the re-detach to run after the fix — `pnpm josh ship --detach`, `--review` only if the stopped ship carried it and stopped before
+   round 2, which is final, or the review went stale (`scripts/run/ship/run-ship-next.ts`).
+   A preflight stop `unplanned: <files>` → take one of the two ways out it prints, then re-detach
+   — unless its `lane:plan` answers `yield` (`docs/josh-commands-run.md` → "`josh ship`").
+   `failed` → step 1.
+
 ## Orchestration facts single-sourced here
 
 These are the gate → review → PR → merge facts other documents cite; this file is their single source
 (`prompts/review.md` carries the review _policy_, `prompts/review-rubric.md` the rubric).
 
-- **The gate runs beside this review, not in front of it** — started with the review, joined before the
-  commit. A red gate is fixed and re-run whatever the review concluded.
+- **The gate runs in front of round 1** — `run:review` prints the gate's note and writes no brief on
+  any gate state but green (step 1); round 2 runs beside the ship's gate.
 - **origin/main is merged in before the gate** — `pnpm josh main:merge` (in a lane, ship's sync) is the last edit, so the scoped
   pair and the gate run once over it (in a lane, ship's, after `run:review`'s over the unmerged tree); a conflict fires `backlogrun-recovery.md` → "Conflicts are not
   predicted" early. **This is the one place a conflicted merge's procedure is written**: `main:merge`
@@ -85,8 +87,8 @@ These are the gate → review → PR → merge facts other documents cite; this
 - **One related-check command answers once per tree** — while implementing re-run one check per edit
   (`lint:related` / `cspell:dot` / `test:related --touched`), one full-reach `test:related` once the
   implementation is done (`docs/josh-commands.md` → "`josh test:related`"), then `pnpm josh check:related` once
-  before `run:review`, a review round's fixes once after the last (in a lane, none after `run:review`); `check:related` is those three plus `check`. In kit `lint:related` reports a metrics total past the
-  merge-base; accept it with its reason before `pnpm josh ship`, or its pre-detach check stops.
+  before `run:review`; ship's scoped pair runs full reach after review fixes; `check:related` is those three plus `check`. In kit `lint:related` reports a metrics total past the
+  merge-base; accept it with its reason before `run:review`, whose open stops on it (the ship's pre-detach check is the backstop).
 - **The pull request opens between the rounds, so CI runs beside round 2** — round 1 runs on the
   uncommitted tree and its High/Medium fixes land before the commit; the verification pass runs against
   the open pull request.
@@ -101,5 +103,4 @@ These are the gate → review → PR → merge facts other documents cite; this
   review:attest <nonce>` from the tree it read, and `pnpm josh review:attest --check` must answer `ok`
   before anything acts on the verdict.
 
-This file is the single source of the gate → review → PR → merge chain rule; other documents reference
-it rather than restating it. `prompts/collaboration-workflow/plan-comment.md` keeps Step 3.
+`prompts/collaboration-workflow/plan-comment.md` keeps Step 3.

package/.claude/skills/workflow-commands/delegation.md

@@ -1,11 +1,5 @@
 # Delegation decisions — the procedure
 
-Read this file when the first delegation decision arises during a run, not at workflow entry.
-
-Designing, assessing a split and reviewing are judgement; applying a fix the gate has already named is
-not. The steps whose answer is already decided go to a cheaper execution tier, and the judgement stays
-where it is.
-
 **Ask before delegating any step of a run**, and use what it answers:
 
 ```bash
@@ -14,10 +8,8 @@ pnpm josh delegate --list   # the enumeration, and what was rejected and why
 ```
 
 **Never decide it yourself. Anything not on the list is `keep`.** A step earns its place by naming
-**how a wrong result is caught** cheaply in the parent tier, not merely by being unlikely to fail.
-`pnpm josh delegate --list` names both delegatable and rejected steps; a rejected step either has no
-verifier or lets a wrong result propagate too far. The command distinguishes `kept deliberately`
-from `kept by default`. `docs/josh-commands-backlog.md` → "`josh delegate`" carries the full enumeration.
+**how a wrong result is caught** cheaply in the parent tier, not merely by being unlikely to fail
+(`docs/josh-commands-backlog.md` → "`josh delegate`").
 
 **The mechanism is not the unit.** `pnpm josh delegate` covers a run step, a file-disjoint Step 0
 implementation unit (`pnpm josh fanout`), and `epic-child` — an epic's child and a named issue of a
@@ -44,7 +36,9 @@ forecast** — where the guard refuses, not a budget. Brief the unit on what was
 `pnpm josh rule:list` refuses the threshold call, in a lane child too (`pnpm josh delegate --list`).
 
 **Dispatch the unit as the `investigator` agent** (`kit:investigator` in a consumer) — read-only, on
-the `model` its definition names.
+the `model` its definition names, briefed with the planned change and tests (what it returns:
+`.claude/agents/investigator.md`). A `general-purpose` or `Explore` dispatch that investigates is
+briefed to return what that file asks for too.
 
 **The main line does not idle while the unit reads** — the reads of files this run will edit go in
 the same message (the `investigator-foreground` row of `pnpm josh rule:list`); then verify the unit's
@@ -59,3 +53,9 @@ the main line decides what that means and what to change.
 
 **A `general-purpose` dispatch sets `model`** — `sonnet` for routine work, `opus` for judgment (the
 `agent-model` row of `pnpm josh rule:list`).
+
+## A consultation main line hands its investigation to a unit
+
+**With no launcher role, broad reading → an investigation-model unit** — Claude
+`JOSH_INVESTIGATION_MODEL`, Codex `gpt-6.1-sol` (`consultation-investigation` rows).
+Design on `claude-opus-5-5` → `kit:design-consultant` (`.claude/agents/design-consultant.md`).

package/.claude/skills/workflow-commands/entry-sequence.md

@@ -4,42 +4,34 @@
 
 ## The ordered entry sequence
 
-**One call folds the mechanical steps**: `pnpm josh run:entry <N> --to
-<command>` claims the tree, reads the budget, bundles the reads and decides the pre-implementation
-step — steps 1, 3, 4 and 5 below in one round trip. Its `stage #<N>` line says where the run starts
-(`start: reached` redoes nothing — stop), and its `entry #<N> — hold: … · cost: … · verdict: …` line
-carries the three facts the run branches on; a `busy` / `unknown` hold or an `over` budget
-short-circuits with a non-zero exit. The numbered steps are the detail behind each fact.
-
-1. **Claim the working tree — first, before anything else.** `#N`: `pnpm josh run:entry <N> --to
-   <command>` (no `--to` is `fullrun`), which calls `run:hold` as its first step. `new`: bare `pnpm
+**Call `pnpm josh run:entry <N> --to <command>` once, fresh or resumed.** It checks the carried cut
+before the hold: a resume returns its instructions; `fresh` continues steps 1, 3, 4 and 5 below.
+Never call `run:cut --resume` separately. Its `stage` line names the start (`reached` stops);
+its `entry` line gives hold, cost and verdict. `busy` / `unknown` hold or `over` budget exits non-zero.
+
+1. **Claim the working tree after the resume check.** `#N`: `pnpm josh run:entry <N> --to
+   <command>` (no `--to` is `fullrun`), which calls `run:hold` on `fresh`. `new`: bare `pnpm
    josh run:hold`, ahead of the title and the filing. `hold` continues; `busy` / `unknown` stop with a
    `confirmation` Telegram carrying stderr (`run:entry` sends it). `working-tree-hold.md` is the single
    source; a cross-repository target resolves its checkout from `pnpm josh doctor` first
    (`target-repository.md`).
-2. **`in-progress` rides on the hold** — for a `#N`, `run:entry` applies it once the tree is held and
-   the budget allows the run; a `new` entry runs `pnpm josh run:hold --adopt <N>` right after filing,
-   which re-keys the hold and applies it (`fullrun-steps.md`). Every stop that leaves the tree clean
-   ends with `pnpm josh run:release <N>`, which removes the label with the record.
+2. **`in-progress` rides on the hold** — `run:entry` applies it; a `new` entry runs
+   `pnpm josh run:entry <N> --adopt` once filed (`fullrun-steps.md`). Every stop that leaves the tree
+   clean ends with `pnpm josh run:release <N>`.
 3. **Ask the session boundary in the same turn as the hold** — `pnpm josh cost --cut`. `under`
-   continues; `over` (or unanswerable) stops before the title — `run:entry` sends the `confirmation`
-   Telegram and runs `run:release` (`stop notified: …`); by hand only for `new`. **Skip it when
-   dispatched by a batch** (that batch owns the question). The verdict and the model-priced threshold
-   are the command's own.
+   continues; `over` (or unanswerable) stops before the plan; `new` asks it through `--adopt`. **Skip it
+   when dispatched by a batch** (that batch owns the question).
 4. **Gather the mechanical reads — `pnpm josh run:prep <N>`**: `issue:read`'s body and comments
    (`issue-comments.md`), `issue:state`'s state, labels and `human_review`, and `latest:scope`'s
-   dependency scope in one report; a `new` entry runs it once filed. The comment stops, the
+   dependency scope in one report; `new` runs it through `--adopt`. The comment stops, the
    `human_review` stop (`needs-human-review.md`) and the dependency decision are read off it.
-5. **Print the next action — `pnpm josh run:step <N>`** — and follow it into the command's step list.
-   Before implementing, `pnpm josh ms`, then on `run:prep`'s `latest: required`
-   `pnpm josh latest:if-required` (`latest-gate.md`) — never on every run. `run:step` names every later
-   action in order, each read at the point-of-use document `SKILL.md` lists, never re-narrated here
-   (`residency.md` → "順序の問い").
+5. Honor prep's stop and update verdicts first. **`start: gate` skips `run:step`, planning and implementation**;
+   enter the verification chain. Otherwise run `pnpm josh run:step <N>` and follow its step list.
+   `run:entry` has already merged main (`docs/josh-commands-run.md` → "`josh run:entry`"). On `latest: required`, run `pnpm josh latest:if-required` (`latest-gate.md`). Later actions and their
+   point-of-use reads come from `run:step` and `SKILL.md` (`residency.md` → "順序の問い").
 
-**Start the progress watcher once the hold is claimed** — `pnpm josh run:progress --wait` in the
-background, started once and relayed never, and `pnpm josh run:progress --mark` in the same turn as
-every real report (`progress-watcher.md` → "Progress while the run is quiet"). A run dispatched as a
-lane child starts none and never reads that document (`pnpm josh read:set lane-child`).
+**Start the progress watcher once the hold is claimed** — `progress-watcher.md` → "Progress while the
+run is quiet", never fetched: `run:entry` prints it. A lane child starts none.
 
 ## The stop branches
 
@@ -47,14 +39,11 @@ lane child starts none and never reads that document (`pnpm josh read:set lane-c
   `in-progress`; `needs-human-review.md`.
 - **A split** — the assessment (`split-assessment.md` → "The question") finds two or more
   separately-mergeable deliverables over one gate: file the children (each `route:split`) and the epic,
-  then **STOP** with "Please run `backlogrun #<E> --only` to execute this epic." Typing the command
-  approved **one** Issue, never a batch.
+  then **STOP** with "Please run `pnpm josh backlogrun <E> --only` to execute this epic." Typing the
+  command approved **one** Issue, never a batch.
 - **A prerequisite** — file it (`route:tier-a`), `pnpm josh run:pause <M> --for <N>`, and **STOP**
-  with "Please run `backlogrun #<E> --only` to execute this epic"; `prerequisite.md` is the single
-  source of the filing, the pause and the epic:bundle branch.
+  with the same line; `prerequisite.md` is the single source of the filing, the pause and the
+  epic:bundle branch.
 - **An observation** — `observation-filing.md` (ask first if interactive).
 
 **The per-origin filing cap is `prerequisite.md`'s** (`issue:file`'s own step); on its refusal, stop and report.
-
-**The `into <target>` suffix** (a `new` entry) inserts the artifact into a named epic —
-`into-target.md`, read when the suffix is typed.

package/.claude/skills/workflow-commands/followup.md

@@ -6,25 +6,29 @@ stops before the commit.
 
 ## Run `pnpm josh followup`
 
-Run it in the foreground after `pnpm josh git` and after every required review disposition:
+After `pnpm josh git` and required review dispositions, run:
 
 ```bash
-pnpm josh followup "<title> #<N>" --notify-message-file <report-file>
+pnpm josh followup "<title> #<N>" --notify-message-file .josh/tmp/report.md
 ```
 
-The report uses the session language: plain `Cause:`, `Fix:` and `Result:` lines, then `Details:`
-bullets. Use the file option whenever it contains a command or path.
+Write the report in the session language; use the shape and file option in "The options" below.
 
 It waits for required CI, checks CodeRabbit and top-level AI review comments, sends the completion
 Telegram, merges by default, posts the Issue report, closes completed epics, removes `in-progress`,
-and releases the hold. Only `--no-merge` stops the merge; `--merge` is a deprecated no-op. **A pull
+and releases the hold. `--no-merge` stops the merge; `--merge` is a deprecated no-op. **A pull
 request already merged by hand** (a `prrun` stop) runs only the post-merge tail; a report already on the
 Issue is not posted twice, so re-running is safe. Keep the default Issue target. Ignore a finding only
 after verifying it is inapplicable; rate-limit text is not a finding.
 
-**A red rate-limited CodeRabbit check is cleared by a retrigger, not a bypass.** `followup` waits
-out the window (≤30 min) and posts `@coderabbitai review` once per pull request. On its
-no-retrigger note, do that and rerun `followup`. Bypassing a second rate limit is Tier C.
+**A PR changing `.github/workflows/**` (adds, deletes, either side of a rename) waits for a human
+merge.** Once CI is green, `followup` leaves it open, labels its Issue `needs-human-merge`, prints the
+PR URL and exits 0 with no completion report; red CI fails as usual. Read the diff on GitHub and merge
+there; `--merge` cannot bypass this stop. Re-run `followup` after merging to finish the tail.
+
+**A rate-limited CodeRabbit check is cleared by a retrigger, never a bypass** (Tier C). `followup`
+waits out each window (≤30 min), posts `@coderabbitai review` ≤3 times per PR, then asks for
+`run:stalled`. On its no-retrigger note, do so and rerun it.
 
 A pre-merge failure stops the run; an unverifiable AI finding or CI failure needing input sends a
 `confirmation` Telegram. A post-merge cleanup failure is named and does not undo the merge; run the
@@ -34,7 +38,7 @@ A CI job red only on tests outside the change → `followup` reruns it once, aft
 when main moved a failed test (`scripts/followup/followup-main-move.ts`).
 
 After the merge `run:tail` returns to the default branch — `ship` runs it; after a bare `followup`, run
-`pnpm josh run:tail <N>`. In a lane the parent uses `pnpm josh lane:close <N>`. Never delete the branch unless requested. The sections below are read when the output needs reading.
+`pnpm josh run:tail <N>`. In a lane the parent uses `pnpm josh lane:close <N>`. Never delete the branch unless requested.
 
 ## The options
 
@@ -55,8 +59,8 @@ Invoking `fullrun` is itself the explicit authorization to merge.
   `confirmation` Telegram and exits non-zero — fix and re-run. SonarCloud is carried by the required
   `SonarQube` check.
 - **Verify a CodeRabbit finding before bypassing it.** Never pass `--coderabbit-ignore-reason`
-  reflexively: a SHA pin flagged "not matching the tag" is checked with `gh api
-  repos/<owner>/<repo>/commits/<tag> --jq '.sha'`, and the bypass cites that command.
+  reflexively: a SHA pin flagged "not matching the tag" is checked with `pnpm josh pin:verify
+  <owner/repo> <tag> <sha>`; bypass only on `match`, citing its printed line.
 - **The merge is `followup`'s, not yours** — `.claude/settings.json` refuses `gh pr merge` and its
   `gh api` spellings (`operating-rules.md` → "git-rules"). Do **not** pass `--delete-branch` unless asked.
 - **A failed merge** (branch protection, a conflict) is reported and stops the run — never retried with
@@ -84,7 +88,7 @@ josh release` runs" below.
 A `failure` Telegram is sent **by hand, exactly once**, and only when recovery is given up:
 
 ```bash
-pnpm josh notify --task-type failure --issue-url "<issue-url>" --body-file <reason-file>
+pnpm josh notify --task-type failure --issue-url "<issue-url>" --body-file .josh/tmp/failure.md
 ```
 
 ## What the output means
@@ -105,7 +109,7 @@ pnpm josh release:scope          # → required | skip | unknown
 
 | It answers | What it means                                                    | What the run does                                                                 |
 | ---------- | ---------------------------------------------------------------- | --------------------------------------------------------------------------------- |
-| `required` | main has taken at least one merge since the version last changed | Close the completion report with the release request, naming `pnpm josh release` |
+| `required` | main has taken at least one merge since the version last changed | Close the completion report with the `request:` line it prints                   |
 | `skip`     | the count is zero — nothing is waiting to ship                   | Say so in one line and finish                                                     |
 | `unknown`  | the count could not be read                                      | **Report it as `unknown`** — it is never read as `skip`                           |
 
@@ -113,7 +117,5 @@ pnpm josh release:scope          # → required | skip | unknown
 outward-facing and effectively irreversible, so Tier C. A person types it in the primary checkout, on
 the default branch, with a clean tree.
 
-**On `required`, the release request cites the open release Issue** — the one `issue:file --release` / `issue:release <N>` links blockers to — with a number-link
-(`prompts/collaboration-workflow/issue-citation.md`). List it with
-`gh api 'repos/{owner}/{repo}/issues?labels=release&state=open' --jq '.[].number'`; when none is
-open, the request names `pnpm josh release` alone.
+**On `required`, it prints `release_issue: [#N](url)|none|unknown` and the `request:` line** — citing the
+open release Issue `issue:release <N>` links blockers to, or naming `pnpm josh release` alone.

package/.claude/skills/workflow-commands/fullrun-lane.md

@@ -0,0 +1,11 @@
+# Headless lane child
+
+- Read this entry for a fresh `fullrun #N` lane child; follow a resume prompt before entry reads. Do not read `SKILL.md`, `fullrun.md` or `entry-sequence.md`.
+- Run `pnpm josh run:entry <N>` first. Follow its hold, stage and prep verdicts; `start: reached` stops, `start: gate` enters the verification chain without planning or implementation; `at: pr-returned` → its `=== returned for a fix ===` lines (`scripts/run/run-pr-return.ts`). Follow `run:cut --resume`'s printed section when resuming.
+- Otherwise run `pnpm josh run:step <N>` and carry out its next action and printed governing section. Read `fullrun-steps.md` only for the named step's detail.
+- Before implementation, present the work summary and tests (`prompts/collaboration-workflow/report-format.md`). Follow prep's investigation dispatch; read only edit targets in the main line.
+- Before the gate, issue `pnpm josh run:cut <N>` alone. Follow its printed section; the verification and shipping chain is printed by `run:step` / `run:chain` (`chain-rule.md` → "A lane child"). `followup.md` → "Run `pnpm josh followup`" is printed by that command; do not fetch it.
+- Before detaching shipping, read `background-commands.md` → "Background the gate and push".
+- A decision, split, prerequisite or failure that needs a person or parent → read `backlogrun-park.md` → "park and continue". Do not ask a person, send a confirmation notification, or file follow-up Issues; return observations to the parent.
+- Do not start a progress watcher, update dependencies, run the parent's retrospective, or merge/carry the batch. The parent owns those actions.
+- Files passed as `*-file` arguments go under `.josh/tmp/`. Fetch one document per call with `pnpm josh doc:read <file>`; a pointer `X.md` → "Heading" is read with `pnpm josh doc:section <file.md> "<heading>"` at that section only.

package/.claude/skills/workflow-commands/fullrun-steps.md

@@ -10,16 +10,14 @@ File Issues with `pnpm josh issue:file` (it applies the classification labels);
 1. **`in-progress` is already on the Issue** — `run:entry` applied it once the tree was held and the
    budget allowed the run, and `run:release <N>` takes it back off.
 2. Read the Issue and its comments off `run:entry`'s `run:prep` report (`issue-comments.md`).
-3. **Record the agreed plan** with `pnpm josh issue:plan <N> --body-file <path>`, adding
+3. **Record the agreed plan** with `pnpm josh issue:plan <N> --body-file .josh/tmp/plan.md`, adding
    `--title "<title>"` when the title is not in English or can be phrased more clearly (the plan goes
    into the body when it is blank and its author has write access, otherwise into a comment; its
    `### 影響を受ける既存の利用者` section is drafted with `pnpm josh plan:consumers` — `kickoff.md` step 4).
-4. Run `pnpm josh ms`, then update dependencies only where the `run:prep` report answers
-   `latest: required` — `latest-gate.md` is its single source, and on `required` load the
-   `dependency-update` skill afterwards. **A dispatched lane child skips `pnpm josh ms`** — it refuses
-   in a lane, and ship's sync brings the latest default in before its gate. The parent runs
-   `pnpm josh ms` in the primary checkout, never the child — `backlogrun-lanes.md` and
-   `backlogrun-child.md` are the single sources.
+   In a lane child it runs `lane:plan` on the plan's paths (`timeout` 600000): `docs/josh-commands-backlog.md` → "`josh issue:plan`".
+4. `run:entry` has synchronized the tree; update dependencies only where the `run:prep` report answers
+   `latest: required` — `latest-gate.md` is its single source. Load the `dependency-update` skill
+   after an update. **A dispatched lane child skips entry synchronization**; ship syncs before its gate.
 5. Implement. The `plan` event `run:board` draws 📝 from is written by code — by `run:entry` for a
    `run:planned` issue, else at the first implementation edit — never by hand; no cut follows the
    plan — a lane child's context is bounded by the threshold-gated implementation cut alone.
@@ -31,35 +29,29 @@ File Issues with `pnpm josh issue:file` (it applies the classification labels);
    ...\nFix: ...\nResult: ...\n\nDetails:\n- <change1>\n- <change2>"`. **`pnpm josh followup` waits
    for CI, verifies AI review findings, sends the completion notification, then merges; if blockers
    are found it exits non-zero — fix and re-run.**
-8. `run:tail` returns the checkout to the default branch (`main:sync`) after the merge; a lane child's
-   `run:tail` skips that step and the parent syncs the primary checkout.
+8. `run:tail` returns the primary checkout to the default branch (`main:sync`) after the merge;
+   every linked checkout skips that step and keeps its branch and port seat.
 
 ## The `fullrun new` step list
 
 `kickoff new` + `fullrun #N` in one run. Steps: (1) Derive an English title, or use the provided one.
-(2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file>`,
+(2) Create Issue: `pnpm josh issue:file "<title>" --body-file .josh/tmp/body.md --over-cap`,
 with the labels `kickoff.md` → "Words typed after `new`" maps (per
 `prompts/collaboration-workflow/issue-template.md`) — its duplicate scan runs first, and a candidate
 that covers the same work stops the run rather than filing a second Issue (`issue-scout.md`). Capture
-`<N>`. (3) `pnpm josh run:hold --adopt <N>` — re-keys the bare hold to `<N>` and applies `in-progress`;
-every later stop releases with `run:release <N>`. (4) Record the agreed plan
-in the session language: `pnpm josh issue:plan <N> --body-file <path>` (its consumers section as in
-`kickoff.md` step 4). (5) `pnpm josh stash:push "fullrun new: pre-existing changes"`. (6) `pnpm josh ms`. (7)
-`pnpm josh run:prep <N>`; on `latest: required` run `pnpm josh latest:if-required` and load the `dependency-update`
-skill; on `skip` neither runs (`latest-gate.md` is the single source). If (5) answered `stashed`,
-`pnpm josh stash:pop "fullrun new: pre-existing changes"`. (8) Implement. (9) Run the verification gate (as in `chain-rule.md`; only the first review round
-runs here). (9a) **Ask `pnpm josh review:round2 --record <N>` whether a second round is due**, once
-round 1 is fixed and recorded, before the commit. (10) Where the tree was edited after the first gate
-started, re-run `pnpm josh gate` and join it. (11) `pnpm josh git -y "<title> #<N>"` — the pull request
-opens here, between the two rounds. (11a) Run the **second round** now beside the CI, where (9a)
-answered `required` (brief `pnpm josh review:brief --round 2`); a finding it fixes in place is pushed
-before its gate. (12) File whatever the review round cap routed to branch 2 with `pnpm josh issue:file`
-(it runs `epic:bundle` on each), and where (9a) answered `skip` record the skip on the Issue. (13) **Where no second
-round was due** (9a `skip`), fold steps (10)–(13) and the release bookkeeping into one call — `pnpm josh
-ship "<title> #<N>" --notify-message "..."` (gate → commit/push/PR → the CI-wait `followup` → `run:tail`,
-stopping at the first failed step); **where a second round ran**, the PR opened
-at (11) and the region stays separate — `pnpm josh followup "<title> #<N>" --notify-message "..."` then
-`pnpm josh run:tail <N>`. (14) **Close the completion summary with `run:tail`'s `release:scope`
+`<N>`. (3) `pnpm josh run:entry <N> --adopt` — the `#N` entry with the bare hold re-keyed to `<N>`
+(`run:hold --adopt`) for its claim; before its reads it stashes pre-existing changes, synchronizes
+as every entry does and pops the stash, and a failed step stops with the stash kept, naming it
+(`scripts/run/entry/run-entry-sync.ts`); every later stop releases with `run:release <N>`. (4) Record the
+agreed plan in the session language: `pnpm josh issue:plan <N> --body-file .josh/tmp/plan.md` (its consumers
+section as in `kickoff.md` step 4). (5) On (3)'s `latest: required` run
+`pnpm josh latest:if-required` and load the `dependency-update` skill; on `skip` neither runs
+(`latest-gate.md` is the single source). (6) Implement. (7) Run round 1 of the verification chain (`chain-rule.md` → "Run the review-to-merge
+chain"). (8) File whatever the review round cap routed to branch 2 with `pnpm josh issue:file` (it
+runs `epic:bundle` on each). (9) Ship in one call — `pnpm josh ship "<title> #<N>" --notify-message
+"..."`, or `pnpm josh ship --review "<title> #<N>" --notify-message "..."` after a High/Medium round 1:
+it asks `review:round2 --record <N>` itself and runs a due round 2 beside the gate, before the commit
+(the same chain step 5). (10) **Close the completion summary with `run:tail`'s `release:scope`
 answer** (`followup.md` → "When `pnpm josh release` runs").
 
 ## The release ask — the last step of either form
@@ -67,12 +59,13 @@ answer** (`followup.md` → "When `pnpm josh release` runs").
 **One call folds the post-merge bookkeeping**: after the merge, `pnpm josh
 run:tail <N>` commits ledger lines written outside any issue's run (`observations:flush`), reads the
 completion citations (`issue:cite`, given the closed issue and any follow-ups filed this run) and
-decides the release scope (`release:scope`) in one round trip, joining each under its own header. **On
-the clean path `run:tail` runs inside `pnpm josh ship`** as its report step, so it is a standalone call
-only where a second round kept the ship region separate. It folds only bookkeeping — the
+decides the release scope (`release:scope`) in one round trip, joining each under its own header. **`run:tail`
+runs inside `pnpm josh ship`** as its report step, with or without `--review`. It folds only bookkeeping — the
 release ask below stays the single source of what `required` means and the Tier-C publish boundary; a
-`backlogrun` child still leaves `observations:flush`, `issue:cite` and the release ask to the batch's
-own end.
+`backlogrun` child leaves `observations:flush` to each drain marker in
+`backlog:offer` (`scripts/backlog/backlog-offer-cli.ts`): before the marker is written it synchronizes
+the primary checkout to the default branch and awaits the flush, ahead of the retrospective; a failure
+prints one line and keeps the batch ending. `issue:cite` and the release ask remain the batch's own end.
 
 Once the merge is done, `pnpm josh release:scope` says whether a release is owed — `required`, `skip`
 or `unknown`, and `unknown` is never read as `skip`. On `required` the completion summary closes with

package/.claude/skills/workflow-commands/fullrun.md

@@ -15,11 +15,10 @@ run's next single action. `chain-rule.md`, `followup.md`, `background-commands.m
 
 ## The lane-child seam
 
-- **A lane child asks whether it is a resume first — `pnpm josh run:cut --resume <N>`** (`run:entry` asks it
-  before the hold); on `resume` it skips the title, plan, hold and implementation and goes to the gate. At the pre-gate
-  boundary of `chain-rule.md` step 1 — step 0's ship fallen through, before the gate — it takes the cut with
-  `pnpm josh run:cut <N>` (the ordered step in `chain-rule.md`, which names the cut's single source),
-  and it records any park on the Issue before the stop notify. A run that is not a lane child never
-  reads the cut's document.
+- **A lane child enters once with `pnpm josh run:entry <N>`**, which checks the carried cut before
+  the hold and completes the fresh entry itself; never call `run:cut --resume` separately. It takes
+  the cut with `pnpm josh run:cut <N>` at the pre-gate boundary of
+  `chain-rule.md` step 1. On a non-trivial answer `run:cut` prints the section that acts on it. A run
+  that is not a lane child never reads the cut's document.
 - **`resume: halfrun`** adopted a stopped `halfrun`: gate in full; `resume: prrun-*` a stopped
   `prrun`; `working-tree-hold.md`.

package/.claude/skills/workflow-commands/halfrun.md

@@ -16,7 +16,7 @@ entry sequence and the stop branches are `entry-sequence.md`.
 ## The step list
 
 `halfrun #<N>`: read Issue #N and its comments → **record the agreed plan**, normalizing
-the title (`pnpm josh issue:plan`, same as `fullrun`) → `pnpm josh ms`, then on `run:prep`'s
+the title (`pnpm josh issue:plan`, same as `fullrun`; `run:entry` has merged main) → on `run:prep`'s
 `latest: required` `pnpm josh latest:if-required` (`latest-gate.md`; the `dependency-update` skill) → implement → run the **full verification gate** (refactor →
 start `pnpm josh gate` beside a subagent `/code-review` with the brief `pnpm josh review:brief` prints,
 join the gate before the stop, iterate to no high/medium findings, within the round cap (`prompts/review.md`) → `pnpm josh
@@ -31,12 +31,9 @@ back with fixes, treat each as a new round: implement, re-run `pnpm josh gate`,
 (it sends the `confirmation`), stop again.
 
 `halfrun new` or `halfrun new "<title>"`: `kickoff new` + `halfrun #<N>` (no Issue exists yet). Steps
-mirror `fullrun new` (1)–(8): derive an English title (or use the provided one) → create the Issue
-(`pnpm josh issue:file "<title>" --body-file <body-file>`, with the labels
+mirror `fullrun new` (1)–(6): derive an English title (or use the provided one) → create the Issue
+(`pnpm josh issue:file "<title>" --body-file .josh/tmp/body.md --over-cap`, with the labels
 `kickoff.md` → "Words typed after `new`" maps, body per
-`prompts/collaboration-workflow/issue-template.md`; its duplicate scan is read per `issue-scout.md`) → `pnpm josh run:hold --adopt <N>` (as `fullrun new` (3)) → post the agreed plan → stash
-any pre-existing changes with `pnpm josh stash:push "halfrun new: pre-existing changes"`, popped
-after `stashed` with `pnpm josh stash:pop "halfrun new: pre-existing changes"` →
-`pnpm josh ms` → `pnpm josh run:prep <N>`, and on `latest: required` `pnpm josh latest:if-required` → implement → run the gate (as above, `pnpm
+`prompts/collaboration-workflow/issue-template.md`; its duplicate scan is read per `issue-scout.md`) → `pnpm josh run:entry <N> --to halfrun --adopt` (as `fullrun new` (3), the tree sync included) → post the agreed plan → on the entry's `latest: required`, `pnpm josh latest:if-required` → implement → run the gate (as above, `pnpm
 josh test:e2e` run by **you**) → `pnpm josh run:hold <N> --halfrun-stop` (it sends the `confirmation`)
 → **stop**.