@joshuafolkken/kit 1.1514.0 → 1.1784.0

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 run** | 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/rules/filing-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.**
@@ -66,7 +66,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 +91,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 +134,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 run | `prerequisite.md`'s cap | 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

@@ -6,12 +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
+   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
@@ -19,8 +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 and the alias of its `model=` id (`claude-opus-5-5` → `opus`) (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
@@ -41,6 +46,7 @@ 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>` — the file carries `## 実機証跡` and
    `## 受け入れ条件の対応` (`report-format.md`), both asked at the preflight: PR preflight → gate → `git -y` →
@@ -49,8 +55,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.
 

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

@@ -37,10 +37,11 @@ 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.
@@ -57,4 +58,4 @@ the main line decides what that means and what to change.
 
 **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`.
+`agent-model` row of `pnpm josh rule:list`.

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

@@ -18,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
@@ -31,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` → "順序の問い").
 
@@ -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-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

@@ -31,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
 
@@ -49,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.
@@ -74,44 +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.
-
-## 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
 

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

@@ -7,55 +7,47 @@ full.
 
 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. 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
@@ -67,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

@@ -9,8 +9,8 @@ run's next single action. `chain-rule.md`, `followup.md`, `background-commands.m
 
 - **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,6 +1,6 @@
 # `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` 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
@@ -15,36 +15,28 @@ entry sequence and the stop branches are `entry-sequence.md`.
 
 ## 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/issue-comments.md

@@ -47,25 +47,29 @@ 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

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`