@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/.claude/skills/workflow-commands/backlogrun-park.md

@@ -28,11 +28,12 @@ parks, re-dispatches or files.
 ## `needs-human-review` — the one stop that is not a park
 
 A child carrying **`needs-human-review`** stops `halfrun`-shaped and **the whole run ends there**:
-implementation and the gate run, nothing is committed, the tree is left dirty and unstashed, a
-`confirmation` Telegram carries the resume command, and the remaining children are not started.
+implementation and the gate run, nothing is committed, the tree is left dirty and unstashed,
+`pnpm josh run:hold <N> --human-review-stop` sends the `confirmation` Telegram with the resume command
+and the lane directory, and the remaining children are not started.
 
 **The child goes on holding its repository**, and **its lane is left open and untouched**. **Name the
-lane directory in the stop report and in the Telegram.** Lanes in flight finish; no new lane opens.
+lane directory in the stop report.** Lanes in flight finish; no new lane opens.
 
 **Never apply or remove the label** — a person's alone (`needs-human-review.md`, the single source).
 
@@ -42,8 +43,7 @@ When a child hits something only a person can decide (→ "Only a person's judge
 `needs-decision`"), **park the child and keep going**:
 
 ```bash
-gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'
-pnpm josh issue:comment <N> --body-file <path>   # what needs deciding, and the options
+pnpm josh run:park <N> --body-file <path>   # what needs deciding, and the options; applies needs-decision
 ```
 
 `in-progress` stays; the parked child does **not** hold the repository (`needs-decision` takes
@@ -60,7 +60,7 @@ still filed at once, and a workaround is still forbidden. `epic:bundle`'s `ask`
 **Removing the label is Tier A — do it without asking**, once the decision is recorded:
 
 ```bash
-gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/needs-decision 2>/dev/null || true
+pnpm josh run:park <N> --clear   # succeeds when the label is already off
 ```
 
 **The released child goes back to a lane, never into the parent's own context** — `pnpm josh
@@ -72,7 +72,9 @@ lane:launch <N>`.
 
 - a design choice nobody has made;
 - a Tier B toss-up, or a Tier C action (`CLAUDE.md` → "Decision autonomy");
-- an upstream defect in another package, whose wait-or-defer is the person's (`upstream-interrupt.md`).
+- an upstream defect in another package, whose wait-or-defer is the person's (`upstream-interrupt.md`);
+- information only the web holds — no lane launches a web tool (`scripts/agent/claude-agent-argv.ts`),
+  so a person fetches it.
 
 It never carries:
 
@@ -81,7 +83,10 @@ It never carries:
 - a wait for the next published release — a dependency, `pnpm josh issue:release <N> --wait`
   (`prerequisite.md`);
 - a defect in the running repository's own run tooling — the run fixes it and resumes
-  (`prompts/collaboration-workflow/upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合").
+  (`prompts/collaboration-workflow/upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合"),
+  its filing carrying the `- 原因の park:` line when it parked or stopped an Issue (`issue-template.md` → I);
+- a wait on an open blocker or a start date — `run:merge` releases it (`run-merge-steps.ts`);
+- a mechanical failure — the driver applies `run:stalled` (`RUN_STALLED_LABEL` in `issue-labels.ts`).
 
 **When in doubt, it is Tier A**: decide, comment the decision, and continue. **A label a mechanical step
 applied** (a failed or abandoned child, a lost merge race) is read against this list once its reason is
@@ -114,22 +119,11 @@ Something else in **this** repository has to land first: not a split, not an ups
 
 1. File the prerequisite `<N>` with `route:tier-a` (Tier A, first-party, no confirmation) — **first**,
    because the next step names it.
-2. **Stash the work in progress**:
-
-   ```bash
-   git stash push -u -m "backlogrun: paused #<M> for prerequisite #<N>"
-   pnpm josh issue:comment <M> --body-file <path>   # what was stashed, and that #<N> must land first
-   ```
-
-   **`-u` is not optional** (new test files are untracked). **Pop it by message, never by position** —
-   `pnpm josh stash:pop "backlogrun: paused #<M> for prerequisite #<N>"` — when `epic:next` offers `<M>`
-   again, after its `pnpm josh ms`; expect conflicts.
-3. `pnpm josh epic --add <E> <N> --before <M>` — row, declaration and `blocked-by` in one command;
-   never a hand edit. **With no epic**, record `<M>` blocked by `<N>` alone with the `gh api
-   …/dependencies/blocked_by` call in
-   `prompts/collaboration-workflow/issue-template.md` → "複数 Issue に分割するときの epic Issue", step 4.
-4. **Remove `in-progress` from `<M>`** — `pnpm josh run:release <M>`; a labelled child is never offered again.
-5. **Do not park.** Back to step 1 of the loop; `epic:next` hands back the prerequisite first.
+2. **`pnpm josh run:pause <M> --for <N>`** — the stash, the comment naming its `stash:pop`, `<M>`
+   blocked by `<N>` (the epic's row and declaration too) and `run:release <M>` in one call
+   (`prerequisite.md`). Pop the stash the comment names when `epic:next` offers `<M>` again, after its
+   `pnpm josh ms`; expect conflicts.
+3. **Do not park.** Back to step 1 of the loop; `epic:next` hands back the prerequisite first.
 
 **A stop a dependency can express is never parked**, including a defect in this repository's own gate
 or run tooling — `prerequisite.md`.

package/.claude/skills/workflow-commands/backlogrun-progress.md

@@ -26,7 +26,7 @@ the lane and comments itself; act on the token.
 | `complete` | Record the root done (`backlogrun-steps.md` → "The session cut is inside the invocation") and post the epic summary |
 | `over` | Hand the lanes over and take the cut — "The hand-off" below |
 | `human-review` | Stop, leave `in-progress` on; send a `confirmation` only where the child ran in this session's own context (`needs-human-review.md`) |
-| `stop` / `environment` | Report the parked children (or the outage) and stop |
+| `stop` / `environment` | Report the parked children (or the outage, or the `/login` an authentication failure needs) and stop |
 | `resumed` | `lane:await <N>` it again |
 | `retry` / `busy` | Re-read the child |
 
@@ -44,9 +44,8 @@ summary, and who propagates" below.
 **The check is asked at every merge, and delegation does not excuse it** — `pnpm josh cost --cut`
 after every child's merge and `pnpm josh ms`, never wired to `pnpm josh delegate epic-child`. Crossing it **hands the session off to a fresh one,
 carrying the budget** (`backlogrun-steps.md` → "The session cut is inside the invocation"); it is not a
-stop. The threshold is `CONTEXT_CUT_THRESHOLD` in `scripts/cost-runtime/context-cut-threshold.ts`
-(135,000, shared by the scheduler entry, hand-off and the lane worker cut, `pre-gate-cut.md` → "The
-implementation-phase cut").
+stop. The threshold is the one `pnpm josh cost --cut` prints, priced at the session's model and
+shared by the scheduler entry, hand-off and the lane worker cut (`pre-gate-cut.md` → "The threshold").
 
 | It answers | What the run does |
 | --- | --- |
@@ -69,7 +68,7 @@ and output path; fill a missing path with `pnpm josh lane:output <N> <path>`:
 - **`--cut` answers `capped`** (`MAX_CUTS`) — **do not `run:wake` or hand off**;
   carry this session on and re-ask at the next merge.
 
-The hand-off report's format is `backlogrun-handoff-report.md`. **This is not a failure and not a
+The hand-off report is `pnpm josh run:report --handoff` (`backlogrun-handoff-report.md`). **This is not a failure and not a
 park** — nothing is labelled, stashed or filed.
 
 ## Resuming after a cut

package/.claude/skills/workflow-commands/backlogrun-recovery.md

@@ -20,6 +20,7 @@ pnpm josh run:liveness <N> --output <absolute path> --process <command lines nam
 | Answer | What the parent does |
 | --- | --- |
 | `alive` | Wait on `lane:await` again; touch nothing |
+| `paused` | Tell the person; neither wait nor recover (`docs/josh-commands-run.md` → `josh run:liveness`) |
 | `settled` | Re-read with `pnpm josh run:status <N>` and take the branch its state section says |
 | `undetermined` | Read the trace that failed and ask again. **A second in a row on the same child is a fault in the check**: send a `confirmation` naming the trace and stop — never escalate it to `stopped` |
 | `stopped` | The recovery below |
@@ -27,24 +28,23 @@ pnpm josh run:liveness <N> --output <absolute path> --process <command lines nam
 **On `stopped`, re-read with `pnpm josh run:status <N>`.** **A re-read carrying `needs-decision`** — the
 unit parked it, then stopped: leave the label on and count nothing. Otherwise, while `state: OPEN`:
 
-1. **Stash the half-finished work** — `git stash push -u -m "backlogrun: stopped unit for #<N>"` — and
-   record it on the Issue; it is popped by message, `pnpm josh stash:pop "backlogrun: stopped unit for
-   #<N>"`, never positionally.
+1. **Stash the half-finished work** — `pnpm josh stash:push "backlogrun: stopped unit for #<N>"` — and
+   record it on the Issue; it is popped with `pnpm josh stash:pop "backlogrun: stopped unit for #<N>"`.
 2. **Classify and act in one call** — `pnpm josh run:merge <N> --output <path>` (`--epic <E> --repo
    <owner/repo> --owner "$PPID"` for a named epic), **the same composite a returned child takes**. It
    tells an `outage` (re-dispatched with its session resumed, uncounted, bounded by
-   `CONSECUTIVE_OUTAGE_LIMIT`) from an `abandoned` child (parked `needs-decision` and counted), and drops
+   `CONSECUTIVE_OUTAGE_LIMIT`) from an `abandoned` child (parked `run:stalled` and counted), and drops
    the stale `in-progress` itself.
 3. **Act on the token it printed** — `backlogrun-progress.md` → "Running a named epic's children".
 
 ## A person withdraws a running child
 
-On a person's instruction to drop a running child's issue, run `pnpm josh lane:withdraw <N>
+On a person's instruction to drop a running child, run `pnpm josh lane:withdraw <N>
 --reason "<their reason>"` — `docs/josh-commands.md` → "`josh lane:withdraw`".
 
 ## Conflicts are not predicted
 
-**This path is the fallback**: every `fullrun` runs `pnpm josh main:merge` ahead of the gate
+**This path is the fallback**: every `fullrun` merges origin/main ahead of the gate
 (`chain-rule.md` → "origin/main is merged in before the gate"), so it covers an overlap that lands on
 `main` *after* it. **Nothing here forecasts which children will overlap** — a conflicting pull request
 comes back `mergeStateStatus: DIRTY`, which `git-pr-checks-eval.ts` reads as a **failure**, so `pnpm josh

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

@@ -20,13 +20,13 @@ judgement** — a Tier B toss-up or a Tier C action inside it; `--no-auto-ok` wi
 
 ### The brake that replaces the promise
 
-**Every bound is counted in the carry record rather than in the conversation:**
+**Every bound is counted by a record or a guard rather than in the conversation:**
 
 | The bound | What it limits | Counted by |
 | --- | --- | --- |
 | `--max` | merges per invocation — a run's own filing competes for it | `run:carry --merged` |
 | `--idle` (8 hours unless typed) | how long the run waits once nothing can proceed | `--active`, the moment its hands became free |
-| **Ten filings per invocation** | additions to the pool on **every** filing route (`prerequisite.md`) — `route:tier-a`, `route:interrupt` and a review branch-2 filing are exempt from the depth test (`observation-filing.md`), never from this ceiling | `run:carry --filed` |
+| **Ten filings per originating work item** | additions to the pool on **every** filing route (`prerequisite.md`) — `route:tier-a`, `route:interrupt` and a review branch-2 filing are exempt from the depth test (`observation-filing.md`), never from this ceiling | `scripts/issue/issue-file-cap.ts` |
 | The WIP cap on open issues | the pool across invocations | `prompts/collaboration-workflow/wip-cap.md` |
 
 **This section is the single source of how the `epic:bundle` obligation and this boundary meet.**
@@ -39,7 +39,8 @@ runs in a delegated unit"), read back with `pnpm josh issue:state <N>`. `pnpm jo
 #N2 …` renders the order (`scripts/backlog/backlog-named.ts`).
 
 **A named issue that cannot finish parks, and the rest of the named list is skipped**; the run drains
-the pool and reports what was not started (`backlog_named.after_failure`). A `needs-human-review` named
+the pool and reports what was not started (`backlog_named.after_failure`). One already closed or parked
+when offered is booked done alone and skips nothing. A `needs-human-review` named
 issue stops the whole run. **`--only` runs the named list and stops there, draining no pool** — a
 failure ends the run, and `--only` with no named issues is refused (`backlog_named.startup`).
 
@@ -66,7 +67,7 @@ record is the parent loop's; a lane never touches it**. Count with `--merged <N>
 | `resumed` | Take the budget from `--json`, report the plan again, read `backlogrun-progress.md` → "Resuming after a cut" |
 | `busy` / `mismatch` / `unreadable` / `unknown` | **Stop; do not open a lane** — report what it printed; never resume into another invocation's record |
 | `over` | **End the conversation**; retype the invocation in a fresh session |
-| `standing` | **Stop; do not open a lane**: report `pnpm josh run:carry --resume "<invocation>" --owner "$PPID"` and `pnpm josh run:carry --end` for the person to choose — a crash from a run-tooling defect this run has since fixed you resume yourself (`upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合") |
+| `standing` | **Stop; do not open a lane**: report `pnpm josh backlogrun --restart` (continue the run) and `pnpm josh run:carry --end` (discard it) for the person to choose — a crash from a run-tooling defect this run has since fixed you resume yourself (`upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合") |
 **End the record when the run ends** — `pnpm josh run:report`, then `pnpm josh run:carry --end`, **never
 batched with it**, and `pnpm josh run:wake --stop` in the same turn. **A run that ends by _stopping_**
 (a `stop` verdict or the consecutive-failure guard) **ends with `pnpm josh run:carry --end --stopped
@@ -91,21 +92,21 @@ Waiting on a person, Out of scope) in the session language, with any truncated-l
 **Settle every `needs-decision` issue the plan listed in one pass**, from one `pnpm josh issue:read <N>
 <N> …` call (`issue-comments.md`):
 
-- **An answer already in the issue** — record it as a comment and **remove the label** (Tier A).
+- **An answer already in the issue** — record it as a comment and **remove the label** with `pnpm josh run:park <N> --clear` (Tier A).
   **Never measure in order to decide**: a question needing a benchmark or a run stays labelled.
 - **A person's judgement** — apply `needs-decision` (`backlogrun-park.md` → "Only a person's judgement
   carries `needs-decision`").
 - **Order and isolate** — a native `blocked-by` where one must land first; `run:solo` on all three
   `backlogrun-lanes.md` → "A solo run" conditions, **every other one `run:lane`**, commenting the
   reason.
-- **`priority:high`** only on a cited ground (a stated deadline, a person's written policy), commented;
-  **never remove it**.
+- **`priority:critical` / `priority:high`** are applied at filing by `pnpm josh issue:file` from the
+  body's `- 優先度:` declaration (`issue-template.md`); **only a person removes them**.
 - **Report `pnpm josh backlog:plan --waves`** with the plan, never an order derived by hand; then start
   the loop, leaving whatever is still labelled parked.
 
-**`needs-decision`, `run:solo`, `run:lane` and `priority:high` are the only workflow labels a run
-applies by hand** — never `needs-human-review` (`needs-human-review.md`), and `auto-ok` only through
-`pnpm josh issue:file` or `pnpm josh auto-ok:judge`.
+**`needs-decision`, `run:solo` and `run:lane` are the only workflow labels a run applies by hand** —
+never `needs-human-review` (`needs-human-review.md`), the priority labels only through
+`pnpm josh issue:file`, and `auto-ok` only through it or `pnpm josh auto-ok:judge`.
 
 ## The loop
 
@@ -134,7 +135,7 @@ verdicts and stops are the driver's own.
 | Step | Where it is defined |
 | --- | --- |
 | `run:carry --begin` + `run:wake --start` before the plan; `run:carry --end` + `run:wake --stop` at the end | "The session cut is inside the invocation" above |
-| `pnpm josh ms`, `pnpm josh latest:scope`, `lane:prune` in the primary checkout before the first lane | `backlogrun-lanes.md` → "Once per repository, before the first lane opens" |
+| `pnpm josh ms`, `pnpm josh latest:if-required`, `lane:prune` in the primary checkout before the first lane | `backlogrun-lanes.md` → "Once per repository, before the first lane opens" |
 | `josh latest` on `required` only, once, never in a lane | `backlogrun-child.md` → "`josh latest` runs once per session, not once per child" |
 | `pnpm josh run:hold <N>`'s preflight, before each child not in a lane | `docs/josh-commands-run.md` → "`josh run:hold`" |
 | `pnpm josh run:progress --wait` in the background, `--mark` at every real report | `progress-watcher.md` → "Progress while the run is quiet" |

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

@@ -70,7 +70,7 @@ reference is read as a section").
 | Guard | Limit | On reaching it |
 | --- | --- | --- |
 | Children per run | 30 | Stop and report; an epic this large should be split. |
-| Issues filed per run | 10 | Stop and report; a run filing more than this has lost the plot. |
+| Issues filed per originating work item | `prerequisite.md`'s cap (`issue:file` refuses the 11th) | Stop and report. |
 | Consecutive child failures | 3 | Stop and report; something is wrong with the environment, not the children. |
 
 A failure that is not consecutive parks its child and the run continues.

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

@@ -5,39 +5,51 @@
 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**: `pnpm josh main:merge`, the self-check (`prompts/review.md` → "Before round 1 —
-   the implementer's self-check"), the scoped pair, `pnpm josh ship --detach --review
-   "<title> #<N>"` (`--cite <N>`), then **end the turn** on `launched`/`busy`. A stop relaunches a child
+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) 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 (`scripts/run/ship/run-ship-next.ts`); the supervisor skips a recorded round 1.
-   `failed` → step 1. A backgrounded `ship` issued alone is moved to the foreground by the hook
-   rather than refused.
-1. Run `pnpm josh main:merge`. **Then issue `pnpm josh run:cut <N>` alone, before the scoped pair and
+   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"), run the final scoped lint/test pair and
-   `pnpm josh run:review`: it starts `pnpm josh gate` in the background and prints the `/code-review`
-   brief in one call, so the two overlap. Launch the `/code-review` subagent as the `general-purpose`
-   agent type with that brief and the alias of its `model=` id (`claude-opus-5-5` → `opus`) (every
-   tool, so `--fix` applies; never a guessed type name).
+   (`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`)
+   (`.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; it exits non-zero on a red gate. Fix any red check, then rerun the affected scoped check
+   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.
 4. Route the attested verdict mechanically:
    - 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 it, then ask `pnpm josh review:round2 --round-1-closed`. On `skip`, record
-     the skip on the Issue. On `required`, open the PR first and run the verification pass from
-     `pnpm josh review:brief --round 2` beside CI.
+   - 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).
    - 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.
-   Any round-1 fix runs its affected scoped check and the gate before `git -y`.
+   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>
-   [<category>:<severity>:<file> ...]` — a clean round records one zero-finding line. **A round 2 that
+   ['[<disposition> ]<category>:<severity>:<file> — <reason>' ...]` (each one quoted argument; none if
+   clean; 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>`).
@@ -49,8 +61,8 @@ Review results and successful pushes are never turn boundaries.
    `pnpm josh git -y "<title> #<N>"`, round 2 beside CI, then `pnpm josh followup`.
 
 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
-`pnpm josh ms` 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 `josh ms` refuses; the parent closes it. Managed config claims are reported by `followup` and do not stop the merge.
+`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.
 
@@ -61,17 +73,20 @@ These are the gate → review → PR → merge facts other documents cite; this
 
 - **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.
-- **origin/main is merged in before the gate** — `pnpm josh main:merge` is the last edit, so the scoped
-  pair and the gate run once over it; a conflict fires `backlogrun-recovery.md` → "Conflicts are not
+- **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`
   refuses when uncommitted changes touch a path the default branch also changed, or the index holds
   unresolved or staged paths — commit first with `pnpm josh git -y`, rerun, and **never stash around the
   merge**. A merge stopped on a conflict: remove the markers, then `pnpm josh git -y` stages the
   resolution and records the merge commit — **Tier A**; a lane child never asks a person for `git add`.
-- **A single check answers once per tree** — re-run one check by name (`pnpm josh lint:related`,
-  `pnpm josh cspell:dot`, `pnpm josh test:related`, or the type check) after every edit, never twice
-  over an untouched tree. In kit a detached `pnpm josh ship` also checks the metrics totals; accept a
-  grown total with its reason, as its output names.
+  A lane child's resolution of ship's `conflict` stop: markers removed → the re-detach the stop
+  prints (step 0), which records the merge commit and runs the scoped pair and the gate.
+- **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.
 - **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.

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

@@ -37,17 +37,19 @@ classification lives in `backlogrun-child.md` → "Each child runs in a delegate
 main line.** The unit returns conclusions with `file:line` citations, never the file text. It may run
 a temporary probe script and return its output.
 
-**The threshold is 3 files, and it is a count, not a forecast.** Brief the unit on what was already
-read. **A delegation resets the counter rather than spending it**; `pnpm josh investigation:guard`
-refuses the threshold call, in a lane child too (`pnpm josh delegate --list`; counting:
-`docs/josh-commands-automation.md` → "`josh investigation:guard`").
+**Subject reading beyond the edit targets → dispatch the unit before the first read**
+(`pnpm josh run:prep` → `=== investigation ===`). **The threshold is 3 files, and it is a count, not a
+forecast** — where the guard refuses, not a budget. Brief the unit on what was already read.
+**A delegation resets the counter rather than spending it**; the `investigation` row of
+`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 main line does not idle while the unit reads:** read files this run will edit, then verify the
-unit's cited lines. Independent investigations launch together; a brief that needs another unit's
-answer waits for that answer.
+**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
+cited lines. Independent investigations launch
+together; a brief that needs another unit's answer waits for that answer.
 
 **When the Issue already names the file, function or rule, read that edit target in the main line.**
 It is not `survey`, and it is not `diagnosis`: the unit describes how the subject works;
@@ -55,6 +57,5 @@ the main line decides what that means and what to change.
 
 ## A `general-purpose` subagent names its model
 
-**A `general-purpose` dispatch → set `model`**: `sonnet` for routine work, `opus` for judgment; a review
-takes the alias of the `model=` id its brief prints (`claude-opus-5-5` → `opus`). Delivered by the
-`agent-model` row of `pnpm josh rule:guard`.
+**A `general-purpose` dispatch sets `model`** — `sonnet` for routine work, `opus` for judgment (the
+`agent-model` row of `pnpm josh rule:list`).

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

@@ -18,21 +18,21 @@ short-circuits with a non-zero exit. The numbered steps are the detail behind ea
    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 applies it right after filing (`fullrun-steps.md`). Every
-   stop that leaves the tree clean ends with `pnpm josh run:release <N>`, which removes the label with
-   the record (a `new` entry's bare release does not — `working-tree-hold.md`).
+   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.
 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 shared 135,000 threshold
+   dispatched by a batch** (that batch owns the question). The verdict and the model-priced threshold
    are the command's own.
 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
    `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 `pnpm josh latest:scope` — update
-   dependencies only on `required` (`latest-gate.md`), never on every run. `run:step` names every later
+   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` → "順序の問い").
 
@@ -49,12 +49,12 @@ lane child starts none and never reads that document (`pnpm josh read:set lane-c
   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.
-- **A prerequisite** — file it (`route:tier-a`), stash, record the dependency, and **STOP** with
-  "Please run `backlogrun #<E> --only` to execute this epic"; `prerequisite.md` is the single source of
-  the filing, the `-u` stash and the epic:bundle branch.
+- **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.
 - **An observation** — `observation-filing.md` (ask first if interactive).
 
-**Automatic filing is capped at 10 Issues per run.** On reaching it, stop and report.
+**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

@@ -22,17 +22,19 @@ request already merged by hand** (a `prrun` stop) runs only the post-merge tail;
 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.** Wait out the stated
-window, post `@coderabbitai review` on the pull request, and rerun `followup`. Bypassing is Tier C — on
-explicit user instruction only, when the window is impractically long or the retrigger is rate-limited
-again.
+**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 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
 named recovery without rerunning `followup`. The printed result is authoritative.
 
-After success, run `pnpm josh ms`; in a lane it refuses and the parent uses `pnpm josh lane:close <N>`.
-Never delete the branch unless requested. The sections below are read when the output needs reading.
+A CI job red only on tests outside the change → `followup` reruns it once, after ship's main merge
+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.
 
 ## The options
 
@@ -49,8 +51,6 @@ Never delete the branch unless requested. The sections below are read when the o
 
 Invoking `fullrun` is itself the explicit authorization to merge.
 
-- **Always run `pnpm josh ms` after a successful merge**. **In a lane, `pnpm josh lane:close <N>` is the
-  terminal step instead** — `josh ms` refuses there.
 - **Green CI is not authorization to merge while AI review findings are open.** A blocker sends a
   `confirmation` Telegram and exits non-zero — fix and re-run. SonarCloud is carried by the required
   `SonarQube` check.
@@ -58,7 +58,7 @@ Invoking `fullrun` is itself the explicit authorization to merge.
   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.
 - **The merge is `followup`'s, not yours** — `.claude/settings.json` refuses `gh pr merge` and its
-  `gh api` spellings (`CLAUDE.md` → "Git Rules"). Do **not** pass `--delete-branch` unless asked.
+  `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
   other flags. To skip the merge, use `kickoff` or say "do not merge" in the same turn and pass
   `--no-merge`.
@@ -74,44 +74,24 @@ to 32 minutes; give the call the largest timeout it accepts (`timeout: 600000` i
 harness detaches the call, wait for its report; where it kills it, set `JOSH_CI_TIMEOUT_SECONDS` and
 re-run once CI has settled. Re-run after every follow-up commit.
 
+In a lane, the detached ship supervisor runs it, not the child — its merge wait holds no lane
+place: `scripts/backlog/backlog-occupied.ts`.
+
 **The count of unreleased merges is surfaced at completion — not a version.** It prints `🚚 unreleased
 merges on main: <n>`. **Do not report a shipped version** — a child no longer bumps. See "When `pnpm
 josh release` runs" below.
 
-## Reading the stage-timing block
-
-One `followup stage: <name> <seconds>` row per stage, then `followup stages total:`.
-
-- **A failed run prints it too**, up to the stage that threw, named `interrupted`. The `merge` row
-  appears only on a run that merged.
-- **A row named `<a>-and-<b>` is a batch of requests sent together**; `checks-wait` is never
-  overlapped.
-- **The total is the sum of the stages**, not the wall clock — the post-merge tail sits outside it.
-
 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>
 ```
 
-## AI reviewer comment scan
-
-`followup` scans top-level PR comments from AI reviewers **independently of CI status**.
-
-- **Blockers are structural, not NLP**: a Claude Review body with `### Issues`, `### Problem`,
-  `#### Logic bug` or a numbered `### 1. …` heading; a CodeRabbit `Actionable comments posted: N` with
-  N > 0. Rate-limit notices and sign-offs (`All issues resolved ✓`) match nothing.
-- **A standing blocker without `--ai-review-ignore-reason`** sends a `confirmation` Telegram and exits
-  non-zero; with it, the reason is posted and the run proceeds.
-- **A comment listing that could not be read is a standing blocker**.
-- **Temporary**: CodeRabbit is non-blocking end to end — out of the default required checks
-  (restore via `JOSH_REQUIRED_CHECKS`); its findings are audit notes.
-
-## Config file reporting
+## What the output means
 
-`followup` matches every changed path against what `josh sync` distributes (`AI_COPY_FILES`,
-`AI_COPY_FILE_MAPPINGS`, `AI_COPY_DIRECTORIES`, `SYNCED_PATHS`) and **reports** the claimed paths in the
-notification and the Issue report. **It stops nothing.** `pnpm josh sync:scope` gives the same answer.
+**A standing AI-review blocker** is fixed, or passed with `--ai-review-ignore-reason` once verified
+inapplicable. The stage-timing block, the blocker shapes and the config-claim report:
+`docs/josh-commands-automation.md` → "`josh followup`" and its detail document.
 
 ## When `pnpm josh release` runs