@joshuafolkken/kit 1.1455.0 → 1.1514.0

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

@@ -1,99 +1,74 @@
 # `backlogrun` — a child that cannot finish
 
 **Read this file in full when a child cannot finish** — before parking it, before a
-`needs-human-review` stop, or before recording a mid-run prerequisite or split. It is a point-of-use
-document, never an entry read: the entry procedure is `backlogrun.md`, which points here at that
-moment. This file is the single source of park-and-continue, the
-`needs-human-review` stop, a stale `in-progress`, a prerequisite discovered mid-run, and a mid-run
-split. Provenance of each rule: `docs/maintainers/backlogrun-park-rationale.md` → "Where each rule came from".
+`needs-human-review` stop, or before recording a mid-run prerequisite or split.
 
 ## What happens to a child that cannot finish
 
-Nothing here is new, and nothing here is restated — a `backlogrun` child is a `fullrun` under a batch
-authorization, whether it came from a named epic or from the opted-in pool:
-
-- **A stop that would end the run parks one issue and the run continues** — → "park
-  and continue", which is that rule's single source, including what happens to the issue's lane.
-- **A prerequisite discovered mid-run is recorded as a dependency rather than parked** —
-  → "A prerequisite discovered mid-run", and `prerequisite.md` for the three-way
-  distinction between a prerequisite, a split and an upstream defect. With no epic there is no
-  `pnpm josh epic --add` to record the ordering into, so the `blocked-by` relation is written on the
-  issue itself (step 3 below) — still a dependency, never a `needs-decision` park.
-- **A split found mid-run** files the children and the epic and does not stop the batch, because the
-  keyword already authorized a batch — `split-assessment.md` for the assessment, → "Splitting a child
-  mid-run" for the branch. The split child is not parked or counted as a failure; its new children
-  remain available to the normal `backlog:next` / `epic:next` offer.
-- **`in-progress` left behind by an interrupted run** is → "`in-progress` is removed by
-  whoever finds it stale".
+A `backlogrun` child is a `fullrun` under a batch authorization:
+
+- **A stop that would end the run parks one issue and the run continues** — → "park and continue".
+- **A prerequisite discovered mid-run is recorded as a dependency rather than parked** — → "A
+  prerequisite discovered mid-run"; `prerequisite.md` separates prerequisite, split and upstream
+  defect. With no epic, the `blocked-by` is written on the issue itself.
+- **A split found mid-run** files the children and the epic and does not stop the batch —
+  `split-assessment.md`, → "Splitting a child mid-run". Not a park, not a failure.
+- **`in-progress` left behind by an interrupted run** — → "`in-progress` is removed by whoever finds
+  it stale".
 - **A child released from `needs-decision` is re-dispatched to a lane, never implemented by the
-  parent.** The parent is an orchestrator: `backlogrun.md` → "Claim nothing at the entry — this
-  parent orchestrates and never implements" is the single source, and "Removing the label
-  is Tier A" below carries the re-dispatch itself. A released child takes a lane exactly as any batch child
-  does.
+  parent** — `backlogrun.md` → "Claim nothing at the entry — this parent orchestrates and never
+  implements".
 
 ## The parent does not investigate a lane failure itself
 
 **A lane failure whose reason is not on its Issue is read by a unit** — `pnpm josh delegate
-lane-failure-investigation`; the parent checks the cited lines and
-`pnpm josh issue:state` before it parks, re-dispatches or files.
+lane-failure-investigation`; the parent checks the cited lines and `pnpm josh issue:state` before it
+parks, re-dispatches or files.
 
 ## `needs-human-review` — the one stop that is not a park
 
-A child carrying **`needs-human-review`** is degraded to a `halfrun`-shaped stop and **the whole run ends
-there** — implementation and the verification gate run, nothing is committed, the working tree is left
-dirty and unstashed, a `confirmation` Telegram carrying the resume command goes out, and the remaining
-children are not started.
-
-**This is the exception to park-and-continue below** — rationale:
-`docs/maintainers/backlogrun-park-rationale.md` → "Why `needs-human-review` ends the run instead of parking".
+A child carrying **`needs-human-review`** stops `halfrun`-shaped and **the whole run ends there**:
+implementation and the gate run, nothing is committed, the tree is left dirty and unstashed, a
+`confirmation` Telegram carries the resume command, and the remaining children are not started.
 
-**The child goes on holding its repository.** `needs-decision` outranks `in-progress` in the
-per-repository exclusion so a parked child releases the checkout; this label deliberately does not,
-because releasing it would start the next child on top of uncommitted work. **Its lane is left open and
-untouched**, for the same reason. **Name the lane directory in the stop report and in the Telegram.** The lanes
-already in flight finish; no new lane is opened.
+**The child goes on holding its repository**, and **its lane is left open and untouched**. **Name the
+lane directory in the stop report and in the Telegram.** Lanes in flight finish; no new lane opens.
 
-**Never apply or remove the label** — a person's alone. Full definition and the
-`needs-decision` comparison: `needs-human-review.md`, which is the single source.
+**Never apply or remove the label** — a person's alone (`needs-human-review.md`, the single source).
 
 ## park and continue
 
-When a child hits something only a person can decide — → "Only a person's judgement carries
-`needs-decision`" below — **park the child and keep going.**
+When a child hits something only a person can decide (→ "Only a person's judgement carries
+`needs-decision`"), **park the child and keep going**:
 
 ```bash
 gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'
 pnpm josh issue:comment <N> --body-file <path>   # what needs deciding, and the options
 ```
 
-`in-progress` is left as it is, and the parked child does **not** hold the repository — `epic:next` gives
-`needs-decision` precedence over `in-progress`, so the next child is offered normally. Then return to
-step 1; the other children are unaffected unless they depend on this one.
+`in-progress` stays; the parked child does **not** hold the repository (`needs-decision` takes
+precedence in `epic:next`). Return to step 1.
 
 **A parked child's lane is kept, whether or not it had committed**, and every parked ending owes
-`pnpm josh run:release <N>` — `backlogrun-lanes.md` → "What happens to a lane", the single source. A
-lost merge race resolves in its lane instead (`backlogrun-recovery.md` → "Conflicts are not predicted").
+`pnpm josh run:release <N>` — `backlogrun-lanes.md` → "What happens to a lane". A lost merge race
+resolves in its lane instead (`backlogrun-recovery.md` → "Conflicts are not predicted").
 
 **Parking replaces stopping the session, not the rule that produced the stop** — an upstream defect is
 still filed at once, and a workaround is still forbidden. `epic:bundle`'s `ask` is Tier A, not a park:
-add the epic you recommend with `pnpm josh epic --add <E> <N> --after <M>` and record it on both
-Issues' `## Decisions`.
+`pnpm josh epic --add <E> <N> --after <M>` and record it on both Issues' `## Decisions`.
 
-**Removing the label is Tier A — do it without asking**, once the decision is recorded; without it the
-parked child never runs again:
+**Removing the label is Tier A — do it without asking**, once the decision is recorded:
 
 ```bash
 gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/needs-decision 2>/dev/null || true
 ```
 
 **The released child goes back to a lane, never into the parent's own context** — `pnpm josh
-lane:launch <N>` (`backlogrun.md` → "Claim nothing at the entry — this parent orchestrates and never
-implements").
+lane:launch <N>`.
 
 ## Only a person's judgement carries `needs-decision`
 
-**`needs-decision` means "a person has to choose", and nothing else.** This is the single source of
-when a run may apply it, by hand or through a park. It carries only:
+**`needs-decision` means "a person has to choose", and nothing else.** It carries only:
 
 - a design choice nobody has made;
 - a Tier B toss-up, or a Tier C action (`CLAUDE.md` → "Decision autonomy");
@@ -108,34 +83,24 @@ It never carries:
 - a defect in the running repository's own run tooling — the run fixes it and resumes
   (`prompts/collaboration-workflow/upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合").
 
-**When in doubt, it is Tier A**: decide, comment the decision, and continue. **A label a mechanical step applied** — a
-failed or abandoned child, a lost merge race's four conditions — is read against this list once its
-reason is known, and removed (Tier A, above) when the reason is not on it. Rationale:
-`docs/maintainers/backlogrun-park-rationale.md` → "Why a run spends no attention on a non-finding".
+**When in doubt, it is Tier A**: decide, comment the decision, and continue. **A label a mechanical step
+applied** (a failed or abandoned child, a lost merge race) is read against this list once its reason is
+known, and removed when the reason is not on it.
 
 ## `in-progress` is removed by whoever finds it stale
 
-A run's own ending removes `in-progress` — `pnpm josh followup` on a merge, `pnpm josh run:release <N>`
-on a stop. An interrupted run reaches neither and leaves it behind, and a child that carries it is
-excluded from every future `epic:next` — permanently. The removal below is the one hand-written call
-left, for a label no live run owns: another tree's record is not this tree's to release.
-**A session that detects a stale child removes the label itself** (Tier A) and reports it, before
-continuing the loop.
-
-**It costs more than that one child now.** An open issue carrying `in-progress` occupies one of the
-repository's lanes — whichever epic it belongs to — so a stale label narrows every epic that touches
-that checkout. **The rule therefore applies to any open issue in the repository, not only to this epic's
-children**, and `epic:next` names the holders on standard error. **Age alone is not the test.** Check the
-90-minute window below *and* look at what is holding it, because three states hold the label legitimately
-for longer: a `halfrun` stopped for manual verification, any run paused mid-child, and a child stopped by
-`needs-human-review` (which waits on a person reading an artifact, and carries its own label alongside
-`in-progress`). **All three leave uncommitted work in the checkout**, so `git status` there is the
-decisive read: a dirty tree means the hold is real — leave the label alone and report, never strip it and
-start a second child on top of that work.
-
-**A closed issue's labels are neither a finding nor something to clean up.** A closed issue holds no lane
-(`epic-busy.ts` counts holders from the open listing alone) and `epic:next` never offers it, so
-`in-progress` left behind on one changes nothing. **Do not report it, and do not strip it.**
+An interrupted run leaves `in-progress` behind, which excludes the child from `epic:next` permanently
+and occupies a lane. **A session that detects a stale child removes the label itself** (Tier A) and
+reports it, before continuing. **The rule therefore applies to any open issue in the repository, not
+only to this epic's children** (`epic:next` names the holders on standard error).
+
+**Age alone is not the test.** Past the 90-minute window, check what holds it: a `halfrun` stopped for
+manual verification, a run paused mid-child, and a `needs-human-review` child hold it legitimately.
+**All three leave uncommitted work in the checkout**, so `git status` there decides: a dirty tree means
+the hold is real — leave the label and report.
+
+**A closed issue's labels are neither a finding nor something to clean up** (no lane, never offered).
+**Do not report it, and do not strip it.**
 
 ```bash
 gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress 2>/dev/null || true
@@ -143,50 +108,35 @@ gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress 2>/dev/null
 
 ## A prerequisite discovered mid-run
 
-Finding that something else in **this** repository has to land first is not a split, and not an upstream
-defect. The child in hand is still one deliverable; it just needs another one before it. The three-way
-distinction, the `route:tier-a` filing command and the filing ceiling are `prerequisite.md`, the single
-source; what follows is this entry's branch.
-
-`<M>` below is the child being implemented when the prerequisite turned up; `<N>` is the new Issue.
+Something else in **this** repository has to land first: not a split, not an upstream defect.
+`prerequisite.md` is the single source of the distinction, the `route:tier-a` filing and the ceiling.
+`<M>` is the child in hand; `<N>` the new Issue.
 
-1. File the prerequisite Issue `<N>` with the `route:tier-a` label — Tier A for a first-party
-   repository, no confirmation. It is filed **first** because the next step names it.
-2. **Stash the work in progress.** A child is implemented on the default branch with an uncommitted tree,
-   so `<M>`'s half-finished edits are sitting there, and the next child's `pnpm josh ms`
-   would refuse or carry them into the prerequisite's branch and PR.
+1. File the prerequisite `<N>` with `route:tier-a` (Tier A, first-party, no confirmation) — **first**,
+   because the next step names it.
+2. **Stash the work in progress**:
 
    ```bash
    git stash push -u -m "backlogrun: paused #<M> for prerequisite #<N>"
    pnpm josh issue:comment <M> --body-file <path>   # what was stashed, and that #<N> must land first
    ```
 
-   **`-u` is not optional** (a new `*.test.ts` is untracked). The comment makes the paused state
-   auditable and tells the session that resumes `<M>` a stash is waiting. **Pop it by message, never by
-   position** — `pnpm josh stash:pop "backlogrun: paused #<M> for prerequisite #<N>"` — when `epic:next`
-   offers `<M>` again, after its `pnpm josh ms`. The stash is a repository-wide stack
-   every lane shares, so a bare `git stash pop` would take whichever lane last pushed; the message
-   targets this one. The prerequisite has merged by then, so expect to resolve conflicts.
-
-3. `pnpm josh epic --add <E> <N> --before <M>` — one command writes the task-list row, the declaration
-   and the `blocked-by` relation together. Never edit the body by hand: the declaration and the relations
-   then disagree, `epic:next` returns `error`, and the unattended run stops.
-   **With no epic** (a pool child), record the relation alone, `<M>` blocked by `<N>`, with the
-   `gh api …/dependencies/blocked_by` call in `prompts/collaboration-workflow/issue-template.md` →
-   "複数 Issue に分割するときの epic Issue", step 4.
-4. **Remove `in-progress` from `<M>`** — `pnpm josh run:release <M>`, which removes the label with the hold.
-   This is what lets `<M>` run again: `epic:next` classifies a child carrying `in-progress` as waiting on
-   time **before** it looks at any blocker, so a child left labelled is never offered again.
-5. **Do not park.** Go back to step 1 of the loop. `epic:next` classifies the original child as resolving
-   on its own and hands back the prerequisite first, so the order is kept with no human input.
-
-**A stop a dependency can express is never parked**, and a defect in this repository's own gate or run
-tooling is such a stop — `prerequisite.md` holds that rule and what the driver does with it.
+   **`-u` is not optional** (new test files are untracked). **Pop it by message, never by position** —
+   `pnpm josh stash:pop "backlogrun: paused #<M> for prerequisite #<N>"` — when `epic:next` offers `<M>`
+   again, after its `pnpm josh ms`; expect conflicts.
+3. `pnpm josh epic --add <E> <N> --before <M>` — row, declaration and `blocked-by` in one command;
+   never a hand edit. **With no epic**, record `<M>` blocked by `<N>` alone with the `gh api
+   …/dependencies/blocked_by` call in
+   `prompts/collaboration-workflow/issue-template.md` → "複数 Issue に分割するときの epic Issue", step 4.
+4. **Remove `in-progress` from `<M>`** — `pnpm josh run:release <M>`; a labelled child is never offered again.
+5. **Do not park.** Back to step 1 of the loop; `epic:next` hands back the prerequisite first.
+
+**A stop a dependency can express is never parked**, including a defect in this repository's own gate
+or run tooling — `prerequisite.md`.
 
 ## Splitting a child mid-run
 
-Discovering that a child is really several is not a reason to stop. File the new children with the
-`route:split` label (Tier A for a first-party repository — no confirmation), then add them with
-`pnpm josh epic --add <E> <N...> [--before <M> | --after <M>]` rather than editing the epic body by hand.
-Use the same split criteria as `kickoff`. If what remains of the original child needs a person, park
-**that** child and move on. Splitting alone never adds `needs-decision` to the promoted epic.
+Not a reason to stop. File the new children with `route:split` (Tier A, first-party), then
+`pnpm josh epic --add <E> <N...> [--before <M> | --after <M>]` — never a hand edit. Same criteria as
+`kickoff`. If what remains needs a person, park **that** child and move on. Splitting alone never adds
+`needs-decision` to the promoted epic.

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

@@ -1,14 +1,11 @@
 # `backlogrun` — progress, the hand-off, resume and waiting
 
-Point-of-use, read one section at a time from `backlogrun.md` → "The route table"; the heartbeat is `progress-watcher.md` → "Progress while the run is quiet".
+Point-of-use, read one section at a time from `backlogrun.md` → "The manifest — the ordered flow"; the heartbeat is `progress-watcher.md` → "Progress while the run is quiet".
 
 ## Running a named epic's children
 
-**`backlog:drive` walks this loop on its own; a session runs it when the driver hands back `epic #N`**
-(the loop: `docs/maintainers/backlogrun-driver.md`; rationale:
-`docs/maintainers/backlogrun-progress-rationale.md` → "Why a named epic's children run in lanes";
-`docs/maintainers/backlogrun-progress-rationale.md` → "Why state lives in records, not the
-conversation"). Each child runs as `fullrun #<N>` in a lane —
+**`backlog:drive` walks this loop on its own; a session runs it when the driver hands back `epic #N`.**
+Each child runs as `fullrun #<N>` in a lane —
 `pnpm josh lane:launch <N>` (`backlogrun-lanes.md` → "Opening one lane and dispatching its child"),
 then `pnpm josh lane:await <N...> --owner "$PPID"` in the background — and every ending is read by one
 command:
@@ -20,10 +17,7 @@ next=$(pnpm josh run:merge <N> --epic <E> --repo <owner/repo> --owner "$PPID" --
 **`pnpm josh run:merge <N>` is the only reading of how a child ended** — never
 classify `issue:state` by hand or ask `epic:next` in its place. **Pass `--output <path>`, the child's
 transcript**; the named-epic flags are dropped for the opted-in backlog. It classifies, counts, closes
-the lane and comments itself; act on the token. Rationale:
-`docs/maintainers/backlogrun-progress-rationale.md` → "Why a child's ending is read by `run:merge` alone";
-`docs/maintainers/backlogrun-progress-rationale.md` → "Why a child's ending is classified at once";
-provenance of each rule: `docs/maintainers/backlogrun-progress-rationale.md` → "Where each rule came from".
+the lane and comments itself; act on the token.
 
 | It prints | What the run does |
 | --- | --- |
@@ -41,10 +35,9 @@ provenance of each rule: `docs/maintainers/backlogrun-progress-rationale.md` →
 ## After a named epic completes
 
 **When a named epic's children are all processed — merged or parked — the run advances to the next
-named item, and then drains the opted-in backlog** (unless `--only`, which stops after the named
-list). A completed epic is one step of the invocation, never its end. A named item that is a bare,
-non-epic Issue reaches the same point when it merges. The epic's own completion summary is sent by the
-session standing in the repository that owns it ("Who sends the summary, and who propagates" below).
+named item, and then drains the opted-in backlog** (unless `--only`). A completed epic — or a merged
+bare named Issue — is one step of the invocation, never its end. Its summary is sent per "Who sends the
+summary, and who propagates" below.
 
 ## The hand-off — one session does not have to run the whole batch
 
@@ -53,8 +46,7 @@ after every child's merge and `pnpm josh ms`, never wired to `pnpm josh delegate
 carrying the budget** (`backlogrun-steps.md` → "The session cut is inside the invocation"); it is not a
 stop. The threshold is `CONTEXT_CUT_THRESHOLD` in `scripts/cost-runtime/context-cut-threshold.ts`
 (135,000, shared by the scheduler entry, hand-off and the lane worker cut, `pre-gate-cut.md` → "The
-implementation-phase cut"). Rationale: `docs/maintainers/backlogrun-progress-rationale.md` → "Why the
-hand-off check is asked at every merge".
+implementation-phase cut").
 
 | It answers | What the run does |
 | --- | --- |
@@ -73,8 +65,7 @@ and output path; fill a missing path with `pnpm josh lane:output <N> <path>`:
   closed by `pnpm josh lane:prune`.
 - **Every in-flight lane records a path** — count everything, run `pnpm josh run:carry --cut --owner
   "$PPID"`, post the progress comment naming every lane and its path with `pnpm josh run:board`, and end
-  the turn; the `run:wake` driver polls the lanes. Rationale:
-  `docs/maintainers/backlogrun-progress-rationale.md` → "Why lanes are handed over rather than drained".
+  the turn; the `run:wake` driver polls the lanes.
 - **`--cut` answers `capped`** (`MAX_CUTS`) — **do not `run:wake` or hand off**;
   carry this session on and re-ask at the next merge.
 
@@ -88,13 +79,12 @@ park** — nothing is labelled, stashed or filed.
 
 ### Picking the lanes up in the fresh session
 
-**Start no child again and open no lane already open.** In one turn: `pnpm josh lane:list` (every line
-with a path is a handed-over child, polled per `backlogrun-recovery.md` → "A delegated unit that stopped
+**Start no child again and open no lane already open.** In one turn: `pnpm josh lane:list` (a line
+with a path is a handed-over child, waited on per `backlogrun-recovery.md` → "A delegated unit that stopped
 without reporting"), `pnpm josh run:progress --wait --output <handed-over paths>` in the background
-(the `run:watcher:guard` enforces it), `pnpm josh run:liveness`, and
-`epic:next --lanes` with a lane for each child it offers. **A carried-over child finishes in its own
-unit — never run its `followup` yourself**; one that did not survive the cut is re-dispatched with
-`pnpm josh lane:open <N>` then `pnpm josh lane:dispatch <N>`, never adopted.
+(`run:watcher:guard`), `pnpm josh run:liveness`, and `epic:next --lanes`, a lane per child it offers.
+**A carried-over child finishes in its own unit — never run its `followup` yourself**; one lost in the
+cut is re-dispatched with `pnpm josh lane:open <N>` then `pnpm josh lane:dispatch <N>`.
 
 ### What carries over
 
@@ -106,15 +96,14 @@ the epic body; what merged the epic's task list.
 
 | Setting | Value | Meaning |
 | --- | --- | --- |
-| Polling interval | 60 s | **In flight, a floor between two asks, never a clock** — the wake is `lane:await`'s completion or the watcher's arrival exit, never a report. **With nothing in flight no wake comes: it is the parent's own clock.** A `backlogrun` idle watch is polled at this same interval. |
+| Re-ask floor | 60 s | **In flight, never a clock — the wait is `backlog:drive` or `lane:await`**, and the wake is their exit or the watcher's arrival exit, never a report; a state read repeated with nothing decided in between is refused. **With nothing in flight no wake comes: it is the parent's own clock.** A `backlogrun` idle watch re-asks at this same floor. |
 | Silent delegated unit | 30 min | Not the child's duration — the time its output has gone **unchanged**. Past it, ask `run:liveness` and book a stopped unit as a failure. |
 | Stale `in-progress` | 90 min | Past it, the other session is gone. |
 | Publish wait | 10 min | `josh propagate`'s own budget. A failed publish never appears. |
 | `backlogrun` idle watch | 8 h | Counted from when the run's hands became free, never from its start; `pnpm josh backlog:budget` decides it. |
 
-Each timeout **ends the wait and reports** — none is retried indefinitely. Rationale for the figures:
-`docs/maintainers/backlogrun-progress-rationale.md` → "Why the parent waits on classification, not a
-clock". A stale child's label is removed first, so the next poll can offer it. **A graph that has
+Each timeout **ends the wait and reports** — none is retried indefinitely. A stale child's label is
+removed first, so the next ask can offer it. **A graph that has
 deadlocked on a cycle is not this loop's to untangle**: `epic:next` detects it and exits with an error.
 
 ## Who sends the summary, and who propagates

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

@@ -4,7 +4,8 @@ Point-of-use, read one section at the failure that reaches it; the single source
 
 ## A delegated unit that stopped without reporting
 
-**A stop from outside leaves no notification behind, so the parent polls rather than waits.** Record
+**A stop from outside leaves no notification behind, so the parent waits on `lane:await`, whose exit
+covers it.** Record
 where a lane child writes with `pnpm josh lane:output <N> <path>` in the dispatch turn, and once its
 output has been unchanged for the silent-unit window (`backlogrun-progress.md` → "Waiting, and never
 waiting forever") **ask the command rather than combining the traces yourself**, in the checkout the
@@ -18,14 +19,11 @@ pnpm josh run:liveness <N> --output <absolute path> --process <command lines nam
 
 | Answer | What the parent does |
 | --- | --- |
-| `alive` | Keep polling; touch nothing |
+| `alive` | Wait on `lane:await` again; touch nothing |
 | `settled` | Re-read with `pnpm josh run:status <N>` and take the branch its state section says |
 | `undetermined` | Read the trace that failed and ask again. **A second in a row on the same child is a fault in the check**: send a `confirmation` naming the trace and stop — never escalate it to `stopped` |
 | `stopped` | The recovery below |
 
-Rationale: `docs/maintainers/backlogrun-recovery-rationale.md` → "Why liveness needs silence and no
-process together".
-
 **On `stopped`, re-read with `pnpm josh run:status <N>`.** **A re-read carrying `needs-decision`** — the
 unit parked it, then stopped: leave the label on and count nothing. Otherwise, while `state: OPEN`:
 
@@ -39,27 +37,22 @@ unit parked it, then stopped: leave the label on and count nothing. Otherwise, w
    the stale `in-progress` itself.
 3. **Act on the token it printed** — `backlogrun-progress.md` → "Running a named epic's children".
 
-Rationale: `docs/maintainers/backlogrun-recovery-rationale.md` → "Why the poll routes through `run:merge`".
-
-## Conflicts are not predicted
+## A person withdraws a running child
 
-**The child merges `origin/main` into its lane before its gate now, so this path is the fallback rather
-than the first line.** Every `fullrun` runs `pnpm josh main:merge` ahead of the gate
-(`chain-rule.md` → "origin/main is merged in before the gate", the single source), so an overlap
-already on `main` is resolved before the gate reads the tree. What this section covers is an overlap
-that lands on `main` *after* it, which `followup` still reports as a conflict.
+On a person's instruction to drop a running child's issue, run `pnpm josh lane:withdraw <N>
+--reason "<their reason>"` — `docs/josh-commands.md` → "`josh lane:withdraw`".
 
-**Nothing here forecasts which children will overlap.** The overlap surfaces where GitHub already
-reports it: a pull request that conflicts with its base comes back `mergeStateStatus: DIRTY`, which
-`git-pr-checks-eval.ts` reads as a **failure** rather than polling through it — so `pnpm josh followup`
-ends that child with a named conflict in about ten seconds.
+## Conflicts are not predicted
 
-**That child does not stop: it resolves the conflict in its own lane.** It is **not** counted against
-the consecutive-failure guard either way.
+**This path is the fallback**: every `fullrun` runs `pnpm josh main:merge` ahead of the gate
+(`chain-rule.md` → "origin/main is merged in before the gate"), so it covers an overlap that lands on
+`main` *after* it. **Nothing here forecasts which children will overlap** — a conflicting pull request
+comes back `mergeStateStatus: DIRTY`, which `git-pr-checks-eval.ts` reads as a **failure**, so `pnpm josh
+followup` ends that child with a named conflict in about ten seconds.
 
-**The merge direction is `origin/main` into the lane's branch, never a rebase**, and no step below
-rewrites a pushed commit. Rationale: `docs/maintainers/backlogrun-recovery-rationale.md` → "Why a conflict
-is resolved in the lane rather than handed to a person".
+**That child does not stop: it resolves the conflict in its own lane**, uncounted by the
+consecutive-failure guard. **The merge direction is `origin/main` into the lane's branch, never a
+rebase**; no step rewrites a pushed commit.
 
 1. **Resolve in the lane.** `git fetch origin main`, merge `origin/main` into the lane's branch, resolve
    in place. Do not close the lane, open another, or switch its branch.
@@ -96,7 +89,5 @@ Meeting any of the four, the child is parked — `needs-decision` plus a comment
 it was, read against `backlogrun-park.md` → "Only a person's judgement carries `needs-decision`" — and its lane is **kept**, because the pushed branch is the resume path
 (`backlogrun-lanes.md` → "What happens to a lane").
 
-**Leave the tree clean before parking: `git merge --abort` precedes a park under conditions 1, 2 or 4.**
-Conditions 1 and 2 are read mid-merge with conflict markers still in the tree, condition 4 after a merge
-that is resolved but not committed; condition 3 fires before any merge is started, so there is nothing
-to abort.
+**Leave the tree clean before parking: `git merge --abort` precedes a park under conditions 1, 2 or 4**
+(condition 3 fires before any merge starts).

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

@@ -1,26 +1,22 @@
 # `backlogrun` — the detailed procedure behind the manifest
 
-Point-of-use, read one section at a time from `backlogrun.md` → "The route table"; how the driver runs the loop on its own is `docs/maintainers/backlogrun-driver.md`.
+Point-of-use, read one section at a time from `backlogrun.md` → "The manifest — the ordered flow".
 
 ## What one invocation approves
 
 **One `backlogrun` approves every merge of every issue `pnpm josh backlog:next` offers** — `auto-ok`
 issues, every child of an epic whose root carries it, and a run's own filing once `pnpm josh
 epic:bundle` (Tier A, `observation-filing.md`) has placed it under such a root. **A named issue is
-approved by the keyword and its number, not by `auto-ok`** ("Named issues run first, in order"). What
-runs is stated by the keyword and its arguments, never inferred from a request's shape. **Two repairs
-that would bound this the other way are prohibited** — dropping a run's own filings, and requiring a
-person's `auto-ok` on a child; the brake below bounds it. A Tier C action inside a child still stops that child.
+approved by the keyword and its number, not by `auto-ok`**. What runs is stated by the keyword and its
+arguments, never inferred. **Two repairs that would bound this the other way are prohibited** —
+dropping a run's own filings, and requiring a person's `auto-ok` on a child; the brake below bounds it.
+A Tier C action inside a child still stops that child.
 
 **`pnpm josh issue:file` judges `auto-ok` and prints it** — `auto-ok: applied` or
-`auto-ok: not applied` with the reason; `scripts/issue/issue-auto-ok.ts` is the single source. Every
-filing is judged the same way, whoever asked for it: the excluded labels, then the body's
-`- 人の判断:` declaration (`issue-template.md`). **Declare `- 人の判断: 要` when the new issue needs a
-person's judgement** — a Tier B toss-up or a Tier C action inside it; `--no-auto-ok` withholds it too.
-The retrospective's filings are judged the same way and count against the same brake.
-
-Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the authorization boundary is shaped this way";
-provenance of each rule: `docs/maintainers/backlogrun-steps-rationale.md` → "Where each rule came from"
+`auto-ok: not applied` with the reason (`scripts/issue/issue-auto-ok.ts`). Every filing, the
+retrospective's included, is judged the same way: the excluded labels, then the body's `- 人の判断:`
+declaration (`issue-template.md`). **Declare `- 人の判断: 要` when the new issue needs a person's
+judgement** — a Tier B toss-up or a Tier C action inside it; `--no-auto-ok` withholds it too.
 
 ### The brake that replaces the promise
 
@@ -33,30 +29,26 @@ provenance of each rule: `docs/maintainers/backlogrun-steps-rationale.md` → "W
 | **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` |
 | 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 authorization
-boundary meet.** `observation-filing.md` points here rather than restating it.
+**This section is the single source of how the `epic:bundle` obligation and this boundary meet.**
 
 ## Named issues run first, in order
 
-**`backlogrun #N1 #N2 …` runs the named issues before it touches the pool**,
-in the order typed, **one at a time — no lanes**, each as a full `fullrun` in a delegated unit
-(`backlogrun-child.md` → "Each child runs in a delegated unit"); the parent reads each one's state back
-with `pnpm josh issue:state <N>`, never the unit's summary. `pnpm josh backlog:plan #N1 #N2 …` renders
-the order, and `scripts/backlog/backlog-named.ts` is its single source.
+**`backlogrun #N1 #N2 …` runs the named issues before it touches the pool**, in the order typed, **one
+at a time — no lanes**, each as a `fullrun` in a delegated unit (`backlogrun-child.md` → "Each child
+runs in a delegated unit"), read back with `pnpm josh issue:state <N>`. `pnpm josh backlog:plan #N1
+#N2 …` renders the order (`scripts/backlog/backlog-named.ts`).
 
-**A named issue that cannot finish parks, and the rest of the named list is skipped**; the run then
-drains the pool, and the report lists what was not started (`backlog_named.after_failure`). A
-`needs-human-review` named issue stops the whole run (`needs-human-review.md`). **`--only` runs the
-named list and stops there, draining no pool** — a failure under `--only` ends the run, and `--only`
-with no named issues is refused before anything starts (`backlog_named.startup`).
+**A named issue that cannot finish parks, and the rest of the named list is skipped**; the run drains
+the pool and reports what was not started (`backlog_named.after_failure`). A `needs-human-review` named
+issue stops the whole run. **`--only` runs the named list and stops there, draining no pool** — a
+failure ends the run, and `--only` with no named issues is refused (`backlog_named.startup`).
 
 ## The session cut is inside the invocation
 
 **Typing `backlogrun` once authorizes the declared budget, and a session cut does not end the run** —
-the next session picks the same invocation up from the carry record (`backlogrun-progress.md` → "The
-hand-off"). The record keeps the opening invocation string, `--only` and the named list included; a
-resumed session runs `remaining` from `--json`. The contract is `docs/josh-commands-run.md` →
-"`josh run:carry`".
+the next session resumes the invocation from the carry record (`backlogrun-progress.md` → "The
+hand-off"), which keeps the invocation string, `--only` and the named list; it runs `remaining` from
+`--json` (`docs/josh-commands-run.md` → "`josh run:carry`").
 
 ```bash
 pnpm josh run:carry --begin "backlogrun --max 5 --idle 30" --owner "$PPID"
@@ -64,9 +56,9 @@ pnpm josh run:carry --json                                                   # r
 pnpm josh run:wake --start                                                   # same turn as --begin; `running` under `josh backlogrun`
 ```
 
-**Always pass `--owner "$PPID"`**, and ask it before the plan, in the same turn as the first `pnpm josh
-ms`. **The record is the parent loop's, and a lane never touches it**; count into it with `--merged <N>`
-and `--filed 1`, and **`--cut` is the session's last write**.
+**Always pass `--owner "$PPID"`**, before the plan, in the same turn as the first `pnpm josh ms`. **The
+record is the parent loop's; a lane never touches it**. Count with `--merged <N>` and `--filed 1`;
+**`--cut` is the session's last write**.
 
 | It answers | What the run does |
 | --- | --- |
@@ -85,30 +77,27 @@ named epic's children", never the root as a standalone `fullrun`, then ask `pnpm
 a child number or `complete` continues; only `stop` or a failure records `pnpm josh run:carry --done <E>
 --owner "$PPID"`.
 
-**A person keeps control of the run** — `pnpm josh run:wake --list` reads it, `pnpm josh backlogrun
---stop` stops it (`docs/josh-commands.md` → "`josh backlogrun`").
-
-Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why a session cut does not end the run"
+**A person keeps control** — `pnpm josh run:wake --list` reads it, `pnpm josh backlogrun --stop` stops
+it (`docs/josh-commands.md` → "`josh backlogrun`").
 
 ## The plan, before the first child starts
 
 **Report the plan before anything is dispatched. The plan is one command's output** — `pnpm josh
-backlog:plan`, rendered from the same
-pool `backlog:next` answers from. Report all four of its sections (Ready now, Waiting, Waiting on a
-person, Out of scope) to the person in the session language, with any truncated-listing `⚠`.
+backlog:plan`, from the pool `backlog:next` answers from. Report all four sections (Ready now, Waiting,
+Waiting on a person, Out of scope) in the session language, with any truncated-listing `⚠`.
 
 ### Resolve what the plan can resolve, before starting
 
 **Settle every `needs-decision` issue the plan listed in one pass**, from one `pnpm josh issue:read <N>
-<N> …` call (body and comments, `issue-comments.md`):
+<N> …` call (`issue-comments.md`):
 
 - **An answer already in the issue** — record it as a comment and **remove the label** (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`"); the next plan classifies it by the label alone.
-- **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.
+  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**.
 - **Report `pnpm josh backlog:plan --waves`** with the plan, never an order derived by hand; then start
@@ -116,9 +105,7 @@ person, Out of scope) to the person in the session language, with any truncated-
 
 **`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`, which check the exclusions first.
-
-Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the plan and the decision pass come first"
+`pnpm josh issue:file` or `pnpm josh auto-ok:judge`.
 
 ## The loop
 
@@ -140,11 +127,7 @@ section the row names:
 | `window` | Hand the loop back as is | — |
 
 **A candidate only in another repository is never a token** — report it with its checkout. The budgets,
-verdicts and stops are the driver's own: `docs/maintainers/backlogrun-driver.md` (rationale:
-`docs/maintainers/backlogrun-steps-rationale.md` → "Why the idle watch lasts 8 hours from when the hands became free";
-`docs/maintainers/backlogrun-steps-rationale.md` → "Why the cost check skips a watch").
-
-Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the loop's contract is shaped this way"
+verdicts and stops are the driver's own.
 
 ## What runs once per session, not once per issue