@joshuafolkken/kit 1.2114.0 → 1.3000.0

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

@@ -13,52 +13,32 @@ children until every one is processed, then the run advances to the next named i
 `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`**: for a prerequisite `<P>`, `pnpm josh run:pause <N> --for <P>`
-   (`prerequisite.md`), which also records the dependency step 3 would; for a split,
-   `pnpm josh stash:push "..."`, `pnpm josh issue:comment <N> --body-file <path>` 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>` (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.
-
-   `#<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 **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`, in that order |
-
-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>`.
+**A split** → file the children with `route:split` (no confirmation) by `split-assessment.md` → "Two
+or more always means an epic", then
+`pnpm josh run:split <N> --children <N1,N2,...> [--ordered] [--title "<title>"]` (`docs/josh-commands-run.md`
+→ "`josh run:split`"). `epic #<E>` → continue into the loop against `#<E>`; `needs-decision` → report.
+
+**A prerequisite** `<P>` → file it with `route:tier-a` (no confirmation), then
+`pnpm josh run:split <N> --prerequisite <P> [--title "<title>"]` (`docs/josh-commands-run.md` →
+"`josh run:split`"), which pauses `#<N>` as `run:pause` does (`prerequisite.md`). `epic #<E>` →
+**do not stop**, continue into the loop against `#<E>`; `needs-decision` → report.
+
+Over the size bar before dispatch → a split-only unit, not a lane (`scripts/backlog/backlog-drive-split-unit.ts`).
 
 - **Nothing found means no epic** — the run finishes at `#<N>`'s merge.
 - **Every guard applies unchanged** (`backlogrun.md` → "Guards").
 - **`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.
+  split mid-run stops the run").
+- **A bare Issue named beside an epic is a mistyped command.** Named alone, `epic:next`'s refusal is the answer;
+  among several, it is **skipped** — `pnpm josh backlogrun <E> <N> --only` exits 0, notes the skip on stderr
+  and **never runs `#<N>`**. To do both, run `pnpm josh backlogrun <N>` after the epic.
 
 ## Each child runs in a delegated unit
 
 **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
+dispatching its child"; its profile and model: `docs/josh-commands-lane.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 parent reads GitHub, never the summary** — `pnpm josh issue:state <N>` (or `run:merge`)
@@ -73,23 +53,18 @@ unit, run the child in the parent's context and still ask the hand-off at every
 
 **Only what GitHub does not, in at most 25 lines; the brief states the bound.**
 
-- **Kept**: `Cause` / `Fix` / `Result`; every verification not closed the ordinary way, named as such;
+- **Kept**: the cause / fix / result lines from `run:tail`'s `child summary template`; 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.
-- Before the final message → `pnpm josh report:lint --child-summary < summary.md` (labels in the
-  session language).
-
-The person-facing report (`prompts/collaboration-workflow/report-format.md` → 「完了報告（セッション向け）」)
-is unchanged.
+- Before the final message → `pnpm josh report:lint --child-summary < summary.md`.
 
-## A delegated unit that stopped without reporting
+Fill the `<…>` narrative fields from `pnpm josh run:tail <N>`, keeping its cited targets.
+`report:template child` supplies a standalone skeleton.
 
-**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`.
+The `notify-message template` section supplies the three lines for `followup --notify-message`
+(or `--notify-message-file`) when preparing a notification.
 
 ## Audit before the first child
 
@@ -98,23 +73,15 @@ creates the epic. Errors stop the run; warnings are read and passed. Fixing a fi
 
 ## `josh latest` runs once per session, not once per child
 
-Run once, the first time the loop hands back a child number, before implementing it:
-
-```bash
-pnpm josh stash:push "backlogrun: ms #<N>"   # `clean` when nothing changed
-pnpm josh ms
-pnpm josh stash:pop "backlogrun: ms #<N>"    # only after `stashed` above
-pnpm josh latest:if-required                 # stash → josh latest → pop; nothing on `skip`
-```
-
-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").
+It is a step of `pnpm josh run:prime` (`backlogrun-lanes.md` → "Once per repository, before the first
+lane opens"), run before the first child. On `latest required`, load the `dependency-update` skill;
+`latest-gate.md` is the single source. **A first child outside a lane** (a named issue) and a `stash`
+line other than `clean` → `pnpm josh stash:pop "<message>"` with that message before it, in the
+primary checkout; the lock file lands with its `pnpm josh git -y`. A resumed `backlogrun` asks again; fix a failing bump forward.
+**Never inside a lane** (`pnpm josh latest:guard` refuses).
 
 ## Preflight — the child's claim asks it
 
-`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`").
+`pnpm josh run:hold <N>`, the child's first call, prints the step for an interrupted run's leftovers
+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

@@ -11,7 +11,10 @@ dependency that crosses a repository are `docs/josh-commands-backlog.md` → "`j
 
 **One kind of child takes no lane beside anything: a defect in kit's own verification that makes
 unrelated PRs answer wrongly on `main` today.** It runs alone, and the batch resumes only once it has
-merged. **Decide it from three conditions that must all hold, never from how serious it looks** — is
+merged. **Ask `pnpm josh backlog:triage --decide --defect <answer> --verification <answer> --every-run <answer>`**
+with `yes`, `no` or `unknown` for each condition below, never from how serious it looks. The command
+prints `run:solo`, `run:lane`, or `judge` when evidence is missing; `judge` keeps the issue untriaged.
+The reader answers the semantic questions; the command computes their conjunction — is
 it a defect (not an improvement, refactor, removal or feature)? Is it in kit's own verification gate
 (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
@@ -21,6 +24,19 @@ answer wrongly (a false green or a false red) **on every run**? All three, and t
 the other lanes for one reason only: a batch run on broken verification leaves nobody's result
 trustworthy.**
 
+`backlog:next` labels `run:lane` itself where the first two conditions fail
+(`docs/josh-commands-backlog.md` → "`josh backlog:next`").
+
+To apply `run:solo`, pass all three affirmative answers:
+
+```bash
+pnpm josh backlog:triage --apply <N> --solo --defect yes --verification yes --every-run yes --reason <text>
+pnpm josh auto-ok:judge --apply <N> --solo --defect yes --verification yes --every-run yes
+```
+
+Missing, negative, unknown or invalid answers refuse the entire request before any writes,
+including relation changes and park clearing. `--lane` requires no answers.
+
 **A wrong answer that only comes some of the time — a flaky test, a timeout under load — is not a solo
 run.** It carries `run:lane` and `priority:critical`, so it leads the next offer while the other lanes
 keep running: a flake costs another lane one rerun, less than every lane stopped until it merges.
@@ -29,37 +45,27 @@ keep running: a flake costs another lane one rerun, less than every lane stopped
 
 `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
+(`docs/josh-commands-lane.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`
-(`docs/josh-commands-run.md` → "`josh run:cut`"; `pre-gate-cut.md` → "The stage is passed to the resumed child").
+**A lane child may cut its own turn before the gate** — `pre-gate-cut.md`, the single source.
 
-**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 review counts only once `pnpm josh review:attest --check` answers `ok`** — `chain-rule.md`
+→ "The brief names the checkout, and a review that read another one is refused".
 
-**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`.
+**A lane's branch is `<N>-lane`. Nothing switches the lane to another branch**, 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 order, never per lane: `pnpm josh ms`; `pnpm josh latest:if-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.** Only if the update rewrote
-anything: `pnpm josh stash:push "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.** **Under
-`backlog:drive` the driver passes `--stash`, never you**; the push stays the parent's.
+`pnpm josh run:prime` in the **primary checkout**, never per lane — its steps are
+`docs/josh-commands-run.md` → "`josh run:prime`". **A `stash` line other than `clean` is the first
+lane's: record it on the first child's Issue and pass its message to `pnpm josh lane:launch "$n" --stash
+"<message>"`**; under `backlog:drive` the driver passes `--stash`, never you.
 
 ### Opening one lane and dispatching its child
 
@@ -76,29 +82,23 @@ 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; the child claims `run:hold` inside the lane.
+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, 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):
+The child runs as `fullrun #<N>` in that lane, with neither `josh latest` nor a progress watcher, as a
+process of its own (`lane:dispatch`, `lane:launch`'s final step), not as a subagent of this session:
 
-- **It records where the child writes** — `<common git dir>/josh/run-state/josh-lane-dispatch-<N>-<key>.log`, which survives a reboot.
+- **It writes to** `<common git dir>/josh/run-state/josh-lane-dispatch-<N>-<key>.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
+- **A child that started with nowhere to write exits zero and warns** — wait on that lane with
+  `lane:await`.
+- **`.claude/settings.json`'s `deny` list still applies to the child** — report what it stopped, never
+  loosen it.
+
+**Start each child without blocking on it** — the wait, and a silent child:
 `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
@@ -111,35 +111,27 @@ read `backlogrun-recovery.md` → "Conflicts are not predicted" when `pnpm josh
 
 ### What happens to a lane
 
-| When | The lane | Why |
-| --- | --- | --- |
-| 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. `run:hold <N> --human-review-stop` names the lane directory in the Telegram; the stop report names it too |
-| 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>` |
+| When | The lane |
+| --- | --- |
+| The child **merged** | `pnpm josh lane:close <N>` |
+| The child was **parked before its commit** | **Left open**, its uncommitted work in place, its directory and held seat recorded on the Issue; `pnpm josh lane:launch <N>` re-dispatches into it |
+| The child was **parked after its commit and push** | **Left open**, its directory and held seat recorded on the Issue — its local branch is 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**, its hold kept — not a park (`backlogrun-park.md` → "`needs-human-review` — the one stop that is not a park") |
+| The child **failed** (not a merge conflict) | Whichever of the two parked rows applies, plus the consecutive-failure count |
+| **`lane:open` failed on the install** | `pnpm josh lane:close <N>`, then park the child, carrying pnpm's reason into the park note |
+| The lane is **spent** | Nothing to do — `pnpm josh lane:prune` closes it |
+| The run was **interrupted** | **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)`** — resolve in the lane. Never search for
-`mergeStateStatus: DIRTY` or `mergeable_state`; neither is printed.
+from `origin/<N>-lane`).
 
-**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>` to give it back.
+**Which row a child takes is decided by what `followup` printed, not by reading the situation** —
+`PR checks failed (merge conflict)` resolves in the lane.
 
 **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 opens, no unit is killed mid-gate; then report and stop.
+run:park <N>` in the lane releases it (**a release names the run it belongs to**); `lane:close` does
+not. `cd` out of the lane **before** `pnpm josh lane:close <N>`.
 
 ### CI concurrency
 

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

@@ -3,22 +3,6 @@
 **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.
 
-## What happens to a child that cannot finish
-
-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** — `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
@@ -27,35 +11,36 @@ parks, re-dispatches or files.
 
 ## `needs-human-review` — the one stop that is not a park
 
-A child carrying **`needs-human-review`** stops `halfrun`-shaped and **the whole run ends there**:
+A child carrying **`needs-human-review`** stops `halfrun`-shaped in **its own lane**:
 implementation and the gate run, nothing is committed, the tree is left dirty and unstashed,
 `pnpm josh run:hold <N> --human-review-stop` sends the `confirmation` Telegram with the resume command
-and the lane directory, and the remaining children are not started.
+and the lane directory. The parent collects that dispatch and offers the next children.
 
-**The child goes on holding its repository**, and **its lane is left open and untouched**. **Name the
-lane directory in the stop report.** Lanes in flight finish; no new lane opens.
+**The child goes on holding its repository**, and **its lane is left open and untouched** — never
+park or release it. **Name the lane directory in the stop report.** The parent keeps launching
+children while free lanes remain.
 
 **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`"), **park the child and keep going**:
+`needs-decision`"; every stop left to a person: `scripts/issue/issue-human-stops.ts`), **park the
+child and keep going**:
 
 ```bash
-pnpm josh run:park <N> --body-file <path>   # what needs deciding, and the options; applies needs-decision
+pnpm josh run:park <N> --body-file .josh/tmp/park.md   # body schema: docs/josh-commands-run.md → "josh run:park"; applies needs-decision, then releases
 ```
 
-`in-progress` stays; the parked child does **not** hold the repository (`needs-decision` takes
-precedence in `epic:next`). Return to step 1.
+Return to step 1.
+
+A finding that meets the body's declared `- 中止条件:` is not a park —
+`issue-comments.md` → "When a declared close condition holds".
 
-**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". A lost merge race
-resolves in its lane instead (`backlogrun-recovery.md` → "Conflicts are not predicted").
+**What happens to a parked child's lane** — `backlogrun-lanes.md` → "What happens to a lane".
 
-**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:
-`pnpm josh epic --add <E> <N> --after <M>` and record it on both Issues' `## Decisions`.
+**Parking keeps the stop's rule** — file upstream defects; never work around them.
+`epic:bundle`'s `ask` is Tier A (`epic-commands` skill).
 
 **Removing the label is Tier A — do it without asking**, once the decision is recorded:
 
@@ -66,19 +51,25 @@ pnpm josh run:park <N> --clear   # succeeds when the label is already off
 **The released child goes back to a lane, never into the parent's own context** — `pnpm josh
 lane:launch <N>`.
 
+An interrupt filed for a parked child turns the park into a wait — `issue:file --route interrupt
+--found-during <N>` (`scripts/issue/issue-file-interrupt.ts`); its merge relaunches #N
+(`backlog_drive_retry.after_merge`).
+
 ## Only a person's judgement carries `needs-decision`
 
 **`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");
+- a Tier B toss-up with no recommendation, or a Tier C action (decision-autonomy below) — the
+  driver decides the first only once (`A park the driver decides`);
 - an upstream defect in another package, whose wait-or-defer is the person's (`upstream-interrupt.md`);
 - information only the web holds — no lane launches a web tool (`scripts/agent/claude-agent-argv.ts`),
   so a person fetches it.
 
 It never carries:
 
-- a choice with a clearly better default — that is Tier A: decide it and record it as an Issue comment;
+- a recommended, reversible choice — Tier A: adopt it with
+  `pnpm josh backlog:triage --apply <N> --adopt <k> --reason <text>`, and continue
+  (`prompts/collaboration-workflow/operating-rules.md` → "decision-autonomy", the single source);
 - whether to run something already planned and opted in with `auto-ok` — the opt-in is that decision;
 - a wait for the next published release — a dependency, `pnpm josh issue:release <N> --wait`
   (`prerequisite.md`);
@@ -86,51 +77,61 @@ It never carries:
   (`prompts/collaboration-workflow/upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合"),
   its filing carrying the `- 原因の park:` line when it parked or stopped an Issue (`issue-template.md` → I);
 - a wait on an open blocker or a start date — `run:merge` releases it (`run-merge-steps.ts`);
-- a mechanical failure — the driver applies `run:stalled` (`RUN_STALLED_LABEL` in `issue-labels.ts`).
+- a mechanical failure — the driver applies `run:stalled` (`RUN_STALLED_LABEL` in `issue-labels.ts`)
+  and re-offers the causes it can itself up to its auto-retry cap; any other or capped row →
+  `run:add <N> --retry`
+  (`backlog-drive-stalled-retry.ts`, `docs/labels-and-run-states.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) is read against this list once its reason is
 known, and removed when the reason is not on it.
 
-## `in-progress` is removed by whoever finds it stale
+### A park the parent session resolves
 
-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).
+A recommendation the child lacked the permission to take → the parent runs
+`pnpm josh backlog:triage --apply <N> --adopt <k> --reason <text>` (tiers: `operating-rules.md` →
+"decision-autonomy"): a scoped size approval, a premise the body constrains, a run-tooling defect to
+file. An option whose `必要な権限` starts with `親` → carry it out first, then adopt it with
+`--done <what was done>`. A dependency → `--apply <N> --blocked-by <M>` / `--unblock <M>`. No tracking epic → comment the
+decision, `run:park <N> --clear`, `run:add <N> --retry`.
 
-**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 park the driver decides
 
-**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.**
+A `parked` child whose park recommends a tier A option needing no permission, or says `推奨なし` over a
+reversible option needing none and no size approval → `backlog:drive` decides it once per issue, records `Auto-decided: …`
+and notifies afterwards (`backlog-drive-after-merge.ts`, `run_park_body.default_pick`). A person
+overrides it with a later decision comment (`issue-comments.md`).
 
-```bash
-gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress 2>/dev/null || true
-```
+### A park left for a person
 
-## A prerequisite discovered mid-run
+`推奨なし` with no option the driver may take, a second park after its decision, a trust or security
+setting, an upstream defect, a third-party write, a destructive operation, or web-only information.
+
+## `in-progress` is removed by whoever finds it stale
 
-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.
+**A session that detects a stale `in-progress` on any open issue in the repository — not only this
+epic's children (`epic:next` names the holders on standard error) — runs `pnpm josh run:stale`**
+(Tier A) before continuing, and reports each `kept` / `removed` line (`docs/josh-commands-run.md` →
+"`josh run:stale`").
 
-1. File the prerequisite `<N>` with `route:tier-a` (Tier A, first-party, no confirmation) — **first**,
-   because the next step names it.
-2. **`pnpm josh run:pause <M> --for <N>`** — the stash, the comment naming its `stash:pop`, `<M>`
-   blocked by `<N>` (the epic's row and declaration too) and `run:release <M>` in one call
-   (`prerequisite.md`). Pop the stash the comment names when `epic:next` offers `<M>` again, after its
-   `pnpm josh ms`; expect conflicts.
-3. **Do not park.** Back to step 1 of the loop; `epic:next` hands back the prerequisite first.
+## A prerequisite discovered mid-run
+
+Something else in **this** repository has to land first: not a split, not an upstream defect. File it
+(`route:tier-a`) and set the child in hand `<M>` aside with `run:pause` — `prerequisite.md`, the
+single source of the distinction, the filing, the pause and the ceiling. Then:
 
-**A stop a dependency can express is never parked**, including a defect in this repository's own gate
-or run tooling — `prerequisite.md`.
+1. **Do not park.** Back to step 1 of the loop; `epic:next` hands back the prerequisite first.
+2. Resume as the pause comment names when `epic:next` offers `<M>` again: on its lane branch the
+   WIP commit is already there — `pnpm josh main:merge` and continue; a stash is popped after
+   `pnpm josh ms`.
 
 ## Splitting a child mid-run
 
-Not a reason to stop. File the new children with `route:split` (Tier A, first-party), then
+**A dispatched child is never split** (`split-assessment.md` → "Over the guide before the gate"):
+finish it, and file an independent new requirement found in it as an observation, without
+`--route split`.
+
+A split is decided before dispatch: file the new children (Tier A, first-party; `split-assessment.md`
+→ "Two or more always means an epic"), 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.
+`kickoff`. Splitting alone never adds `needs-decision` to the promoted epic.