@joshuafolkken/kit 1.2116.0 → 1.3000.0

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

@@ -4,20 +4,21 @@ Point-of-use, read one section at a time from `backlogrun.md` → "The manifest
 
 ## Running a named epic's children
 
+An epic `pnpm josh run:add <E>` tracked as a root is a named epic too, in a pool run as well.
+
 **`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
+then `pnpm josh lane:await <N...>` in the background — and every ending is read by one
 command:
 
 ```bash
-next=$(pnpm josh run:merge <N> --epic <E> --repo <owner/repo> --owner "$PPID" --output <path>)
+next=$(pnpm josh run:merge <N> --epic <E> --repo <owner/repo> --output <path>)
 ```
 
 **`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.
+transcript**; the named-epic flags are dropped for the opted-in backlog. It closes the lane itself; act on the token.
 
 | It prints | What the run does |
 | --- | --- |
@@ -25,8 +26,8 @@ the lane and comments itself; act on the token.
 | `wait` | Wait for the next wake |
 | `complete` | Record the root done (`backlogrun-steps.md` → "The session cut is inside the invocation") and post the epic summary |
 | `over` | Hand the lanes over and take the cut — "The hand-off" below |
-| `human-review` | Stop, leave `in-progress` on; send a `confirmation` only where the child ran in this session's own context (`needs-human-review.md`) |
-| `stop` / `environment` | Report the parked children (or the outage, or the `/login` an authentication failure needs) and stop |
+| human-review child | Keep its lane and `in-progress`; `run:merge` offers the next children and the stopped lane holds no execution place once its worker exits |
+| `stop` / `environment` | Report the parked children and stop. Failure streaks, outages and authentication failures hold launches instead (`scripts/run/merge/run-merge-health.ts`, `run-merge-auth.ts`) |
 | `resumed` | `lane:await <N>` it again |
 | `retry` / `busy` | Re-read the child |
 
@@ -41,49 +42,36 @@ summary, and who propagates" below.
 
 ## The hand-off — one session does not have to run the whole batch
 
-**The check is asked at every merge, and delegation does not excuse it** — `pnpm josh cost --cut`
-after every child's merge and `pnpm josh ms`, never wired to `pnpm josh delegate epic-child`. Crossing it **hands the session off to a fresh one,
-carrying the budget** (`backlogrun-steps.md` → "The session cut is inside the invocation"); it is not a
-stop. The threshold is the one `pnpm josh cost --cut` prints, priced at the session's model and
-shared by the scheduler entry, hand-off and the lane worker cut (`pre-gate-cut.md` → "The threshold").
+**The check is asked at every merge, and delegation does not excuse it** — `pnpm josh run:handoff-lanes`
+after every child's merge, never wired to `pnpm josh delegate epic-child`. It chains
+`pnpm josh cost --cut` (its threshold priced at the session's model), the lane reading, `run:carry --cut`,
+`run:board --chat` and `pnpm josh run:report --handoff` (`backlogrun-handoff-report.md`). A cut
+**hands the session off to a fresh one, carrying the budget** (`backlogrun-steps.md` → "The session cut
+is inside the invocation").
 
 | It answers | What the run does |
 | --- | --- |
 | `under` | Back to the loop |
-| `over` | Open no new lane, take no new child, and read the lanes below in the same turn |
-| exit 1, empty output | Report that the check could not answer, and take `over`'s branch |
+| `cut` | Open no new lane, take no new child, and end the turn; the `run:wake` driver polls the lanes |
+| `blocked <lanes>` | No cut, never assume idle: fix each named lane as printed, name it in the progress comment, re-ask at the next merge |
+| `capped` | No `run:wake`, no hand-off: carry this session on and re-ask at the next merge |
+| a step's exit code | Settle what it refused, then rerun the command |
 
 **A parent without a completion callback (Codex) dispatches the wave and ends the turn** — `run:step`
-prints the `--cut`.
-
-**On `over`, read the lanes rather than judging them** — `pnpm josh lane:list` prints each lane's state
-and output path; fill a missing path with `pnpm josh lane:output <N> <path>`:
-
-- **A lane nobody can poll** (`unreadable`, or `open` with no path) — **the cut does not happen**: name
-  it in the progress comment and re-ask at the next merge. **Never assume idle.** A `stranded` lane is
-  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.
-- **`--cut` answers `capped`** (`MAX_CUTS`) — **do not `run:wake` or hand off**;
-  carry this session on and re-ask at the next merge.
-
-The hand-off report is `pnpm josh run:report --handoff` (`backlogrun-handoff-report.md`). **This is not a failure and not a
-park** — nothing is labelled, stashed or filed.
+prints the `--cut`. **A cut is not a failure and not a park** — nothing is labelled, stashed or filed.
 
 ## Resuming after a cut
 
-**A session woken by the driver** — `Driver result:` in its prompt — acts on its branch and cuts as its
-`Next:` line says. A session resumed by hand reads the subsections below.
+**A session woken by the driver** — `Driver result:` in its prompt — acts on its branch and ends its turn
+as its `Next:` line says. A session resumed by hand reads the subsections below.
 
 ### 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` (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
-(`run:watcher:guard`), `pnpm josh run:liveness`, and `epic:next --lanes`, a lane per child it offers.
+**Start no child again and open no lane already open.** Run `pnpm josh run:pickup <E>...` and start
+the watcher line it prints in the background. A lane with a path is a handed-over child, waited on per
+`backlogrun-recovery.md` → "A delegated unit that stopped without reporting".
 **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>`.
+cut is re-dispatched with `pnpm josh lane:launch <N>`.
 
 ### What carries over
 
@@ -95,20 +83,18 @@ the epic body; what merged the epic's task list.
 
 | Setting | Value | Meaning |
 | --- | --- | --- |
-| 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. |
+| 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. **With nothing in flight no wake comes: it is the parent's own clock.** A `backlogrun` idle watch re-asks every 180 s, every 30 s while a named issue is left to dispatch, at the next poll after `run:add`, and when the `auto-ok` listing a free lane checks every 10 s holds a new issue number. |
+| Silent delegated unit | 30 min | 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. |
+| `backlogrun` idle watch | 8 h | Counted from when the run's hands became free; `pnpm josh backlog:budget` decides it. |
 
 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.
+removed first, so the next ask can offer it.
 
 ## Who sends the summary, and who propagates
 
 **Exactly one session does the end-of-epic work: the one standing in the repository that owns the
 epic** — the start and completion notifications, `josh propagate`, and `pnpm josh release:scope` once
 after the last merge (`followup.md` → "When `pnpm josh release` runs"). **Never compose the summary by
-hand — `pnpm josh run:report` generates it**; pass it to `pnpm josh notify
---body-file`.
+hand — `pnpm josh run:report` generates it**; write its output to `.josh/tmp/report.md` for
+`pnpm josh notify --body-file .josh/tmp/report.md`.

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

@@ -4,8 +4,7 @@ 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 waits on `lane:await`, whose exit
-covers it.** Record
+**The parent hands the child off without blocking and waits on `backlog:drive` or `lane:await`.** 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
@@ -28,14 +27,9 @@ pnpm josh run:liveness <N> --output <absolute path> --process <command lines nam
 **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`:
 
-1. **Stash the half-finished work** — `pnpm josh stash:push "backlogrun: stopped unit for #<N>"` — and
-   record it on the Issue; it is popped with `pnpm josh stash:pop "backlogrun: stopped unit for #<N>"`.
-2. **Classify and act in one call** — `pnpm josh run:merge <N> --output <path>` (`--epic <E> --repo
-   <owner/repo> --owner "$PPID"` for a named epic), **the same composite a returned child takes**. It
-   tells an `outage` (re-dispatched with its session resumed, uncounted, bounded by
-   `CONSECUTIVE_OUTAGE_LIMIT`) from an `abandoned` child (parked `run:stalled` and counted), and drops
-   the stale `in-progress` itself.
-3. **Act on the token it printed** — `backlogrun-progress.md` → "Running a named epic's children".
+1. **Stash, classify and act in one call** — `pnpm josh run:merge <N> --output <path> --stash` (`--epic <E> --repo
+   <owner/repo>` for a named epic), **the same composite a returned child takes**.
+2. **Act on the token it printed** — `backlogrun-progress.md` → "Running a named epic's children".
 
 ## A person withdraws a running child
 
@@ -46,41 +40,32 @@ On a person's instruction to drop a running child, run `pnpm josh lane:withdraw
 
 **This path is the fallback**: every `fullrun` merges origin/main 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.
+`main` *after* it. **Nothing here forecasts which children will overlap** — `pnpm josh followup` ends a
+conflicting child with a named conflict.
 
 **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.
+1. **Resolve in the lane — `pnpm josh lane:resolve <N>`**, then act on its verdict
+   (`docs/josh-commands.md` → "`josh lane:resolve`"): `conflict <paths>` → resolve in place;
+   `step-back 2|3` → park (below). Do not close the lane, open another, or switch its branch.
 2. **Re-run the whole gate.** The tree changed, so the green recorded before the conflict is void:
    `pnpm josh lint:related` and `pnpm josh test:related`, then `pnpm josh gate`.
 3. **Review the resolution, one round.** Brief it with `pnpm josh review:brief` and run `/code-review`
-   over the resolution diff, then require `pnpm josh review:attest --check` to answer `ok`. That round
-   is a different subject and does not spend one of the two the cap allows — `prompts/review.md` →
-   "Review round cap" carries the exception.
-4. **Conclude the merge and push it, with `pnpm josh git -y`** — the only sanctioned way; without it
-   nothing changes on `origin` and condition 3 parks the child for good. **Record the resolution on the
-   Issue in this same step** — a comment naming the conflicting paths — because condition 3 counts
-   resolutions off the Issue comments, not off memory.
+   over the resolution diff, then require `pnpm josh review:attest --check` to answer `ok`. The round
+   spends none of the cap (`prompts/review.md` → "Review round cap").
+4. **Conclude the merge and push it, with `pnpm josh git -y`**, then **`pnpm josh lane:resolve <N>
+   --record <paths>`** — the comment condition 3 counts; it refuses until the push has landed.
 5. **Merge**, by re-running `pnpm josh followup` exactly as before.
 
-**The safeguard is the re-run verification, not who holds the pen** — a conflict the run can resolve is
-not routed to a person.
-
-**The run steps back under these four conditions, and under no others. The list is exhaustive and
-carries no judgement.**
+**The run steps back under these four conditions, and under no others.**
 
 1. **The resolution requires deleting the other side's change.** That decides intended behavior, not
    text. It goes to the user as a **specification** question — "behavior A or behavior B" — never as a
    diff.
-2. **Both sides rewrote the same lines** — overlapping, not adjacent. Read off the structure of the
-   conflict hunks, so it needs no interpretation.
-3. **A second conflict on the same child.** One resolution per child; the count is read off the Issue
-   comments step 4 writes, so it survives an interrupt.
+2. **Both sides rewrote the same lines** — `lane:resolve`'s `step-back 2`, merge already aborted.
+3. **A second conflict on the same child** — `lane:resolve`'s `step-back 3`, read off step 4's comments.
 4. **The re-run gate did not come back green, or the resolution review returned a High.** Not only a
    High: a lint error, a failing test or a spell-check hit that merging a moved `main` introduced is
    this condition too.
@@ -89,5 +74,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**
-(condition 3 fires before any merge starts).
+**Leave the tree clean before parking: `git merge --abort` precedes a park under conditions 1 or 4**
+(`lane:resolve` aborts for 2; 3 fires before any merge starts).

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

@@ -12,11 +12,9 @@ arguments, never inferred. **Two repairs that would bound this the other way are
 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`). 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.
+**`pnpm josh issue:file` judges `auto-ok` and prints it** (`scripts/issue/issue-auto-ok.ts`).
+**Declare `- 人の判断: 要` when the new issue needs a person's judgement** — a Tier B toss-up or a
+Tier C action inside it (`issue-template.md`); `--no-auto-ok` withholds it too.
 
 ### The brake that replaces the promise
 
@@ -52,57 +50,69 @@ hand-off"), which keeps the invocation string, `--only` and the named list; it r
 `--json` (`docs/josh-commands-run.md` → "`josh run:carry`").
 
 ```bash
-pnpm josh run:carry --begin "backlogrun --max 5 --idle 30" --owner "$PPID"
-pnpm josh run:carry --json                                                   # read it back in a resumed session
-pnpm josh run:wake --start                                                   # same turn as --begin; `running` under `josh backlogrun`
+pnpm josh run:carry --begin "backlogrun --max 5 --idle 30"
+pnpm josh run:carry --json                                   # read it back in a resumed session
+pnpm josh run:wake --start                                   # same turn as --begin; `running` under `josh backlogrun`
 ```
 
-**Always pass `--owner "$PPID"`**, before the plan, in the same turn as the first `pnpm josh ms`. **The
+**Begin it before the plan**, in the same turn as the first `pnpm josh ms`; the owner is the session pid
+the agent exports (`--owner <pid>` only where it exports none). **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 |
 | --- | --- |
 | `began` | Report the plan and run the decision pass, then run what the bare `pnpm josh run:step` prints — an empty plan or a `none` from `backlog:next` included, which the driver's idle watch ends, never the session |
+| `driving` | The supervisor already holds the record — "The plan, beside the first child" |
 | `resumed` | Take the budget from `--json`, report the plan again, read `backlogrun-progress.md` → "Resuming after a cut" |
-| `busy` / `mismatch` / `unreadable` / `unknown` | **Stop; do not open a lane** — report what it printed; never resume into another invocation's record |
+| `busy` | Wait; do not open a lane — ask `--begin` again at the next wake |
+| `mismatch` / `unreadable` / `unknown` | **Stop; do not open a lane** — report what it printed; never resume into another invocation's record |
 | `over` | **End the conversation**; retype the invocation in a fresh session |
-| `standing` | **Stop; do not open a lane**: report `pnpm josh backlogrun --restart` (continue the run) and `pnpm josh run:carry --end` (discard it) for the person to choose — a crash from a run-tooling defect this run has since fixed you resume yourself (`upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合") |
-**End the record when the run ends** — `pnpm josh run:report`, then `pnpm josh run:carry --end`, **never
-batched with it**, and `pnpm josh run:wake --stop` in the same turn. **A run that ends by _stopping_**
-(a `stop` verdict or the consecutive-failure guard) **ends with `pnpm josh run:carry --end --stopped
-"<one-line reason>"`** instead, which sends the one ⏸️ confirmation.
+| `standing` | **Run `pnpm josh backlogrun --restart`**, then report it and `pnpm josh run:carry --end` (`scripts/backlog/backlogrun-restart.ts`; a run-tooling crash: `upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合") |
+**End the record when the run ends** — `pnpm josh run:report --end`: the report, `run:carry --end`,
+then `run:wake --stop`, stopping at the first failed stage, which it names. **A run that ends by
+_stopping_** (a `stop` verdict) **ends with `pnpm josh run:report
+--end --stopped "<one-line reason>"`** instead, which sends the one ⏸️ confirmation.
 
-**A driver hand-off of `epic #N` is a named epic**: settle it by `backlogrun-progress.md` → "Running a
+**A driver hand-off of `epic #N` is a named epic**, declared or added by `run:add`: settle it by `backlogrun-progress.md` → "Running a
 named epic's children", never the root as a standalone `fullrun`, then ask `pnpm josh epic:next <E>` —
-a child number or `complete` continues; only `stop` or a failure records `pnpm josh run:carry --done <E>
---owner "$PPID"`.
+a child number or `complete` continues; only `stop` or a failure records `pnpm josh run:carry --done <E>`.
 
 **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
+## The plan, beside the first child
 
-**Report the plan before anything is dispatched. The plan is one command's output** — `pnpm josh
-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 `⚠`.
+Under `josh backlogrun` the first lane opens while the plan is reported (`--begin` answers
+`driving`); a run typed in a session reports it before its hand-off.
 
-### Resolve what the plan can resolve, before starting
+**The plan is one command's output** — `pnpm josh backlog:plan`, from the pool `backlog:next` answers
+from, printed in the session language. Relay all four sections as printed, with any truncated-listing `⚠`.
 
-**Settle every `needs-decision` issue the plan listed in one pass**, from one `pnpm josh issue:read <N>
-<N> …` call (`issue-comments.md`):
+### Resolve what the plan can resolve
 
-- **An answer already in the issue** — record it as a comment and **remove the label** with `pnpm josh run:park <N> --clear` (Tier A).
+**Run `pnpm josh backlog:triage --pass`** after the first offer and follow its one stdout command.
+It settles mechanical lane candidates and batches the remaining judgments, `needs-decision` and
+`run:stalled` issues into one body-and-comments read, once per local issue. Foreign-repository and
+excluded children are not read. After recording answers, repeat it with `--exclude <N>`
+for decisions left parked in this pass; when none remain it prints `pnpm josh backlog:plan --waves`.
+The reader supplies semantic evidence; the command cannot infer a person's answer or prove a main failure:
+
+- **A park the parent resolves** — `pnpm josh backlog:triage --apply <N> --adopt <k> --reason <text>`
+  (`backlogrun-park.md` → "A park the parent session resolves").
   **Never measure in order to decide**: a question needing a benchmark or a run stays labelled.
+- **A recovered mechanical failure** — retry with `pnpm josh run:add <N> --retry`, which clears
+  `run:stalled` and the previous attempt; unresolved failures stay parked and excluded from this pass.
 - **A person's judgement** — apply `needs-decision` (`backlogrun-park.md` → "Only a person's judgement
   carries `needs-decision`").
-- **Order and isolate** — a native `blocked-by` where one must land first; `run:solo` on all three
-  `backlogrun-lanes.md` → "A solo run" conditions, **every other one `run:lane`**, commenting the
-  reason.
+- **Order and isolate** — a native `blocked-by` where one must land first (`--blocked-by <M>`);
+  the label from `pnpm josh backlog:triage --decide` (`backlogrun-lanes.md` → "A solo run"),
+  in one call with the reason (`--clear` folds in the answered park): `pnpm josh backlog:triage`
+  (`docs/josh-commands-backlog.md` → "`josh backlog:triage`").
 - **`priority:critical` / `priority:high`** are applied at filing by `pnpm josh issue:file` from the
   body's `- 優先度:` declaration (`issue-template.md`); **only a person removes them**.
 - **Report `pnpm josh backlog:plan --waves`** with the plan, never an order derived by hand; then start
-  the loop, leaving whatever is still labelled parked.
+  the loop (under `driving`, end the turn), leaving whatever is still labelled parked.
 
 **`needs-decision`, `run:solo` and `run:lane` are the only workflow labels a run applies by hand** —
 never `needs-human-review` (`needs-human-review.md`), the priority labels only through
@@ -112,33 +122,35 @@ never `needs-human-review` (`needs-human-review.md`), the priority labels only t
 
 **The loop is computed, not walked by hand** — the `run:wake` supervisor runs `pnpm josh backlog:drive`
 (`docs/josh-commands-backlog.md` → "`josh backlog:drive`"). A session reaches this section only when
-the `Driver result:` line hands a branch back: claim with `pnpm josh run:carry --resume "<invocation>"
---owner "$PPID"`, act on the row, then `pnpm josh run:carry --cut --owner "$PPID"`. Read only the one
-section the row names:
+the `Driver result:` line hands a branch back. The supervisor already holds the carry record — never
+run `run:carry --begin`; act on the row, then end the turn:
 
-| Handed back | What the session does | Read |
-| --- | --- | --- |
-| `triage` | Label each issue stderr names `run:solo` or `run:lane` (`blocked-by` where one must land first) | "Resolve what the plan can resolve, before starting" above |
-| `judge` | For each number `pnpm josh auto-ok:judge` prints, read the issue (`pnpm josh issue:read <N>`) and answer `--apply <N> --lane\|--solo` or `--decline <N> --reason "<why>"` | `docs/josh-commands-backlog.md` → "`josh auto-ok:judge`" |
-| `offer` | Report what stderr printed — a failed offer, or a named issue whose state stayed unreadable; **never pick an issue by hand** | — |
-| `launch #N` | Read the lane's log and park `#N` | `backlogrun-park.md` → "park and continue" |
-| `merge [<token>] #N` | `environment` ends the run; the others re-read the child | `backlogrun-progress.md` → "Running a named epic's children" |
-| `epic #N` | A named epic's turn | "The session cut is inside the invocation" above |
-| `watch` | The retrospective is owed (`run:step`) | `retrospective.md` |
-| `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.
+| Handed back | What the session does |
+| --- | --- |
+| `triage` | The session runs beside the driver, which keeps the carry: run no `run:carry`. Run `pnpm josh backlog:triage --pass` and follow its next command; resolve as above, leaving only genuine human questions parked |
+| `judge` | For each number `pnpm josh auto-ok:judge` prints, read the issue (`pnpm josh issue:read <N>`) and answer `--apply <N> --lane\|--solo` or `--decline <N> --reason "<why>"` |
+| `offer` | Report what stderr printed — a failed offer, or a named issue whose state stayed unreadable; **never pick an issue by hand** |
+| `launch #N` | The driver parked `#N` `run:stalled`: "Resolve what the plan can resolve" → "A recovered mechanical failure" |
+| `merge [<token>] #N` | Re-read the child |
+| `epic #N` | A named epic's turn |
+| `watch` | The retrospective is owed (`run:step`): run `pnpm josh run:handoff retrospective` (`retrospective.md`) |
+| `window` | Hand the loop back as is |
+
+**A round starts with the initial plan or a batch of collected children.** A batch containing at least
+one newly parked child hands back `triage` once, after all finished children are collected and before
+another offer. The pass re-reads all parked children; its exclusions last only for that pass. A batch
+with no park adds no triage step; a resumed driver does not repeat it.
+
+**A candidate only in another repository is never a token** — report it with its checkout.
 
 ## What runs once per session, not once per issue
 
 | Step | Where it is defined |
 | --- | --- |
-| `run:carry --begin` + `run:wake --start` before the plan; `run:carry --end` + `run:wake --stop` at the end | "The session cut is inside the invocation" above |
-| `pnpm josh ms`, `pnpm josh latest:if-required`, `lane:prune` in the primary checkout before the first lane | `backlogrun-lanes.md` → "Once per repository, before the first lane opens" |
-| `josh latest` on `required` only, once, never in a lane | `backlogrun-child.md` → "`josh latest` runs once per session, not once per child" |
+| `run:carry --begin` + `run:wake --start` before the plan; `run:report --end` at the end | "The session cut is inside the invocation" above |
+| `pnpm josh run:prime` in the primary checkout before the first child | `backlogrun-lanes.md` → "Once per repository, before the first lane opens"; a first child outside a lane: `backlogrun-child.md` → "`josh latest` runs once per session, not once per child" |
 | `pnpm josh run:hold <N>`'s preflight, before each child not in a lane | `docs/josh-commands-run.md` → "`josh run:hold`" |
 | `pnpm josh run:progress --wait` in the background, `--mark` at every real report | `progress-watcher.md` → "Progress while the run is quiet" |
 | `pnpm josh release:scope` once, after the last merge and lane close | `followup.md` → "When `pnpm josh release` runs" |
 
-**`pnpm josh epic:audit` is not run.** There is no epic to audit — the run began from the backlog.
+**`pnpm josh epic:audit` is not run on the opted-in backlog.**

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

@@ -13,7 +13,7 @@ governs it. With no `<N>` it answers for the parent itself, from the carry recor
 
 **A named item may be a single issue or an epic.** A single-issue item is one `fullrun`; **a named epic runs its children in
 dependency order across the free lanes, and the run does not advance to the next named item until
-every one of that epic's children has been processed — merged or parked.** `backlogrun #E --only`
+every one of that epic's children has been processed — merged or parked.** `pnpm josh backlogrun <E> --only`
 therefore runs exactly one epic's children and stops.
 
 ## Explicit invocation required (MANDATORY)
@@ -24,23 +24,20 @@ is still that one invocation (`backlogrun-steps.md` → "The session cut is insi
 
 ## The manifest — the ordered flow
 
-A section `run:step` prints is not fetched again. Every other one is read at its step with
+A section a command prints — `run:step`, `run:park`, `run:pause` — is not fetched again. Every other one is read at its step with
 `pnpm josh doc:section <file> "<heading>"` — never a whole document (`SKILL.md` → "A section
 reference is read as a section").
 
 1. **Claim nothing at the entry — this parent orchestrates and never implements.** The working-tree
    hold, the split assessment and `fullrun.md` are read by a dispatched child inside its own delegated
    `fullrun` unit, never at the parent's entry.
-2. **Begin the carry record before the plan** — `pnpm josh run:carry --begin "<invocation>" --owner
-   "$PPID"` and `pnpm josh run:wake --start`, in the same turn as the first `pnpm josh ms`. Its answers:
-   `backlogrun-steps.md` → "The session cut is inside the invocation"; a resumed session:
-   `backlogrun-progress.md` → "Resuming after a cut".
+2. **Begin the carry record before the plan** — its commands and the table of its answers:
+   `backlogrun-steps.md` → "The session cut is inside the invocation".
 3. **What this invocation approves** — the opted-in pool, a run's own filings once bundled, and the
    brake that bounds the amount: `backlogrun-steps.md` → "What one invocation approves".
-4. **Report the plan before the first child** — `pnpm josh backlog:plan`, then resolve every
-   `needs-decision` issue decidable from its body in one pass, recording `blocked-by`, `run:solo` and
-   `run:lane` in the same pass: `backlogrun-steps.md` → "The plan, before the first child starts";
-   `run:solo`: `backlogrun-lanes.md` → "A solo run".
+4. **Report the plan beside the first child** — `pnpm josh backlog:plan`, then resolve every
+   `needs-decision` issue decidable from its body in one pass: `backlogrun-steps.md` → "The plan,
+   beside the first child".
 5. **Named issues run first, in order** — each as a delegated `fullrun`, one at a time, then the pool;
    `--only` stops after the list.
    - Once per session: `backlogrun-steps.md` → "What runs once per session, not once per issue" and
@@ -52,16 +49,14 @@ reference is read as a section").
    - Dispatch: `backlogrun-child.md` → "Each child runs in a delegated unit".
 6. **The loop belongs to the supervisor — hand it over with what the bare `pnpm josh run:step`
    prints**, whatever the plan held: `run:wake` runs `backlog:drive`, which returns a branch to an AI
-   session only when it needs judgment (`backlogrun-steps.md` → "The loop").
-   - An `epic #N` hand-back or a `merge` branch: `backlogrun-progress.md` → "Running a named epic's
-     children".
+   session only when it needs judgment, its hand-off carrying the sections the branch needs.
    - A merge answered `over`: `backlogrun-progress.md` → "The hand-off".
    - A unit gone silent: `backlogrun-recovery.md` → "A delegated unit that stopped without reporting".
-   - A child that cannot finish: `backlogrun-park.md` → "park and continue".
-7. **End the record when the run ends** — `run:report`, then `run:carry --end` (or `--end --stopped
-   "<reason>"`) and `run:wake --stop`: `backlogrun-steps.md` → "End the record when the run ends".
+   - A child that cannot finish: the driver's `launch #N` hand-off carries the section.
+7. **End the record when the run ends** — `pnpm josh run:report --end` (or `--end --stopped
+   "<reason>"`): `backlogrun-steps.md` → "End the record when the run ends".
    - An empty plan is not that end; the driver's idle watch decides it. A person stops a run from the
-     terminal with `pnpm josh backlogrun --stop`, which makes both calls.
+     terminal with `pnpm josh backlogrun --stop`, which ends the run without the report.
    - The last merge: `backlogrun-progress.md` → "Who sends the summary, and who propagates", then
      `followup.md` → "When `pnpm josh release` runs".
 
@@ -71,6 +66,6 @@ reference is read as a section").
 | --- | --- | --- |
 | Children per run | 30 | Stop and report; an epic this large should be split. |
 | Issues filed per originating work item | `prerequisite.md`'s cap (`issue:file` refuses the 11th) | Stop and report. |
-| Consecutive child failures | 3 | Stop and report; something is wrong with the environment, not the children. |
+| Consecutive child failures | 3 | Not a stop: `run:merge` checks `main`, filing a `run:solo` Issue if red, and offers the next child (`run-merge-health.ts`). |
 
 A failure that is not consecutive parks its child and the run continues.