@joshuafolkken/kit 1.1453.0 → 1.1471.0

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

@@ -24,6 +24,6 @@ structure and the label translations are `prompts/collaboration-workflow/report-
 - One sentence per line, no internal identifiers, every child named by number. **Never omit
   `Remaining`** — it is the one line that tells this report from a completion report
 - Telegram uses the same format and is **sent with `--task-type confirmation`** (`completion` would
-  announce an unfinished epic as done)
+  announce an unfinished epic as done), `--recommended` naming the resume command
 - **Write it only when the run stops.** While a run carries on past the threshold it writes none; the
   epic progress comment is the record

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

@@ -1,14 +1,21 @@
 # `backlogrun` — lanes and concurrency
 
-Point-of-use, read one section at a time from `backlogrun.md` → "The route table".
+Point-of-use, read one section at a time from `backlogrun.md` → "The route table". Reasons:
+
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Why the lane ceiling is shaped the way it is"
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Why CI concurrency is capped by the lane limit"
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Why a lane's review needs a brief and an attestation"
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Why the lane branch is `<N>-lane` and never switched"
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Why lanes cost as well as buy throughput"
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Why `lane:launch` folds the lane steps into one"
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Why a committed child's lane is kept"
+- `docs/maintainers/backlogrun-lanes-rationale.md` → "Where each rule came from"
 
 ## Concurrency: as many children per repository as it has free lanes
 
-**One session per repository**, each running only its own repository's children; the per-repository
-lane ceiling (`JOSH_LANE_LIMIT`, counted from the `in-progress` listing by `epic:next`) is
-`.claude/skills/epic-commands/SKILL.md` → "An `in-progress` issue occupies a lane", and a dependency that crosses a
-repository is `.claude/skills/epic-commands/SKILL.md` → "Epics that span repositories". Rationale:
-`docs/maintainers/backlogrun-lanes-rationale.md` → "Why the lane ceiling is shaped the way it is".
+**One session per repository**, each running only its own repository's children. The lane ceiling is
+`.claude/skills/epic-commands/SKILL.md` → "An `in-progress` issue occupies a lane"; a dependency that
+crosses a repository is `.claude/skills/epic-commands/SKILL.md` → "Epics that span repositories".
 
 ## A solo run
 
@@ -19,65 +26,50 @@ it a defect (not an improvement, refactor, removal or feature)? Is it in kit's o
 (lint / type check / spell check / unit tests), the code review, the pre-push hook, or the merge
 checks — not a consumer repository's CI or template? Does it, on `main` now, make unrelated PRs
 answer wrongly (a false green or a false red)? All three, and the issue carries `run:solo`; any one
-missing, and it carries `run:lane`. `backlog:next` and `epic:next --lanes` answer `triage` for an issue
-with neither, so an issue a run files carries one of the two from its
-filing. **It stops the other lanes for one reason only: a batch run on broken verification leaves
-nobody's result trustworthy.** This section is the rule's single source; rationale:
-`docs/maintainers/wip-cap-rationale.md` → "Why a solo run"; provenance:
-`docs/maintainers/backlogrun-lanes-rationale.md` → "Where each rule came from".
+missing, and it carries `run:lane`. `backlog:next` and `epic:next --lanes` answer `triage` for an
+issue with neither, so a filed issue carries one of the two from its filing. **It stops the other
+lanes for one reason only: a batch run on broken verification leaves nobody's result trustworthy.**
+This section is the rule's single source; why: `docs/maintainers/wip-cap-rationale.md` → "Why a solo run".
 
 ## Lanes — running more than one child at a time
 
-`pnpm josh epic:next <E> --repo <owner/repo> --lanes` answers with **one issue number per line**, up to
-the number of free lanes, and each of those children runs in a **lane** of its own: a linked git work
-tree with its own branch, its own `.env` and its own dev and preview ports (`docs/josh-commands-run.md` →
-"`josh lane:open` / `josh lane:close` / `josh lane:list` / `josh lane:prune`"). **Implementation, the
-verification gate and the review run in parallel; the merges stay serial** — each one lands on the
-`main` the next is then measured against.
-
-**A lane child may cut its own turn before the gate.** Implementation done, it ends its process and a
-fresh one resumes the same lane from the gate onward — the boundary, the two commands and the resume
-verification are `pre-gate-cut.md`, the single source. **The child is told apart from a person, and its
-resume stage is handed to it, by a mark the dispatch sets** — `JOSH_LANE_CHILD`, the lane's issue
-number (`pre-gate-cut.md` → "The dispatch mark" and "The stage is passed to the resumed child").
-
-**A lane's review does not inherit the lane, and `pnpm josh review:brief` is what closes that.**
-`pnpm josh review:brief` prints the lane's absolute root, branch and HEAD, hands over targets written
-`git -C <root> …`, and prints a nonce the review attests with `pnpm josh review:attest <nonce>` from
-the checkout it actually read. **The child asks `pnpm josh review:attest --check` before it counts a
-round**, and `pnpm josh followup` asks again before it merges; `missing` and `mismatch` are both
-refusals. A clean round is the case to check hardest, not the case to skip the check on. Rationale:
-`docs/maintainers/backlogrun-lanes-rationale.md` → "Why a lane's review needs a brief and an
-attestation".
-
-**A lane's branch is `<N>-lane`, and the issue number leads it so that the commit path accepts it.**
-**Never switch the lane to another branch** — a switched lane loses its seat, its listing and its
-isolation. So `epic:next` is asked **with** `--lanes`, and everything below runs as written. Rationale:
-`docs/maintainers/backlogrun-lanes-rationale.md` → "Why the lane branch is `<N>-lane` and never
-switched".
-
-**Report the throughput gain only with its merge-race cost** — every overlap that becomes a conflict
-costs a resolution, a re-run gate and a review (`backlogrun-recovery.md` → "Conflicts are not predicted"). Rationale:
-`docs/maintainers/backlogrun-lanes-rationale.md` → "Why lanes cost as well as buy throughput".
+`pnpm josh epic:next <E> --repo <owner/repo> --lanes` answers **one issue number per line**, up to the
+free lanes. Each child runs in a **lane**: a linked work tree with its own branch, `.env` and ports
+(`docs/josh-commands-run.md` → "`josh lane:open` / `josh lane:close` / `josh lane:list` / `josh
+lane:prune`"). **Implementation, the verification gate and the review run in parallel; the merges
+stay serial.**
+
+**A lane child may cut its own turn before the gate** — `pre-gate-cut.md`, the single source. The
+child is told apart from a person, and handed its resume stage, by `JOSH_LANE_CHILD`
+(`pre-gate-cut.md` → "The dispatch mark" and "The stage is passed to the resumed child").
+
+**A lane's review does not inherit the lane, and `pnpm josh review:brief` is what closes that**: it
+prints the lane's root, branch and HEAD, targets written `git -C <root> …`, and a nonce the review
+attests with `pnpm josh review:attest <nonce>`. **The child asks `pnpm josh review:attest --check`
+before it counts a round**, and `pnpm josh followup` asks again before merging; `missing` and
+`mismatch` are refusals. A clean round is checked hardest.
+
+**A lane's branch is `<N>-lane`. Never switch the lane to another branch** — it loses its seat,
+listing and isolation. So `epic:next` is asked **with** `--lanes`.
+
+**Report the throughput gain only with its merge-race cost** (`backlogrun-recovery.md` → "Conflicts
+are not predicted").
 
 ### Once per repository, before the first lane opens
 
-In the **primary checkout**, in this order, never again per lane: `pnpm josh ms`; `pnpm josh
-latest:scope` and the update on `required` (`backlogrun-child.md` → "`josh latest` runs once per
-session, not once per child"); `pnpm josh lane:prune`; `pnpm josh run:tidy`.
+In the **primary checkout**, in order, never per lane: `pnpm josh ms`; `pnpm josh latest:scope` and the
+update on `required` (`backlogrun-child.md` → "`josh latest` runs once per session, not once per
+child"); `pnpm josh lane:prune`; `pnpm josh run:tidy`.
 
-**The rewritten lock file reaches a pull request through the first lane.** In the primary checkout,
-only if the update rewrote anything, `git stash push -u -m "backlogrun: josh latest before lanes"`, and
-record it on that first child's Issue. **The first lane's `pnpm josh lane:launch "$n" --stash
-"backlogrun: josh latest before lanes"` pops it by message** — never a positional `stash pop` on the
-shared stack. **Under `backlog:drive` the driver passes `--stash`, never you**; the push stays the
-parent's, before the driver starts.
+**The rewritten lock file reaches a pull request through the first lane.** Only if the update rewrote
+anything: `git stash push -u -m "backlogrun: josh latest before lanes"` in the primary checkout, and
+record it on the first child's Issue. **The first lane's `pnpm josh lane:launch "$n" --stash
+"backlogrun: josh latest before lanes"` pops it by message** — never a positional `stash pop`. **Under
+`backlog:drive` the driver passes `--stash`, never you**; the push stays the parent's.
 
 ### Opening one lane and dispatching its child
 
-**One command opens the lane, prepares it, and dispatches the child — `pnpm josh lane:launch`** (over
-`lane:open`, `stash:pop` and `lane:dispatch`, each guard unchanged; rationale:
-`docs/maintainers/backlogrun-lanes-rationale.md` → "Why `lane:launch` folds the lane steps into one"):
+**One command opens the lane, prepares it, and dispatches the child — `pnpm josh lane:launch`**:
 
 ```bash
 pid=$(pnpm josh lane:launch "$n") || exit 1   # the child's pid on stdout, nothing else
@@ -90,93 +82,71 @@ pid=$(pnpm josh lane:launch "$n") || exit 1   # the child's pid on stdout, nothi
 | empty, non-zero, `already-open` or a failed install | **Park that child and name `pnpm josh lane:close <N>`** — a lock the lane cannot build is a person's to fix |
 | `lane:open` reports a reused `<N>-lane` on stderr | The way back to a child parked after it pushed — **a reused branch is not a fresh lane** |
 
-**Nothing switches the lane's branch.** In a lane `lane:open`'s answer replaces `pnpm josh run:hold`'s
-preflight, and the child claims `run:hold` inside the lane, keyed on its own git directory.
+**Nothing switches the lane's branch.** In a lane, `lane:open`'s answer replaces `pnpm josh
+run:hold`'s preflight; the child claims `run:hold` inside the lane.
 
 ### Handing the child over
 
-The child runs as `fullrun #<N>` in that lane, and neither `josh latest` nor a progress watcher is
-started there. Everything else — the plan, the gate, `/code-review`, `pnpm josh git`,
-`pnpm josh followup` — is unchanged, and `pnpm josh followup` releases that lane's hold at the merge.
-
-**The child is started as a process of its own, not as a subagent of this session** — `lane:launch`'s
-final step, the `lane:dispatch` it runs after the lane is opened and prepared, whose pid it returns.
-The bullets below describe that dispatch:
-
-- **It records where the child writes as it starts it** — the dispatch's own
-  `<temp>/josh-lane-dispatch-<N>.log`.
-- **A refusal is an empty capture beside a non-zero exit**, and every refusal also sends a `warning`
-  Telegram — no lane open, a path that could not be recorded, a launch that failed. **Park that child
-  and name the log the message carries**; do not re-dispatch into the same lane without reading it.
-- **A child that started with nowhere to write exits zero and warns.** The launcher starts the session
-  even when it could not open the log, so the child really is running. **Poll that lane on the process
-  trace alone**, because its log will never grow.
-- **The child is started as `fullrun #<N>` with the lane as its working directory.** The batch a
-  person approved by typing `backlogrun` covers the child.
-- **It passes `--permission-mode bypassPermissions`, never `--dangerously-skip-permissions`.** A
-  current Claude Code ignores the mode `.claude/settings.json` declares, and a new lane worktree is
-  never a trusted workspace; that file's `deny` list still refuses what it names, so the run reports
-  what stopped rather than loosening it.
+The child runs as `fullrun #<N>` in that lane, with neither `josh latest` nor a progress watcher.
+Everything else is unchanged; `pnpm josh followup` releases the lane's hold at the merge.
+
+**The child is started as a process of its own, not as a subagent of this session** (`lane:dispatch`,
+`lane:launch`'s final step):
+
+- **It records where the child writes** — `<temp>/josh-lane-dispatch-<N>.log`.
+- **A refusal is an empty capture beside a non-zero exit**, with a `warning` Telegram. **Park that
+  child and name the log the message carries**; never re-dispatch into the same lane without reading it.
+- **A child that started with nowhere to write exits zero and warns** — **poll that lane on the
+  process trace alone**.
+- **The child is started as `fullrun #<N>` with the lane as its working directory**; the typed
+  `backlogrun` covers it.
+- **It passes `--permission-mode bypassPermissions`, never `--dangerously-skip-permissions`.**
+  `.claude/settings.json`'s `deny` list still refuses what it names; report what stopped, never loosen it.
 
 **Start each child without blocking on it, and poll them all** — a silent one is
-`backlogrun-recovery.md` → "A delegated unit that stopped without reporting", read in that child's
-lane.
+`backlogrun-recovery.md` → "A delegated unit that stopped without reporting", read in that child's lane.
 
-**`pnpm josh ms` is the parent's now, not the child's.** No lane can switch to the
-default branch, so the refresh moves to the primary checkout **before each `lane:open`** — the ref the
-lane is cut from.
+**`pnpm josh ms` is the parent's now, not the child's** — run it in the primary checkout **before
+each `lane:open`**.
 
 ### Conflicts are not predicted
 
 **A child whose pull request conflicts with `main` resolves it in its own lane rather than stopping** —
-read `backlogrun-recovery.md` → "Conflicts are not predicted" when `pnpm josh followup` reports the
-conflict.
+read `backlogrun-recovery.md` → "Conflicts are not predicted" when `pnpm josh followup` reports it.
 
 ### What happens to a lane
 
 | When | The lane | Why |
 | --- | --- | --- |
-| The child **merged** | `pnpm josh lane:close <N>` | `followup` released the hold and the branch is on `main`; nothing in that tree is wanted |
-| The child was **parked before its commit** | **Left open**, its uncommitted work in place, its directory and held seat recorded on the Issue | The stash stack is shared by every work tree, so a parallel lane can pop another's entry — the tree itself is the safe place for the work. `lane:close` is a **forced** removal that would take it. `pnpm josh lane:launch <N>` dispatches the released child into the kept lane rather than refusing it as `already-open` — only a lane a child was already dispatched into; a failed-install lane is still refused |
-| The child was **parked after its commit and push** | **Left open**, its directory and held seat recorded on the Issue | The tree is clean because committed. What `lane:close` would take is the **local branch**, which is the resume path |
-| The child hit a **merge conflict** | **Left open** — the resolution happens in it | The child resolves in place (`backlogrun-recovery.md` → "Conflicts are not predicted"). A park under that section's four conditions takes the row above |
-| The child stopped on **`needs-human-review`** | **Left open and untouched** | The uncommitted work *is* the artifact a person has to look at. Name the lane directory in the stop report and in the Telegram |
-| The child **failed** | Whichever of the two parked rows applies, plus the consecutive-failure count | Same reasoning; only the counter differs. **A merge conflict is not this row** — it takes the row above, and it is not counted |
-| **`lane:open` failed on the install** | `pnpm josh lane:close <N>`, then park the child | A lane exists that no `pnpm josh …` runs in and the next `lane:open` answers `already-open`. Closing frees the seat; parking is right because the cause is one a person fixes. Carry pnpm's reason into the park note |
-| The lane is **spent** — no child working in it, its Issue closed, not one this run launched and has not collected with `run:merge`, a clean tree, no commit that is on no remote | Nothing to do — `pnpm josh lane:prune` closes it | Nothing in it is wanted, so no one has to type the close. Any other lane is kept and `lane:prune` says why on standard error |
-| The run was **interrupted** | Nothing to do — the work tree survives on disk | The next session's `pnpm josh lane:prune` closes what git no longer has a tree for. **Park that child**, naming the lane and `pnpm josh lane:close <N>` as the way out |
-
-**A lane closed after a push is reopened by `pnpm josh lane:open <N>`**, which attaches to a local
-`<N>-lane` or creates one from `origin/<N>-lane`, saying on standard error which it reused. **The branch
-still has to have reached the remote for that to hold** — a child parked before its commit has nothing
-on `origin`, which is why that row keeps its lane open rather than closing it. Rationale:
-`docs/maintainers/backlogrun-lanes-rationale.md` → "Why a committed child's lane is kept".
+| The child **merged** | `pnpm josh lane:close <N>` | Nothing in that tree is wanted |
+| The child was **parked before its commit** | **Left open**, its uncommitted work in place, its directory and held seat recorded on the Issue | The shared stash stack is unsafe; `lane:close` is a **forced** removal. `pnpm josh lane:launch <N>` re-dispatches into the kept lane (a failed-install lane is still refused) |
+| The child was **parked after its commit and push** | **Left open**, its directory and held seat recorded on the Issue | `lane:close` would take the **local branch**, the resume path |
+| The child hit a **merge conflict** | **Left open** — the resolution happens in it | `backlogrun-recovery.md` → "Conflicts are not predicted"; a park there takes the row above |
+| The child stopped on **`needs-human-review`** | **Left open and untouched** | The uncommitted work is what a person looks at. Name the lane directory in the stop report and Telegram |
+| The child **failed** | Whichever of the two parked rows applies, plus the consecutive-failure count | **A merge conflict is not this row**, and is not counted |
+| **`lane:open` failed on the install** | `pnpm josh lane:close <N>`, then park the child | Frees the seat; a person fixes the cause. Carry pnpm's reason into the park note |
+| The lane is **spent** — no child working in it, its Issue closed, not one this run launched and has not collected with `run:merge`, a clean tree, no commit that is on no remote | Nothing to do — `pnpm josh lane:prune` closes it | Any other lane is kept, with the reason on standard error |
+| The run was **interrupted** | Nothing to do — the work tree survives on disk | **Park that child**, naming the lane and `pnpm josh lane:close <N>` |
+
+**A lane closed after a push is reopened by `pnpm josh lane:open <N>`** (a local `<N>-lane`, or one
+from `origin/<N>-lane`). A child parked before its commit has nothing on `origin`, so its lane stays open.
 
 **Which row a child takes is decided by what `followup` printed, not by reading the situation.** **What
-it prints is `PR checks failed (merge conflict)`** — that string is what reaches you;
-`mergeStateStatus: DIRTY` is the internal spelling `git-pr-checks-eval.ts` compares against, never an
-output line to search for. That string sends the child to resolve the conflict in the lane it is
-standing in. Do not grep the output for `mergeable_state`: that is the REST field name, normalized away
-before anything prints it.
+it prints is `PR checks failed (merge conflict)`** — resolve in the lane. Never search for
+`mergeStateStatus: DIRTY` or `mergeable_state`; neither is printed.
 
 **A kept lane holds its seat. Say it in the park comment**: the lane directory, that its seat is held,
-and `pnpm josh lane:close <N>` as the way to give it back.
+and `pnpm josh lane:close <N>` to give it back.
 
-**Release the hold on either parked arm, and leave the lane before closing it.** `pnpm josh followup`
-releases the working-tree hold at the **merge**, so a parked child's is still held: run
-`pnpm josh run:release <N>` in the lane — **a release names the run it belongs to**, and the child's own
-number is what that record carries. **A `needs-human-review` stop is not a park and keeps its hold.**
-`lane:close` does not release the hold for you — the record is keyed to the work tree's git directory,
-so removing the tree strands it. And `cd` out of the lane **before** `pnpm josh lane:close <N>`: the
-close removes the directory the shell is sitting in.
+**Release the hold on either parked arm, and leave the lane before closing it**: `pnpm josh
+run:release <N>` in the lane (**a release names the run it belongs to**); `lane:close` does not
+release it. `cd` out of the lane **before** `pnpm josh lane:close <N>`. **A `needs-human-review` stop is
+not a park and keeps its hold.**
 
-**A `needs-human-review` stop ends the run, and the lanes already in flight are allowed to finish.** No
-new lane is opened, and no unit is killed mid-gate. When the others have merged or parked, report and
-stop.
+**A `needs-human-review` stop ends the run, and the lanes already in flight are allowed to finish** —
+no new lane opens, no unit is killed mid-gate; then report and stop.
 
 ### CI concurrency
 
-**`JOSH_LANE_LIMIT` lowers the ceiling with no code** when CI jobs start to queue. Whether queueing
-bites is read from the multi-day backlog timing report — a `checks-wait` that grows with the lane count
-is the queueing. Rationale: `docs/maintainers/backlogrun-lanes-rationale.md` → "Why CI concurrency is
-capped by the lane limit".
+**`JOSH_LANE_LIMIT` lowers the ceiling with no code** when CI jobs queue — a `checks-wait` growing
+with the lane count in the backlog timing report.

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

@@ -1,99 +1,79 @@
 # `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. Point-of-use, never an
+entry read (`backlogrun.md` points here). Single source of park-and-continue, the `needs-human-review`
+stop, a stale `in-progress`, a mid-run prerequisite and a mid-run split. Provenance:
+`docs/maintainers/backlogrun-park-rationale.md` → "Where each rule came from".
 
 ## 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.
+Rationale: `docs/maintainers/backlogrun-park-rationale.md` → "Why `needs-human-review` ends the run
+instead of parking".
 
-**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 +88,25 @@ 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:
+**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. Rationale:
 `docs/maintainers/backlogrun-park-rationale.md` → "Why a run spends no attention on a non-finding".
 
 ## `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 +114,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

@@ -41,10 +41,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
 
@@ -88,13 +87,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
+**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, polled 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