@joshuafolkken/kit 1.1455.0 → 1.1514.0

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

@@ -1,10 +1,5 @@
 # `backlogrun` — the manifest (named issues, epics and the opted-in backlog)
 
-**This file is the manifest, not the procedure**: the ordered flow as terse triggers, and the route
-table naming the one section each moment reads. Rationale and provenance:
-`docs/maintainers/backlogrun-rationale.md` → "Why the loop's position is computed";
-`docs/maintainers/backlogrun-rationale.md` → "Where each rule came from".
-
 **`backlogrun` names either nothing, or the issues and epics to run first.** With no argument it runs
 whatever `pnpm josh backlog:next` offers — the whole opted-in backlog, every issue carrying `auto-ok`
 plus every child of an epic whose root carries it, ordered by dependency and grouped into waves. With
@@ -12,9 +7,9 @@ plus every child of an epic whose root carries it, ordered by dependency and gro
 that same backlog. **`--only` stops it after the named list**, draining nothing.
 
 **The loop's current position is computed, not carried in the conversation.** `pnpm josh run:step <N>`
-reads where the run is from the event stream, the carry record and the issue state, and prints the next
-single action — a runnable command, or the one point a person has to judge. **With no `<N>` it answers
-for the parent itself**, from the carry record alone.
+reads it from the event stream, the carry record and the issue state, and prints the next single
+action — a runnable command, or the one point a person has to judge — followed by the section that
+governs it. With no `<N>` it answers for the parent itself, from the carry record alone.
 
 **A named item may be a single issue or an epic.** A single-issue item is one `fullrun`; **a named epic runs its children in
 dependency order across the free lanes, and the run does not advance to the next named item until
@@ -29,52 +24,46 @@ is still that one invocation (`backlogrun-steps.md` → "The session cut is insi
 
 ## The manifest — the ordered flow
 
+A section `run:step` prints is not fetched again. Every other one is read at its step with
+`pnpm josh doc:section <file> "<heading>"` — never a whole document (`SKILL.md` → "A section
+reference is read as a section").
+
 1. **Claim nothing at the entry — this parent orchestrates and never implements.** The working-tree
    hold, the split assessment and `fullrun.md` are read by a dispatched child inside its own delegated
    `fullrun` unit, never at the parent's entry.
 2. **Begin the carry record before the plan** — `pnpm josh run:carry --begin "<invocation>" --owner
-   "$PPID"` and `pnpm josh run:wake --start`, in the same turn as the first `pnpm josh ms`.
+   "$PPID"` and `pnpm josh run:wake --start`, in the same turn as the first `pnpm josh ms`. Its answers:
+   `backlogrun-steps.md` → "The session cut is inside the invocation"; a resumed session:
+   `backlogrun-progress.md` → "Resuming after a cut".
 3. **What this invocation approves** — the opted-in pool, a run's own filings once bundled, and the
-   brake that bounds the amount; the route table's row points at the single source of the `auto-ok` rule.
+   brake that bounds the amount: `backlogrun-steps.md` → "What one invocation approves".
 4. **Report the plan before the first child** — `pnpm josh backlog:plan`, then resolve every
    `needs-decision` issue decidable from its body in one pass, recording `blocked-by`, `run:solo` and
-   `run:lane` in the same pass.
+   `run:lane` in the same pass: `backlogrun-steps.md` → "The plan, before the first child starts";
+   `run:solo`: `backlogrun-lanes.md` → "A solo run".
 5. **Named issues run first, in order** — each as a delegated `fullrun`, one at a time, then the pool;
    `--only` stops after the list.
+   - Once per session: `backlogrun-steps.md` → "What runs once per session, not once per issue" and
+     `backlogrun-child.md` → "`josh latest` runs once per session, not once per child"
+     (`latest-gate.md` whole on `required`).
+   - The watcher: `progress-watcher.md` → "Progress while the run is quiet".
+   - Lanes: `backlogrun-lanes.md` → "Once per repository, before the first lane opens", by hand
+     `backlogrun-lanes.md` → "Opening one lane and dispatching its child".
+   - Dispatch: `backlogrun-child.md` → "Each child runs in a delegated unit".
 6. **The loop belongs to the supervisor — hand it over with what the bare `pnpm josh run:step`
    prints**, whatever the plan held: `run:wake` runs `backlog:drive`, which returns a branch to an AI
-   session only when it needs judgment.
+   session only when it needs judgment (`backlogrun-steps.md` → "The loop").
+   - An `epic #N` hand-back or a `merge` branch: `backlogrun-progress.md` → "Running a named epic's
+     children".
+   - A merge answered `over`: `backlogrun-progress.md` → "The hand-off".
+   - A unit gone silent: `backlogrun-recovery.md` → "A delegated unit that stopped without reporting".
+   - A child that cannot finish: `backlogrun-park.md` → "park and continue".
 7. **End the record when the run ends** — `run:report`, then `run:carry --end` (or `--end --stopped
-   "<reason>"`) and `run:wake --stop`. An empty plan is not that end; the driver's idle watch decides it.
-   A person stops a run from the terminal with `pnpm josh backlogrun --stop`, which makes both calls.
-
-## The route table
-
-**Read one section, at the moment its row names, with `pnpm josh doc:section <file> "<heading>"`** —
-never a whole document (`SKILL.md` → "A section reference is read as a section"):
-
-| The moment | Read |
-| --- | --- |
-| The entry: the carry record and its answers | `backlogrun-steps.md` → "The session cut is inside the invocation" |
-| What the invocation may merge, and the `auto-ok` rule | `backlogrun-steps.md` → "What one invocation approves" |
-| Before the first child: the plan and the decision pass | `backlogrun-steps.md` → "The plan, before the first child starts" |
-| The driver hands a branch back | `backlogrun-steps.md` → "The loop" |
-| Once per session | `backlogrun-steps.md` → "What runs once per session, not once per issue" |
-| `josh latest:scope` answers `required` | `latest-gate.md` (whole) |
-| Starting the progress watcher | `progress-watcher.md` → "Progress while the run is quiet" |
-| The run ends | `backlogrun-steps.md` → "End the record when the run ends" |
-| Labelling an issue `run:solo` | `backlogrun-lanes.md` → "A solo run" |
-| Before the first lane opens | `backlogrun-lanes.md` → "Once per repository, before the first lane opens" |
-| Opening a lane by hand | `backlogrun-lanes.md` → "Opening one lane and dispatching its child" |
-| The first child is in hand | `backlogrun-child.md` → "`josh latest` runs once per session, not once per child" |
-| Dispatching a child | `backlogrun-child.md` → "Each child runs in a delegated unit" |
-| An `epic #N` hand-back, a `merge` branch, or a `run:merge` token | `backlogrun-progress.md` → "Running a named epic's children" |
-| A merge answered `over` | `backlogrun-progress.md` → "The hand-off" |
-| A resumed session | `backlogrun-progress.md` → "Resuming after a cut" |
-| The run's last merge | `backlogrun-progress.md` → "Who sends the summary, and who propagates" |
-| `josh release:scope`, after the last merge | `followup.md` → "When `pnpm josh release` runs" |
-| A unit went silent | `backlogrun-recovery.md` → "A delegated unit that stopped without reporting" |
-| A child cannot finish | `backlogrun-park.md` → "park and continue" |
+   "<reason>"`) and `run:wake --stop`: `backlogrun-steps.md` → "End the record when the run ends".
+   - An empty plan is not that end; the driver's idle watch decides it. A person stops a run from the
+     terminal with `pnpm josh backlogrun --stop`, which makes both calls.
+   - The last merge: `backlogrun-progress.md` → "Who sends the summary, and who propagates", then
+     `followup.md` → "When `pnpm josh release` runs".
 
 ## Guards
 
@@ -85,11 +74,3 @@ never a whole document (`SKILL.md` → "A section reference is read as a section
 | 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.
-
-## This file is the single source of the `backlogrun` procedure
-
-`CLAUDE.md` carries the keyword's row in the shorthand table and the explicit-invocation rule;
-`SKILL.md` → §1 routes here. This manifest names which children there are and in what order; each
-step's procedure is the section its route-table row names. Where any of them could disagree, the rule
-is that this manifest and `backlogrun-steps.md` add nothing to a child's procedure — they only say
-which children there are.

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

@@ -8,7 +8,8 @@ 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
+   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
@@ -18,7 +19,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 the alias of its `model=` id (`claude-opus-5-5` → `opus`) (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
@@ -40,7 +42,8 @@ Review results and successful pushes are never turn boundaries.
    **`pnpm josh followup` refuses the merge until the round is recorded**
    (`pnpm josh review:record --check --issue <N>`).
 5. **The clean path ships in one call** — with no second round due, background
-   `pnpm josh ship "<title> #<N>" --body-file <evidence.md>`: 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`.
@@ -54,46 +57,34 @@ Recommendations are informational; severity decides. A CodeRabbit rate-limit war
 ## 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** — `pnpm josh gate` is started when the review
-  starts and joined before the commit. A red gate is fixed and re-run whatever the review concluded, and
-  there is no path to a commit on a gate nobody read.
-- **origin/main is merged in before the gate** — `pnpm josh main:merge` merges `origin/<default>` into
-  the branch before the gate and the review start. It is the last edit, so the scoped pair and the gate
-  run once over it. A conflict here fires `backlogrun-recovery.md` → "Conflicts are not predicted"
-  early. **This is the one place a conflicted merge's procedure is written**:
-  `main:merge` refuses before merging when uncommitted changes touch a path the default branch also
-  changed, or when the index still holds unresolved or staged paths — commit the work first with
-  `pnpm josh git -y`, then rerun it, and **never stash around the merge**. A merge that stops on a
-  conflict is finished the same way: remove the markers, then `pnpm josh git -y` stages the resolution
-  and records the merge commit. That commit is the sanctioned flow, so it is **Tier A** — a lane child
-  never stops to ask a person for `git add`, and the `Stop` hook sends back a reply that does.
-- **A single check answers once per tree** — while implementing, re-run a single check by name
-  (`pnpm josh lint:related`, `pnpm josh cspell:dot`, `pnpm josh test:related`, or the project's type
-  check) after every edit; a repeat of the same command with the same arguments over a tree nothing has
-  touched since buys only a copy of the answer already in hand. In kit a detached `pnpm josh ship` also
-  checks the metrics totals before the hand-off, so the implementing session accepts a grown total with
-  its reason, as the ship's output names.
-- **The pull request opens between the rounds, so CI runs beside round 2** — `pnpm josh git -y` sits
-  between the two review rounds. Round 1 runs on the uncommitted tree and its High/Medium findings are
-  fixed before anything is committed; the verification pass over those fixes then runs against the open
-  pull request, beside the CI the commit started.
-- **The round-2 fix commit is pushed before its gate** — a fix the second round makes in place is
-  pushed (`pnpm josh git -y` again, a follow-up commit) before its `pnpm josh gate`, so the gate runs
-  inside the CI wait and is joined before `pnpm josh followup` rather than in front of it.
-- **A clean second round issues the merge in the same turn** — the turn that reads a clean second round
-  issues `pnpm josh followup`, after any branch-2 filing and `pnpm josh epic:bundle` and never in a turn
-  of its own. Clean has two halves: no confirmed High is standing, and nothing was routed to branch 1 of
-  the disposition.
-- **The review runs in a subagent, never a main-line skill load** — `/code-review` is spawned through
-  the `Agent` tool in its own context, as the agent type step 1 names.
+- **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
+  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.
+- **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.
+- **The round-2 fix commit is pushed before its gate** — `pnpm josh git -y` again, so the gate runs
+  inside the CI wait and is joined before `pnpm josh followup`.
+- **A clean second round issues the merge in the same turn** — `pnpm josh followup`, after any branch-2
+  filing and `pnpm josh epic:bundle`. Clean: no confirmed High standing, nothing routed to branch 1.
+- **The review runs in a subagent, never a main-line skill load** — `/code-review` through the `Agent`
+  tool, as the agent type step 1 names.
 - **The brief names the checkout, and a review that read another one is refused** — `pnpm josh
-  review:brief` prints the checkout root, branch and HEAD and a nonce; the review runs `pnpm josh
+  review:brief` prints the checkout root, branch, HEAD and a nonce; the review runs `pnpm josh
   review:attest <nonce>` from the tree it read, and `pnpm josh review:attest --check` must answer `ok`
-  before the run or `pnpm josh followup` acts on the verdict, or it is discarded.
+  before anything acts on the verdict.
 
 This file is the single source of the gate → review → PR → merge chain rule; other documents reference
 it rather than restating it. `prompts/collaboration-workflow/plan-comment.md` keeps Step 3.

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

@@ -37,15 +37,13 @@ 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.
+**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`").
 
-**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 +52,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:guard`.

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
 

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

@@ -1,10 +1,8 @@
 # Finishing a run — `pnpm josh followup`
 
 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` never reaches this file, because it stops before the commit. This file is the single source
-of the rule. Where each rule came from: `docs/maintainers/followup-rationale.md` → "Where each rule
-came from".
+the reviewer scan, the config report and the release ask. `fullrun` and `backlogrun` end here; `halfrun`
+stops before the commit.
 
 ## Run `pnpm josh followup`
 
@@ -20,85 +18,75 @@ bullets. Use the file option whenever it contains a command or path.
 It waits for required CI, checks CodeRabbit and top-level AI review comments, sends the completion
 Telegram, merges by default, posts the Issue report, closes completed epics, removes `in-progress`,
 and releases the hold. Only `--no-merge` stops the merge; `--merge` is a deprecated no-op. **A pull
-request already merged by hand** (a `prrun` stop) skips the CI wait, the AI review scan and the merge
-and runs only the post-merge tail; a completion report already on the Issue is not posted or notified
-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.
+request already merged by hand** (a `prrun` stop) runs only the post-merge tail; a report already on the
+Issue is not posted twice, so re-running is safe. Keep the default Issue target. Ignore a finding only
+after verifying it is inapplicable; rate-limit text is not a finding.
 
-**A red rate-limited CodeRabbit check is cleared by a retrigger, not a bypass.** Wait out the window
-the rate-limit comment states, post `@coderabbitai review` on the pull request, and rerun `followup`.
-Bypassing the check is Tier C — only on explicit user instruction, and only when the stated 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.** 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 pre-merge failure stops the run; an unverifiable AI finding or CI failure needing input receives a
-`confirmation` Telegram. Post-merge cleanup failures are named and do not undo the merge; run the
-named recovery without rerunning it. Because notification precedes merge, the printed result is
-authoritative.
+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 its refusal is expected and the parent uses
-`pnpm josh lane:close <N>`. Never delete the branch unless requested. The sections below are read
-after execution, when its output needs reading.
+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.
 
 ## The options
 
 | Option | What it is |
 | --- | --- |
-| `--no-merge` | **The only flag that stops the merge** — leave it out and the command merges |
-| `--notify-target` | `pr` \| `issue` \| `both`, defaulting to `issue`. **Keep the default** — the workflow puts no completion report on the pull request |
-| `--notify-message` / `--notify-message-file` | The completion comment body in the two-layer report shape — `Cause: / Fix: / Result:`, then `Details:` bullets, never a bare `Added … / Changed …` list. **Use the file form whenever the report names a command or a path** (`prompts/collaboration-workflow/shell-body.md`); `-` reads stdin |
-| `--coderabbit-ignore-reason` | The reason comment for leaving CodeRabbit line comments unresolved |
-| `--ai-review-ignore-reason` | The reason comment for leaving an AI-review blocker (Claude Review / a CodeRabbit summary) unresolved |
-| `--issue-number` | The Issue number — or give it positionally as `"<title> #<number>"`; with neither, the PR body's `closes #N` supplies it |
+| `--no-merge` | **The only flag that stops the merge** |
+| `--notify-target` | `pr` \| `issue` \| `both`, default `issue`. **Keep the default** |
+| `--notify-message` / `--notify-message-file` | The completion comment in the two-layer shape — `Cause: / Fix: / Result:`, then `Details:` bullets, never a bare `Added … / Changed …` list. **Use the file form whenever the report names a command or a path** (`prompts/collaboration-workflow/shell-body.md`); `-` reads stdin |
+| `--coderabbit-ignore-reason` | Why CodeRabbit line comments stay unresolved |
+| `--ai-review-ignore-reason` | Why an AI-review blocker (Claude Review / a CodeRabbit summary) stays unresolved |
+| `--issue-number` | The Issue number — or positionally as `"<title> #<number>"`; with neither, the PR body's `closes #N` |
 
 ## `auto-merge` — Default `fullrun` behavior
 
-Invoking `fullrun` is itself the explicit authorization to merge; the user adds no keyword.
+Invoking `fullrun` is itself the explicit authorization to merge.
 
-- **Always run `pnpm josh ms` after a successful merge** — it returns the tree to the default branch
-  with the merge commit pulled. **In a lane, `pnpm josh lane:close <N>` is the terminal step instead**:
-  `josh ms` refuses there, and the refresh is the parent's.
-- **Green CI is not authorization to merge while AI review findings are open.** On a blocker
-  `followup` sends a `confirmation` Telegram and exits non-zero — fix and re-run. SonarCloud is not
-  scanned here; the required `SonarQube` check carries it.
+- **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.
 - **Verify a CodeRabbit finding before bypassing it.** Never pass `--coderabbit-ignore-reason`
   reflexively: a SHA pin flagged "not matching the tag" is checked with `gh api
   repos/<owner>/<repo>/commits/<tag> --jq '.sha'`, and the bypass cites that command.
-- **The merge is `followup`'s, not yours** — it calls the REST merge endpoint from inside a node
-  script, and `.claude/settings.json` refuses `gh pr merge` and its `gh api` spellings (`CLAUDE.md` →
-  "Git Rules"). Do **not** pass `--delete-branch` unless the user asks.
+- **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.
 - **A failed merge** (branch protection, a conflict) is reported and stops the run — never retried with
-  other flags or past a protection. To skip the merge, use `kickoff` or say "do not merge" in the same
-  turn and pass `--no-merge`.
+  other flags. To skip the merge, use `kickoff` or say "do not merge" in the same turn and pass
+  `--no-merge`.
 
 ## Completion notifications: always via `pnpm josh followup`
 
-**Never send a `completion` Telegram with `pnpm josh notify`** — `followup` sends it with the PR URL,
-which the manual CLI does not fill in. `pnpm josh notify` stays the tool for `planning`,
-`confirmation`, `kickoff_retry` and `failure`. **It fires before the merge**, so a received ✅ is not
-proof the PR merged — read what the command printed; a silent run is a failed run.
+**Never send a `completion` Telegram with `pnpm josh notify`** — `followup` fills in the PR URL.
+`pnpm josh notify` stays the tool for `planning`, `confirmation`, `kickoff_retry` and `failure`. **It
+fires before the merge**, so a ✅ is not proof the PR merged — read what the command printed.
 
-**Always run it in the foreground** — the deliberate exception to `background-commands.md`, because
-nearly every later step reads its result. The CI wait defaults to 32 minutes, so give the call the
-largest timeout it accepts (`timeout: 600000` in Claude Code). Where the harness detaches an
-over-running command, wait for its report; where it kills the call, set `JOSH_CI_TIMEOUT_SECONDS` to fit
-and re-run once CI has settled. Re-run it after every follow-up commit.
+**Always run it in the foreground** — the exception to `background-commands.md`. The CI wait defaults
+to 32 minutes; give the call the largest timeout it accepts (`timeout: 600000` in Claude Code). Where the
+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.
 
 **The count of unreleased merges is surfaced at completion — not a version.** It prints `🚚 unreleased
-merges on main: <n>` and puts the count in the Telegram. **Do not report a shipped version**: a child
-no longer bumps, so `package.json` names the previous release. What the run does about it is "When
-`pnpm josh release` runs" below.
+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
 
-The command closes with one `followup stage: <name> <seconds>` row per stage and a
-`followup stages total:` line, so where it spent its time is read, not guessed.
+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` — a short block is
-  the run stopping early, not the printer breaking. The `merge` row appears only on a run that merged.
+- **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, because it is the merge gate.
-- **The total is the sum of the stages**, not the wall clock — the post-merge tail (record clears, the
-  hold release, the next-issue listing) sits outside it.
+  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:
 
@@ -108,36 +96,28 @@ pnpm josh notify --task-type failure --issue-url "<issue-url>" --body-file <reas
 
 ## AI reviewer comment scan
 
-`followup` scans top-level PR comments from AI reviewers **independently of CI status**, so a finding
-posted after CI goes green is not silently shipped.
+`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 to the PR and the run proceeds.
-- **A comment listing that could not be read is a standing blocker** — never an empty listing that
-  passes.
+  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 actionable count and unreadable line-comment listing are
-  audit notes rather than blockers. When it is reverted:
-  `docs/maintainers/followup-rationale.md` → "The temporary CodeRabbit exemption".
+  (restore via `JOSH_REQUIRED_CHECKS`); its findings are audit notes.
 
 ## Config file reporting
 
 `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
-completion 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 on demand; there is no flag to pass.
+notification and the Issue report. **It stops nothing.** `pnpm josh sync:scope` gives the same answer.
 
 ## When `pnpm josh release` runs
 
-**The release point is a position plus a command's answer, never a judgement.**
-
-**The position: once per invocation, after the last merge** — a lone `fullrun`'s only one, a
-`backlogrun`'s **last** child, never once per child. In a lane the parent asks it, in the primary
-checkout, after the last lane is closed.
+**The release point is a position plus a command's answer, never a judgement.** **The position: once
+per invocation, after the last merge** — a lone `fullrun`'s only one, a `backlogrun`'s **last** child.
+With lanes the parent asks it, in the primary checkout, after the last lane is closed.
 
 ```bash
 pnpm josh release:scope          # → required | skip | unknown
@@ -149,11 +129,9 @@ pnpm josh release:scope          # → required | skip | unknown
 | `skip`     | the count is zero — nothing is waiting to ship                   | Say so in one line and finish                                                     |
 | `unknown`  | the count could not be read                                      | **Report it as `unknown`** — it is never read as `skip`                           |
 
-**The run never types `pnpm josh release` itself.** It opens and merges a PR of its own and starts
-the tag → publish → `production` chain — outward-facing and effectively irreversible, so Tier C.
-Typing `fullrun` authorizes this Issue's merge and nothing past it; a person types the release in the
-primary checkout, on the default branch, with a clean tree. `release:scope` counts nothing of its own —
-it reads the same fetch-then-count `followup` uses for the Telegram line, so the two cannot disagree.
+**The run never types `pnpm josh release` itself** — it starts the tag → publish → `production` chain,
+outward-facing and effectively irreversible, so Tier C. A person types it in the primary checkout, on
+the default branch, with a clean tree.
 
 **On `required`, the release request cites the open release Issue** — the one `issue:file --release` / `issue:release <N>` links blockers to — with a number-link
 (`prompts/collaboration-workflow/issue-citation.md`). List it with

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

@@ -1,8 +1,7 @@
 # `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
 
@@ -31,8 +30,7 @@ fit**: open the PR between the rounds with `pnpm josh git -y "<title> #<N>"`, ru
 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
+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

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

@@ -1,11 +1,9 @@
 # `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
 

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

@@ -2,13 +2,9 @@
 
 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.
 
-`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
 

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