@joshuafolkken/kit 1.1471.0 → 1.1784.0

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

@@ -6,11 +6,17 @@ This is the execution contract for `fullrun` and `backlogrun`, and for `prrun` u
 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
-   whose prompt names `pnpm josh ship --log <N>` and (Anthropic lane) the re-detach to run after
+   the implementer's self-check"), the scoped pair, the ship body draft filled in
+   (`report-format.md` → "PR 本文の受け入れ条件の対応表"), `pnpm josh ship --detach --review
+   "<title> #<N>"` (`--cite <N>`), then **end the turn** on `launched`/`busy`. No `pnpm josh gate`,
+   `check` or `metrics` before it, by hand: ship reuses the scoped pair green on this tree and base
+   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 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.
+   round 2, which is final, or the review went stale (`scripts/run/ship/run-ship-next.ts`); the
+   supervisor skips a recorded round 1 unless it went stale.
    `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
@@ -18,7 +24,8 @@ Review results and successful pushes are never turn boundaries.
    (`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 (every tool, so `--fix` applies; never a guessed type name).
+   agent type with that brief and its `model` (`delegation.md`) (every tool, so `--fix` applies;
+   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
@@ -39,24 +46,24 @@ Review results and successful pushes are never turn boundaries.
    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>`).
+   A change to the run tooling also takes the interaction review: `prompts/review.md` → "Interaction review".
 5. **The clean path ships in one call** — with no second round due, background
-   `pnpm josh ship "<title> #<N>" --body-file <evidence.md>`: PR preflight → gate → `git -y` →
+   `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`.
 
 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.
 
 ## 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). Where each
-rule came from and why it holds: `docs/maintainers/chain-rule-rationale.md` → "Where each rule came
-from", `docs/maintainers/chain-rule-rationale.md` → "Why the orchestration facts hold".
+(`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.

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

@@ -37,15 +37,14 @@ 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.** When the next read reaches it,
-delegate the unread investigation. Brief the unit on what was already read; do not re-read it there.
-**A delegation resets the counter rather than spending it**; `pnpm josh investigation:guard` counts
-unedited files and search turns and refuses the threshold call. `pnpm josh delegate --list` prints
-the threshold.
+**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) — the parent's
-model at a lowered effort, read-only.
-`docs/josh-commands-automation.md` → "`josh investigation:guard`" carries the command's counting details.
+**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
@@ -54,3 +53,9 @@ 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;
 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:list`.

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

@@ -1,8 +1,6 @@
 # The entry sequence and the stop branches — shared by `fullrun`, `halfrun` and `prrun`
 
-`fullrun.md`, `halfrun.md` and `prrun.md` name only how their own run differs from this shared
-procedure; `pnpm josh run:step <N>` prints the run's next single action. History:
-`docs/maintainers/entry-sequence-rationale.md` → "Where each rule came from".
+`pnpm josh run:step <N>` prints the run's next single action.
 
 ## The ordered entry sequence
 
@@ -20,9 +18,9 @@ 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
@@ -33,8 +31,8 @@ short-circuits with a non-zero exit. The numbered steps are the detail behind ea
    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` → "順序の問い").
 
@@ -51,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-run filing cap is `prerequisite.md`'s** (the `filing-cap` row); 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

@@ -2,8 +2,7 @@
 
 Everything between a green CI and a merged PR: the command, the merge it authorizes, the notifications,
 the reviewer scan, the config report and the release ask. `fullrun` and `backlogrun` end here; `halfrun`
-stops before the commit. This file is the single source. Where each rule came from:
-`docs/maintainers/followup-rationale.md` → "Where each rule came from".
+stops before the commit.
 
 ## Run `pnpm josh followup`
 
@@ -32,8 +31,8 @@ A pre-merge failure stops the run; an unverifiable AI finding or CI failure need
 `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.
+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
 
@@ -50,8 +49,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.
@@ -75,46 +72,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. Reverting it:
-  `docs/maintainers/followup-rationale.md` → "The temporary CodeRabbit exemption".
-
-## 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** (`docs/maintainers/followup-rationale.md` →
-"Why config claims are reported, not stopped"). `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
 

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

@@ -1,63 +1,53 @@
 # `fullrun` — the step lists and the branches
 
-**The detailed procedure behind `fullrun.md`'s manifest**, read on demand — `pnpm josh run:next <N>`
-names which step the run is at, and the sections below carry that step in full. History:
-`docs/maintainers/fullrun-steps-rationale.md` → "Where each rule came from".
+`pnpm josh run:next <N>` names which step the run is at, and the sections below carry that step in
+full.
 
 ## The `fullrun #N` step list
 
 File Issues with `pnpm josh issue:file` (it applies the classification labels); see `prompts/collaboration-workflow/issue-template.md`.
 
-**`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 → Read Issue #N and its comments
-(`issue-comments.md`) → **normalize the title** (if not in English or can be phrased more clearly,
-derive a better English title and `gh api -X PATCH repos/{owner}/{repo}/issues/<N> -f title="<title>"`)
-→ post the agreed plan only if the Issue body is blank (`gh api -X PATCH
-repos/{owner}/{repo}/issues/<N> -f body="<plan>"`); if the body already has content, skip the
-plan-posting step → 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) → run the **verification gate** (the full procedure is `chain-rule.md`;
-in outline: refactor → `pnpm josh main:merge` → **a dispatched lane child hands the rest to
-`pnpm josh ship --detach --review "<title> #<N>"` and ends its turn** (`chain-rule.md` step 0) → otherwise `pnpm josh run:cut <N>` (the pre-gate cut, before the gate; a no-op
-outside a lane) → start `pnpm josh gate` and a subagent `/code-review`
-with the brief `pnpm josh review:brief` prints on `git diff main`, join the gate before the commit,
-iterate to no high/medium findings, within the round cap (`prompts/review.md`) → **the clean path folds the ship region into
-one call**, `pnpm josh ship "<title> #<N>"` (gate → commit/push/PR → the CI-wait `followup` → the
-`run:tail` report bookkeeping, stopping at the first failed step), with any
-branch-2 filing (`pnpm josh issue:file`, which runs `epic:bundle` itself) run before it → **when a second round is due `ship` does not
-fit**: open the PR between the rounds with `pnpm josh git -y "<title> #<N>"`, run round 2 beside CI, then
-`pnpm josh followup` and `pnpm josh run:tail <N>`). Issue plan comments are written in the session language (`JOSH_SESSION_LANG`,
-default `ja`). Before implementing, run `pnpm josh ms`, then `pnpm josh latest:scope`
-and update dependencies only on `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 `pnpm josh main:merge` brings the latest default in during the gate
-(`docs/maintainers/fullrun-steps-rationale.md` → "Why a lane child skips `josh ms`"). The parent runs
-`pnpm josh ms` in the primary checkout, never the child — `backlogrun-lanes.md` and
-`backlogrun-child.md` are the single sources. When running `pnpm josh followup`, pass an
-implementation summary via `--notify-message` in the session language, leading with the three
-plain-language lines: `"Implemented <title>\nCause: ...\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.**
-**Run `pnpm josh ms` after the merge.** A Codex lane skips it — the parent's `run:merge` syncs the
-primary checkout; a Claude run keeps it.
+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
+   `--title "<title>"` when the title is not in English or can be phrased more clearly (a blank body
+   takes the plan, otherwise it becomes 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 `pnpm josh main:merge` brings the latest default in during the 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.
+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.
+6. Run the **verification gate** through the merge: `chain-rule.md` → "Run the review-to-merge
+   chain". Branch-2 filing (`pnpm josh issue:file`, which runs `epic:bundle` itself) runs before
+   `pnpm josh ship`.
+7. When running `pnpm josh followup`, pass an implementation summary via `--notify-message` in the
+   session language, leading with the three plain-language lines: `"Implemented <title>\nCause:
+   ...\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.
 
 ## 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> --depth <n>`,
+(2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file>`,
 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) Add `in-progress` (the bare hold named no issue):
-`gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=in-progress'`. (4) Post the agreed plan
-in the session language: fill the body if blank,
-otherwise add a comment. (5) If the working tree already has staged or modified files,
-`git stash push -m "fullrun new: pre-existing changes" -- ':!.josh/observations'` first. (6) `pnpm josh ms`. (7)
-`pnpm josh latest:scope`; on `required` run `josh latest` and load the `dependency-update` skill; on
-`skip` neither runs (`latest-gate.md` is the single source). If you stashed in (5),
-`pnpm josh stash:pop "fullrun new: pre-existing changes"` — by message, never a positional `git stash
-pop`. (8) Implement. (9) Run the verification gate (as in `chain-rule.md`; only the first review round
+`<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 --round-1-closed` whether a second round is due**, once
 round 1's fixes are in and 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
@@ -69,9 +59,8 @@ round was due** (9a `skip`), fold steps (10)–(13) and the release bookkeeping
 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) **After the merge, run `pnpm josh ms`.** (15) **Ask `pnpm josh
-release:scope` and close the completion summary with what it answered** (`followup.md` →
-"When `pnpm josh release` runs").
+`pnpm josh run:tail <N>`. (14) **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
 

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

@@ -1,18 +1,16 @@
 # `fullrun` — the manifest (plan → implement → PR → merge → notify)
 
-**This file is the manifest, not the procedure.** The entry sequence and the stop branches are
-`entry-sequence.md`, shared with `halfrun` and `prrun`; this file names only what is `fullrun`'s own.
-`pnpm josh run:step <N>` prints the run's next single action. `chain-rule.md`, `followup.md`,
-`background-commands.md` and `latest-gate.md` are **not entry reads** — each is fetched at its point of
-use. The step lists are `fullrun-steps.md`, read when a step needs its detail. History:
-`docs/maintainers/fullrun-rationale.md` → "Where each rule came from".
+The entry sequence and the stop branches are `entry-sequence.md`. `pnpm josh run:step <N>` prints the
+run's next single action. `chain-rule.md`, `followup.md`, `background-commands.md` and
+`latest-gate.md` are **not entry reads** — each is fetched at its point of use. The step lists are
+`fullrun-steps.md`, read when a step needs its detail.
 
 ## The difference — the entry and the end
 
 - **The entry passes no `--to`**: `pnpm josh run:entry <N>` is `fullrun`'s stage. Follow `run:step`
   into `fullrun-steps.md` — the `fullrun #N` list or the `fullrun new` list.
-- **The end merges**: `run:step` names the verification gate, `pnpm josh followup`, `pnpm josh ms` and
-  the release ask in order. Invoking `fullrun` authorizes the merge, through `pnpm josh followup` only.
+- **The end merges**: `run:step` names the verification gate, `pnpm josh followup` and the release ask
+  in order. Invoking `fullrun` authorizes the merge, through `pnpm josh followup` only.
 - **A split or a prerequisite stops the run**: typing `fullrun` approved **one** Issue.
 
 ## The lane-child seam

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

@@ -1,14 +1,10 @@
 # `halfrun` — the manifest (implement + verify, stop before commit)
 
-When this run files a new Issue, file it with `pnpm josh issue:file`, which lints the body and applies the classification labels it declares beside the `--depth` and `--route` labels; `prompts/collaboration-workflow/issue-template.md` is the single source for this classification.
+When this run files a new Issue, file it with `pnpm josh issue:file`, which lints the body and applies the classification labels it declares beside the `--route` label; `prompts/collaboration-workflow/issue-template.md` is the single source for this classification.
 
-`halfrun` sits between `kickoff` (plan only) and `fullrun` (full execution with auto-merge). It
-implements the change and runs the full verification gate, then **stops before commit** — nothing is
-committed, pushed, or opened as a PR — so a person verifies the working tree by hand. Use it when a change needs human eyes before shipping.
-
-**This file is the manifest.** The entry sequence and the stop branches are `entry-sequence.md`,
-shared with `fullrun` and `prrun`; this file names only what is `halfrun`'s own. History:
-`docs/maintainers/halfrun-rationale.md` → "Where each rule came from".
+`halfrun` implements the change and runs the full verification gate, then **stops before commit** —
+nothing is committed, pushed, or opened as a PR — so a person verifies the working tree by hand. The
+entry sequence and the stop branches are `entry-sequence.md`.
 
 ## The difference — the entry
 
@@ -19,36 +15,28 @@ shared with `fullrun` and `prrun`; this file names only what is `halfrun`'s own.
 
 ## The step list
 
-`halfrun #<N>`: read Issue #N and its comments → **normalize the title** (same as
-`fullrun`) → post the agreed plan only if the body is blank → `pnpm josh ms`, then `pnpm
-josh latest:scope` and update dependencies only on `required` (`latest-gate.md`; the
-`dependency-update` skill) → implement → run the **full verification gate** (refactor →
+`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
+`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
 test:e2e`, run by **you**, because `halfrun` opens no pull request and there is no CI E2E job; a printed
 skip is the answer where the project has no suite) → **mark the stop: `pnpm josh run:hold <N>
---halfrun-stop`** (the record `fullrun #<N>` adopts; `new` passes the filed number) → send a
-`confirmation` Telegram with the resume commands in the body → **stop**. Plan comments are in the session language. The `confirmation` Telegram
-body MUST include the exact resume commands — **the `Next:` line first**, since that is how a verified
-`halfrun` ships: its `run:entry` adopts this stop's marked hold and resumes at
-the gate. The direct commands follow for shipping without an agent:
-`pnpm josh notify --task-type confirmation --issue-url "<issue-url>" --body=$'halfrun ready for manual
-verification\nNext: prrun #<N> | fullrun #<N>\nWithout an agent: pnpm josh git -y "<title> #<N>" && pnpm josh
-followup "<title> #<N>" --notify-message "Implemented <title>\\nCause: ...\\nFix: ...\\nResult:
-...\\n\\nDetails:\\n- <change1>"' --recommended "Verify by hand, then prrun #<N>" --alternative "fullrun
-#<N>"`. The stop report names the same two, in the same order.
+--halfrun-stop`** (the record `fullrun #<N>` adopts; refused with `e2e-owed` until `test:e2e` answered
+green on this tree; it also sends the `confirmation` Telegram, its body led by
+`Next: prrun #<N> | fullrun #<N>` — never compose one) → **stop**. Plan comments are in
+the session language. The stop report names `prrun #<N>` (recommended) and `fullrun #<N>`, in that order.
 **Invoking `halfrun` is _not_ authorization to commit, push, or merge** — do not run `pnpm josh git -y` or `pnpm josh followup` yourself. If the user comes
-back with fixes, treat each as a new round: implement, re-run `pnpm josh gate`, send another
-`confirmation` Telegram, stop again.
+back with fixes, treat each as a new round: implement, re-run `pnpm josh gate`, mark the stop again
+(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> --depth <n>`, with the labels
+(`pnpm josh issue:file "<title>" --body-file <body-file>`, 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`) → add `in-progress` (as `fullrun new` (3)) → post the agreed plan → stash
-any pre-existing changes with `git stash push -m "halfrun new: pre-existing changes" -- ':!.josh/observations'`
-(the pathspec keeps the observation ledger in the tree for this run's commit), popped by
-message with `pnpm josh stash:pop "halfrun new: pre-existing changes"`, never a positional `git stash pop` →
-`pnpm josh ms` → `pnpm josh latest:scope` → implement → run the gate (as above, `pnpm
-josh test:e2e` run by **you**) → `pnpm josh run:hold <N> --halfrun-stop` → send the `confirmation`
-Telegram and **stop**.
+`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
+josh test:e2e` run by **you**) → `pnpm josh run:hold <N> --halfrun-stop` (it sends the `confirmation`)
+→ **stop**.

package/.claude/skills/workflow-commands/into-target.md

@@ -2,8 +2,7 @@
 
 **This file is the suffix's single source, read at its point of use — the moment a `new` entry is
 typed with an `into <target>` suffix, not at any entry.** A run given a `#N` or a bare `new` never
-reaches it. `SKILL.md` → §2's table keeps the trigger and points here. Rationale:
-`docs/maintainers/into-target-rationale.md` → "Why the suffix reads as it does".
+reaches it.
 
 `kickoff new` / `fullrun new` / `halfrun new` accept a suffix naming the epic the run's artifact
 belongs to. Without it the artifact belongs to no epic, and `epic:next` only ever offers an epic's

package/.claude/skills/workflow-commands/issue-comments.md

@@ -1,7 +1,6 @@
 # An Issue's comments are part of the Issue
 
-**The single source of the comment read**, read before implementing a `#N` Issue. Rationale and
-history: `docs/maintainers/issue-comments-rationale.md` → "Why comments are read".
+Read before implementing a `#N` Issue.
 
 **Every `#N` entry point reads the Issue's comments before it implements** — `fullrun`, `halfrun` and
 `kickoff`; a `backlogrun` named issue and epic child inherit it through `fullrun`. One call, in the same
@@ -48,32 +47,37 @@ means "waiting for an answer", and here the answer exists.
 the Issue (`scripts/issue/issue-labels.ts` → `NOT_DIRECTLY_RUNNABLE_LABELS`, `epic-classify.ts` →
 `human`), and `epic:busy` stops counting it. **Only a person removes it, by closing the Issue.**
 
+**Commit nothing, push nothing, open no pull request** — run one command; it posts the evidence,
+applies `already-done` and releases the hold, in that order, stopping at the first failure:
+
 ```bash
-gh api repos/{owner}/{repo}/labels -f name=already-done -f color=6f42c1 -f description="Verified already merged — a person closes it" --silent 2>/dev/null || true
-gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=already-done'
+pnpm josh issue:already-done <N> --evidence-file <path>
 ```
 
-1. **Record the evidence as an Issue comment, before the label**: the merging pull request or commit
-   and, per acceptance criterion, the file and lines that satisfy it. **A claim with no citations is not
-   the finding this exit is for.**
-2. **Apply `already-done`** — the two commands above.
-3. **Commit nothing, push nothing, open no pull request.** Release the hold with
-   `pnpm josh run:release <N>`, which also removes `in-progress`.
-4. **Then behave as the entry point does for a parked child.** A typed `fullrun` / `halfrun` sends a
-   `confirmation` Telegram naming the Issue and the covering merge, and stops; a `backlogrun` child is
-   park-and-continue (`backlogrun-park.md` → "park and continue").
-5. **Never close the Issue** — Tier C at every entry point.
+**The evidence file names the merging pull request or commit and, per acceptance criterion, the
+`file:line` that satisfies it.** **A claim with no citations is not the finding this exit is for.**
+
+Then behave as the entry point does for a parked child: a typed `fullrun` / `halfrun` sends a
+`confirmation` Telegram naming the Issue and the covering merge, and stops; a `backlogrun` child is
+park-and-continue (`backlogrun-park.md` → "park and continue"). **Never close the Issue** — Tier C.
 
 **Looking familiar is no license to skip the work**: a criterion you cannot point at merged code for is
 one this run still owes.
 
+## A measurement-only Issue
+
+**Every criterion is a measurement, so no pull request closes it** → `pnpm josh issue:measured <N>
+--evidence-file <path>` (per criterion, the result and its run), never a bare comment: an OPEN child is
+parked `run:stalled`. Invoking `fullrun` / `backlogrun` authorizes this close. `docs/josh-commands-backlog.md` → "`josh issue:measured`".
+
 ## A long thread
 
 **The fetch is one call; what costs is carrying it** — hence the projection to author, timestamp and
 body. A thread longer than the Issue is the pre-implementation reading `delegation.md` describes: brief
 a unit to return **the agreements in force plus the comment URLs that carry them**, never the text.
 
-**`pnpm josh rule:guard` refuses the body-only read** (`prompts/collaboration-workflow/rule-delivery.md`).
+**Under Claude Code the hook prepends the comments to a line that opens with a body-only `gh api` read
+and refuses every other body-only read; the Codex adapter refuses them all** (`prompts/collaboration-workflow/rule-delivery.md`).
 **This file is the rule, not the hook** — a session without hooks still owes the read.
 
 ## A person's update mid-run

package/.claude/skills/workflow-commands/issue-scout.md

@@ -6,8 +6,8 @@ Every filing asks whether the work already exists and which epic owns it; the co
 named in `--distinct`:
 
 ```bash
-pnpm josh issue:file "<title>" --body-file <complete-draft.md> --depth <n> [--route <route>]
-pnpm josh issue:file "<title>" --body-file <complete-draft.md> --depth <n> --distinct 2801,2795
+pnpm josh issue:file "<title>" --body-file <complete-draft.md> [--route <route>]
+pnpm josh issue:file "<title>" --body-file <complete-draft.md> --distinct 2801,2795
 ```
 
 - **`Duplicates:` is read, not skimmed.** Open each candidate and apply `issue-fold-existing.md`
@@ -28,8 +28,9 @@ pnpm josh issue:file "<title>" --body-file <complete-draft.md> --depth <n> --dis
   `add_to_epic` / `create_epic` Tier A and `ask` a stop, in exactly the reading `into-target.md`'s
   `into <target>` suffix would have given by hand. Where the user typed `into <target>`, that naming wins.
 - **`Epic: not asked` is not `Epic: none`.** The epic half decides from the issue numbers the body
-  names. **Cite `#N` in the body whenever the work follows an existing Issue** — one line is enough,
-  and naming the epic itself (`part of epic #<E>`) is answered with that epic.
+  names in its acceptance criteria or its `parent: #N` line; a background mention does not count.
+  **Cite `#N` there whenever the work follows an existing Issue** — one line is enough, and naming
+  the epic itself (`parent: #<E>`) is answered with that epic.
 - **`epic:bundle` then runs on the new Issue, in the same call.** Act on its printed answer; a `⚠`
   means rerun `pnpm josh epic:bundle <N>` — the Issue exists, so never refile; a placing answer
   reads the `epic-commands` skill.