@joshuafolkken/kit 1.1455.0 → 1.1514.0

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

@@ -1,113 +1,99 @@
 # `backlogrun` — running a child (shared mechanics, delegation, liveness, session setup)
 
-Point-of-use, read one section at a time from `backlogrun.md` → "The route table" (rationale: `docs/maintainers/backlogrun-child-rationale.md` → "Why the file is read by section").
+Point-of-use, read one section at a time from `backlogrun.md` → "The manifest — the ordered flow".
 
 ## Running a child — the shared mechanics
 
-Everything below runs **one child** — of a named epic, or of the opted-in backlog. A single-issue named item, a named epic's child and a bare backlog child all run the same `fullrun` in the same way, and this part is the single source of how. A named epic runs these mechanics over its own children until every one is processed, then the run advances to the next named item.
+This file is the single source of how **one child** runs — a named single-issue item, a named epic's
+child and a bare backlog child all run the same `fullrun`. A named epic runs these mechanics over its
+children until every one is processed, then the run advances to the next named item.
 
 ## When `#N` is not an epic
 
-`backlogrun` accepts an ordinary Issue as well as an epic. `backlogrun #<N>` on an Issue with no task list
-runs `#<N>` as a `fullrun` and then finishes. Inside `backlogrun #<N>`, a prerequisite or a split found
-mid-run does **not** stop the run (rationale: `docs/maintainers/backlogrun-child-rationale.md` → "Why a
-bare Issue promotes itself under `backlogrun` but not under `fullrun`"):
-
-1. File the new Issue(s) with the matching route label — `route:split` for a split, `route:tier-a`
-   for a prerequisite — no confirmation.
-2. **Stash the work in progress and remove `in-progress` from `#<N>`**, exactly as steps 2 and 4 of
-   "A prerequisite discovered mid-run" do — `git stash push -u -m "..."` with the `-u`, the
-   `gh api repos/{owner}/{repo}/issues/<N>/comments` post that records the stash, and
-   `pnpm josh run:release <N>`, which removes the label with the hold.
+`backlogrun #<N>` on an Issue with no task list runs `#<N>` as a `fullrun` and finishes. A prerequisite
+or a split found mid-run does **not** stop it:
+
+1. File the new Issue(s) — `route:split` for a split, `route:tier-a` for a prerequisite — no
+   confirmation.
+2. **Stash and remove `in-progress`**, as steps 2 and 4 of "A prerequisite discovered mid-run" do:
+   `git stash push -u -m "..."`, a `gh api repos/{owner}/{repo}/issues/<N>/comments` post recording the
+   stash, and `pnpm josh run:release <N>`.
 3. **Ask `pnpm josh epic:bundle <N>` whether an epic already tracks `#<N>` before creating one.**
 
    | Answer | What to do |
    | --- | --- |
-   | An epic `#<E>` already tracks `#<N>` | `pnpm josh epic --add <E> <P> --before <N>` for a prerequisite, or `--add <E> <N1> ...` for a split. **Do not create a second epic.** Continue the loop against `#<E>` |
-   | No epic tracks it | Create one — the command depends on what was found (table below) |
-   | **The command could not answer** — a non-zero exit, `Could not confirm which epic already tracks these — do not place this issue in one.`, or a ⚠ warning about a truncated listing (beginning `⚠ The epic listing …`, in either form `hit its …-epic cap` / `stopped at the …-issue page ceiling`) above a `Nothing to bundle.` verdict; `⚠ Could not read #N.` is one failed relation read and voids nothing, and a definitive answer stands even beside a warning | Park `#<N>` with `needs-decision` and report. "Could not tell" is not "no epic tracks it" |
+   | An epic `#<E>` already tracks `#<N>` | `pnpm josh epic --add <E> <P> --before <N>` (prerequisite) or `--add <E> <N1> ...` (split). **Do not create a second epic**; continue against `#<E>` |
+   | No epic tracks it | Create one (table below) |
+   | **The command could not answer** | Park `#<N>` with `needs-decision` and report — "could not tell" is not "no epic" |
+
+   "Could not answer" is a non-zero exit, `Could not confirm which epic already tracks these — do not
+   place this issue in one.`, or a `⚠ The epic listing …` truncation warning (`hit its …-epic cap` /
+   `stopped at the …-issue page ceiling`) above `Nothing to bundle.`. `⚠ Could not read #N.` voids
+   nothing, and a definitive answer stands beside a warning.
 
-   When creating one, `#<N>` is itself one of the deliverables — this path always takes the
-   keep-as-a-child arm of `split-assessment.md`'s promote-or-create branch. Which command depends on
-   what was found, because `--ordered` makes the argument order the dependency chain:
+   `#<N>` is itself one of the deliverables (the keep-as-a-child arm of `split-assessment.md`).
+   `--ordered` makes the argument order the dependency chain:
 
    | Found | Command |
    | --- | --- |
-   | A prerequisite `<P>` | `pnpm josh epic "<title>" <P> <N> --ordered` — the prerequisite comes **first** |
+   | A prerequisite `<P>` | `pnpm josh epic "<title>" <P> <N> --ordered` — the prerequisite **first** |
    | A split into independent children | `pnpm josh epic "<title>" <N> <N1> ...` — **no `--ordered`** |
-   | A split whose children do have an order | `pnpm josh epic "<title>" ... --ordered`, arguments in that order |
-
-4. **Run `pnpm josh epic:audit <E>` now**, not earlier — there is no epic to audit until step 3.
-5. **Do not stop.** Continue into the loop below against the new epic `#<E>`.
-
-**Nothing found means no epic.** If `#<N>` reaches its merge without a prerequisite or a split turning
-up, the run finishes there. An epic is created only when there is a second child to put in it.
+   | A split whose children do have an order | `pnpm josh epic "<title>" ... --ordered`, in that order |
 
-**Every guard below applies on this path unchanged** — 30 children, 10 Issues filed, 3 consecutive
-failures.
+4. **Run `pnpm josh epic:audit <E>` now** — there is no epic to audit before step 3.
+5. **Do not stop.** Continue into the loop against `#<E>`.
 
-**This does not let `fullrun` promote itself.** A `fullrun` that discovered a split still files the
-children and the epic and then **stops** (`split-assessment.md` → "Finding a split mid-run stops the
-run").
+- **Nothing found means no epic** — the run finishes at `#<N>`'s merge.
+- **Every guard applies unchanged** — 30 children, 10 Issues filed, 3 consecutive failures.
+- **`fullrun` does not promote itself** — it files and **stops** (`split-assessment.md` → "Finding a
+  split mid-run stops the run"). `josh epic:next` still refuses an Issue with no task list.
+- **A bare Issue named beside an epic is a mistyped command.** Named alone, the refusal is the answer;
+  among several, it is **skipped** — `backlogrun #<E> --only #<N>` exits 0, notes the skip on stderr
+  and **never runs `#<N>`**. To do both, type `backlogrun #<N>` after the epic.
 
-**`josh epic:next` is not changed by any of this.** It still refuses an Issue with no task list; the
-acceptance of a bare Issue belongs to `backlogrun`.
-
-**Naming a bare Issue beside an epic is a mistyped command rather than a second entry.** Where one
-reference is named, the refusal is the whole answer. Where several are, a task-listless reference is
-**skipped** so the other epics keep running — `backlogrun #<E> --only #<N>` with `#<N>` an ordinary Issue exits
-0, notes the skip on standard error, and **never runs `#<N>`**. A run that means to do both types
-`backlogrun #<N>` on its own after the epic.
 ## Each child runs in a delegated unit
 
-**A child is not run in the parent loop's context** — **whatever offers a child — the loop, or a
-person clearing a label — the child is handed to a lane, never to the parent.** `pnpm josh delegate
-epic-child` answers `delegate`; in a lane the unit is a detached process started by `pnpm josh
-lane:launch` (`backlogrun-lanes.md` → "Opening one lane and dispatching its child"), with the invoking
-CLI's `worker` profile — Claude Code defaults to Anthropic `claude-opus-5-5` / `medium`
-(`docs/josh-commands-run.md` → "`josh lane:dispatch`", the single source).
-Where no isolated unit exists, run the child in the parent's context; the hand-off is still asked at
-every merge. Rationale: `docs/maintainers/backlogrun-child-rationale.md` → "Why each child runs in a
-delegated unit".
-
-**The parent reads GitHub, never the summary** — `pnpm josh issue:state <N>` (or `run:merge`) is the
-verifier; **never advance the loop on the summary alone**.
+**Whatever offers a child — the loop, or a person clearing a label — the child is handed to a lane,
+never run in the parent's context.** `pnpm josh delegate epic-child` answers `delegate`; the unit is a
+detached process from `pnpm josh lane:launch` (`backlogrun-lanes.md` → "Opening one lane and
+dispatching its child") with the CLI's `worker` profile — Claude Code defaults to Anthropic
+`claude-opus-5-5` / `medium` (`docs/josh-commands-run.md` → "`josh lane:dispatch`"). With no isolated
+unit, run the child in the parent's context and still ask the hand-off at every merge.
 
-**The brief names the invocation it descends from** — e.g. `backlogrun #<E> --only`, the child number,
-and that the child runs as `fullrun #<N>` under that authorization; the unit refuses a brief without it.
+- **The parent reads GitHub, never the summary** — `pnpm josh issue:state <N>` (or `run:merge`)
+  verifies; **never advance the loop on the summary alone**.
+- **The brief names the invocation it descends from** — e.g. `backlogrun #<E> --only`, the child
+  number, and that it runs as `fullrun #<N>` under that authorization; the unit refuses a brief without
+  it.
 
 ### What the summary carries, and how long it may be
 
-**The summary carries only what GitHub does not, in at most 25 lines; the brief states the bound.**
-Rationale: `docs/maintainers/backlogrun-child-rationale.md` → "Why the summary is bounded the way it is".
+**Only what GitHub does not, in at most 25 lines; the brief states the bound.**
 
-- **Kept**: `Cause` / `Fix` / `Result`; every verification result not closed the ordinary way, named
-  as such; observations that could bite later — **the only route a child's discretionary observation
-  has** (`observation-filing.md` → "A delegated child does not take this route"); decisions not already
-  logged; what was left undone, and under whose authority.
-- **Cut**: the changed-file list, per-round review detail, and restated rules.
+- **Kept**: `Cause` / `Fix` / `Result`; every verification not closed the ordinary way, named as such;
+  observations that could bite later — **a child's only route for one** (`observation-filing.md` → "A
+  delegated child does not take this route"); decisions not yet logged; what was left undone, on whose
+  authority.
+- **Cut**: the changed-file list, per-round review detail, restated rules.
 
 The person-facing report (`prompts/collaboration-workflow/report-format.md` → 「完了報告（セッション向け）」)
 is unchanged.
 
 ## A delegated unit that stopped without reporting
 
-**Hand the child to the unit without blocking on its return, and poll** — a stopped unit leaves no
-notification behind. Once its output has been unchanged for the silent-unit window, read
-`backlogrun-recovery.md` → "A delegated unit that stopped without reporting" and ask
-`pnpm josh run:liveness`.
+**Hand the child off without blocking, and wait on `pnpm josh lane:await <N>`** — a stopped unit
+leaves no notification, so the await's exit is the wake. Once its
+output is unchanged for the silent-unit window, read `backlogrun-recovery.md` → "A delegated unit that
+stopped without reporting" and ask `pnpm josh run:liveness`.
 
 ## Audit before the first child
 
-Run `pnpm josh epic:audit <E>` before step 1 below. **When the run began from a bare Issue there is
-nothing to audit yet** — that path runs the audit at the moment it creates the epic instead. Errors
-stop the run; warnings are read and carried on past. Fixing what it finds is Tier A. Rationale:
-`docs/maintainers/backlogrun-child-rationale.md` → "Why the audit runs before the first child".
+Run `pnpm josh epic:audit <E>` before the first child; a run begun from a bare Issue audits when it
+creates the epic. Errors stop the run; warnings are read and passed. Fixing a finding is Tier A.
 
 ## `josh latest` runs once per session, not once per child
 
-`josh latest` belongs to the **session**, not to a child. Ask once, the first time the loop below hands
-back a child number — before implementing that child — and never again:
+Ask once, the first time the loop hands back a child number, before implementing it:
 
 ```bash
 pnpm josh latest:scope   # → required | skip ; the reason on stderr
@@ -117,20 +103,14 @@ pnpm josh latest         # on `required` only
 pnpm josh stash:pop "backlogrun: josh latest #<N>"         # only if you stashed above — by message, not a positional pop
 ```
 
-On `required`, load the `dependency-update` skill; `latest-gate.md` is the single source. **Session,
-not run** — each session updates its own checkout, and a resumed `backlogrun` asks again. **The lock
-file lands with the first child's `pnpm josh git -y`**; fix a failing bump forward. **`josh latest` is
-never run inside a lane** (`pnpm josh latest:guard` refuses it) — with lanes the parent runs it in the
-primary checkout (`backlogrun-lanes.md` → "Once per repository, before the first lane opens").
-
-Rationale: `docs/maintainers/backlogrun-child-rationale.md` → "Why `josh latest` is hoisted to the
-session".
+On `required`, load the `dependency-update` skill; `latest-gate.md` is the single source. A resumed
+`backlogrun` asks again. **The lock file lands with the first child's `pnpm josh git -y`**; fix a
+failing bump forward. **Never inside a lane** (`pnpm josh latest:guard` refuses) — the parent runs it
+in the primary checkout (`backlogrun-lanes.md` → "Once per repository, before the first lane opens").
 
 ## Preflight — the child's claim asks it
 
-`pnpm josh run:hold <N>`, the first call of the child's `fullrun`, checks for an interrupted run's
-leftovers before it claims the tree, and prints the step for each answer (`reclaim` / `resume` /
-`park`) on stderr — follow it, and report a reclaim or resume with its stash reference. The answers are
-`docs/josh-commands-run.md` → "`josh run:hold`"; rationale:
-`docs/maintainers/backlogrun-child-rationale.md` → "Why the preflight is part of the claim".
-
+`pnpm josh run:hold <N>`, the child's first call, checks for an interrupted run's leftovers before
+claiming the tree and prints the step for each answer (`reclaim` / `resume` / `park`) on stderr —
+follow it, and report a reclaim or resume with its stash reference (`docs/josh-commands-run.md` →
+"`josh run:hold`").

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

@@ -1,14 +1,12 @@
 # `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 manifest — the ordered flow".
 
 ## 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 +17,49 @@ 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.**
 
 ## 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
@@ -85,98 +67,77 @@ pid=$(pnpm josh lane:launch "$n") || exit 1   # the child's pid on stdout, nothi
 
 | It answers | What the run does |
 | --- | --- |
-| a pid | The child runs; poll it |
+| a pid | The child runs; wait on it with `lane:await` |
 | empty, non-zero, `full` | No free lane; wait for one |
 | 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.
-
-**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.
-
-**`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.
+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** — **wait on that lane with
+  `lane:await`, which reads 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, then wait on `backlog:drive` or `lane:await`**
+(`scripts/run/run-poll-hook.ts`) — a silent one is
+`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** — 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.