@joshuafolkken/kit 1.1128.0 → 1.1166.0

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

@@ -12,7 +12,7 @@ restating any of it.
 **One `backlogrun` approves every merge of every issue `pnpm josh backlog:next` offers** — the issues
 carrying `auto-ok`, every child of an epic whose root carries it, **and an issue this run filed, once
 it has become such a child**. A filing is placed into an epic by `pnpm josh epic:bundle`, which
-`prompts/review.md` → "Review round cap" and `SKILL.md` → §2i both make **Tier A rather than
+`prompts/review.md` → "Review round cap" and `observation-filing.md` both make **Tier A rather than
 optional**; where that epic's root carries `auto-ok`, the child is offered from the next ask onwards
 without anybody having labelled it.
 
@@ -24,23 +24,26 @@ bounds it instead is "The brake that replaces the promise" below.
 epic"** — what runs is stated by the keyword and its arguments, never inferred from the shape of a
 request.
 
-**Which issues may be opted in stays a person's decision.** `auto-ok` is applied only by a person —
-this file is that rule's single source. **Which ones carry the label, a person; in what order and how
-many at once, the run.** An issue the run files and bundles into an already opted-in epic is offered
-from the next ask onwards, and the brake below bounds that quantity rather than the membership.
+**An issue found by opted-in work is opted in by default** (joshuafolkken/kit#3213) — this file is
+that rule's single source, and `pnpm josh issue:file` computes it (`scripts/issue/issue-auto-ok.ts`),
+printing `auto-ok: applied` or `auto-ok: not applied` with the reason. It applies `auto-ok` while a
+`backlogrun` carry record is live, or when the issue the current branch names carries `auto-ok`,
+and never on a `--repo` filing to another repository. **Pass `--no-auto-ok` only when the new issue needs a person's judgement** — a Tier B toss-up or a
+Tier C action inside it; a choice with a clear recommendation is Tier A and does not qualify.
+Outside those signals `auto-ok` stays a person's to apply. **Which ones carry the label, that rule;
+in what order and how many at once, the run** — the brake below bounds the quantity, not the
+membership.
 
-**The end-of-run retrospective is the one carve-out** (joshuafolkken/kit#2328): when a run drains its
-backlog, the retrospective files the improvements worth carrying into the next run and applies
-`auto-ok` to them. Its filings are counted against every brake in "The brake that replaces the
-promise" below with no exception, and a retrospective that judges nothing worth carrying files
-nothing. Every other filing route is unchanged: `auto-ok` stays a person's to apply.
+The end-of-run retrospective is no longer a separate carve-out: it files
+while the carry record is live, so the same default opts its filings in, counted against every brake
+in "The brake that replaces the promise" below.
 
 A Tier C action inside a child still stops that child, exactly as it does for any batch child.
 
 **A named issue is approved by the keyword and its number, not by `auto-ok`** (joshuafolkken/kit#1984).
-`backlogrun #N1 #N2 …` runs those issues whether or not they carry the label. The pool that follows is
-unchanged: still `auto-ok`, still a person's to opt in. "Named issues run first, in order" below is the
-procedure.
+`backlogrun #N1 #N2 …` runs those issues whether or not they carry the label. The pool that follows
+is unchanged: still `auto-ok`, opted in as "Which ones carry the label" above says. "Named issues
+run first, in order" below is the procedure.
 
 Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the authorization boundary is shaped this way"
 
@@ -53,23 +56,23 @@ inside the invocation" below):
 | --- | --- | --- |
 | `--max` | how many issues one invocation may merge — a run's own filing competes for that number rather than extending it | `run:carry --merged` |
 | `--idle`, and the 8-hour whole-run bound | how long one invocation may go on looking for more | the record's `started_at` |
-| **Ten filings per invocation** | how much one invocation may add to the pool at all, on **every** filing route (`SKILL.md` → §2d) | `run:carry --filed` |
+| **Ten filings per invocation** | how much one invocation may add to the pool at all, on **every** filing route (`prerequisite.md`) | `run:carry --filed` |
 | The WIP cap on open issues | how large the pool may become, across invocations | `prompts/collaboration-workflow/wip-cap.md` |
 
 One invocation may add at most ten issues to the pool and merge at most `--max` of them, after which
 the run ends and the next one waits for a person to type the keyword.
 
-**Two filing routes are exempt from the depth test (`SKILL.md` → §2i), and the ten-filings ceiling
+**Two filing routes are exempt from the depth test (`observation-filing.md`), and the ten-filings ceiling
 still covers them:**
 
-- **`route:tier-a` and `route:interrupt` stay exempt.** **Their number is still capped**: §2d's
+- **`route:tier-a` and `route:interrupt` stay exempt.** **Their number is still capped**: `prerequisite.md`'s
   ten-filings ceiling is stated "at every entry point", and `run:carry --filed` counts it across
   session cuts.
 - **A review branch-2 filing stays exempt** — a confirmed defect reaching a runtime path, with a
   written failure scenario.
 
 **This section is the single source of how the `epic:bundle` obligation and this authorization
-boundary meet.** `SKILL.md` → §2i points here rather than restating it.
+boundary meet.** `observation-filing.md` points here rather than restating it.
 
 ## Named issues run first, in order
 
@@ -95,7 +98,7 @@ issues it did not start. `backlog_named.after_failure` is the single source.
 
 - A named issue read back `CLOSED` — merged, or already `already-done` — is finished; continue with the
   next.
-- A **`needs-human-review`** named issue stops the whole run before its commit (`SKILL.md` → §2z),
+- A **`needs-human-review`** named issue stops the whole run before its commit (`needs-human-review.md`),
   exactly as any child does — the named issues after it are not started and neither is the pool.
 - Everything else about running one — the verification gate, the hand-off, the guards — is
   this file's and is not restated here.
@@ -189,11 +192,11 @@ the maximum, the whole-run bound), or the consecutive-failure guard tripped —
 it clears the record; the reason is the stop verdict's, in the session language. A clean completion
 takes the bare `--end` and stays silent, having its own report; a parked _child_ is pushed by the child
 that parked it (`backlogrun-park.md`). Because `--end` removes the record, a re-run's second `--end`
-finds nothing and never re-sends that confirmation — `backlogrun-progress.md` →
+finds nothing and never re-sends that confirmation — `progress-watcher.md` →
 "Progress while the run is quiet" is the single source of the pull-versus-push split.
 
-**The record widens nothing.** It carries a budget and nothing else: `auto-ok` is still applied only
-by a person. A pool grown across the cut by this run's own bundled filings is "What one invocation
+**The record widens nothing but the default.** It carries a budget, and its being live is what
+opts this run's filings in ("What one invocation approves"); no other label follows from it. A pool grown across the cut by this run's own bundled filings is "What one invocation
 approves", its ceiling counted from the record's `filed`.
 
 **Nothing waits for a person any more — `pnpm josh run:wake` supervises the driver**. After a cut or
@@ -215,7 +218,8 @@ owner prevents a second driver from taking it over. On `none`, `expired` or `unr
 person's**: the supervisor spends the declared budget and never declares another.
 
 **What may be run is untouched.** The driver takes named issues from the invocation and pool issues
-from the existing offer command. The supervisor writes no `auto-ok` label. A judgment session receives
+from the existing offer command. The supervisor writes no label of its own; `auto-ok` arrives only
+through `issue:file`'s default. A judgment session receives
 the original invocation plus the driver's reason and resume state.
 For a named epic, the driver hands off `epic #N` with the original invocation. The judgment session
 follows the named epic procedure and dispatches its children; the epic root is never launched as a
@@ -225,31 +229,9 @@ from the carry record's remaining named list, so the next driver pass can advanc
 also consults the carried maximum and whole-run bound
 before each launch, and a failed named issue skips the remaining named prefix.
 
-**A failure is visible rather than silent.** A judgment wake that never claims the carry record is retried, and
-once the retries are spent the supervisor stops and sends a `warning` Telegram; a carry record that
-expired or cannot be read ends it the same way. `none` — the run having finished — and a person's own
-`--stop` stay silent. Everything the supervisor starts writes to one log file per repository, named by
-`--list` and by every warning, so a silent exit stays diagnosable.
-
-**A person keeps control of it.** `pnpm josh run:wake --list` names the running supervisor and
-`--stop` ends it; the full contract, what it launches and why that is a constant rather than a
-setting are `docs/josh-commands-automation.md` → "`josh run:wake`".
-
-**Every unattended role runs with the provider selected from the invoking CLI and its own profile.**
-Codex sessions use OpenAI; Claude Code sessions use Anthropic. Anthropic uses scheduler
-`claude-opus-5-5`, worker `claude-opus-5-5` and reviewer `claude-opus-5-5`; OpenAI uses `gpt-6.1-sol`,
-with role efforts `medium`/`medium`/`high` (scheduler / worker / reviewer) for both. Role overrides
-resolve before launch; model overrides apply only to Claude Code, effort overrides to either provider,
-and legacy `JOSH_LANE_*` values to the worker only. Invalid configuration, a missing or conflicting
-session marker, or a missing, outdated or unauthenticated CLI refuses without fallback, promotion or
-worker retry. `run:wake --list`, `lane:list`, the review brief and each launch
-log expose the resolved provider, role, model and effort.
-`docs/josh-commands-automation.md` → "`josh lane:dispatch`" and `backlogrun-child.md` → "Each child runs in a
-delegated unit" are the single sources.
-
-**It relays progress from the existing report record.** The driver keeps the same `run:merge` event
-stream and `run:report` finish path; `pnpm josh run:wake --list` relays the latest line from that
-record. Telegram notifications retain their existing generation points (→ "It goes to the session only").
+**A person keeps control of it** — `pnpm josh run:wake --list` names the running supervisor and `--stop`
+ends it. Its failure warnings, log file, progress relay and the provider / model / effort each
+unattended role runs with are `docs/josh-commands-automation.md` → "`josh run:wake`".
 
 **The completion report names how many sessions were woken beside the record's `cuts`** — one wake per
 cut is the invariant, and what counts is a carry record actually claimed, never a process started.
@@ -291,7 +273,7 @@ children are enumerated individually rather than summarized under their root. Re
 stop at a time.**
 
 - **Decide everything decidable from the issue itself.** Read the issue's body **and its comments**
-  (`SKILL.md` → §2g), and where the answer is already there, record it as an Issue comment and
+  (`issue-comments.md`), and where the answer is already there, record it as an Issue comment and
   **remove the label** — `CLAUDE.md` → "Decision autonomy" already makes that Tier A. **Read them all in
   one `pnpm josh issue:read <N> <N> …` call**, not a `gh api` pair per issue.
 - **Never measure in order to decide.** A question needing a benchmark, a profile, or a run of the
@@ -301,8 +283,8 @@ stop at a time.**
   never the body.
 - **Order and isolate the pool in the same pass** (joshuafolkken/kit#2776), from the same
   `issue:read`: an issue that must land first (it builds what another reuses, or both edit one code
-  path) becomes a native `blocked-by`; an issue meeting all three of the `wip-cap.md` → 「実行のしかた」
-  conditions gets `run:solo`, **every other one `run:lane`**. Comment the reason; the offer commands enforce all
+  path) becomes a native `blocked-by`; an issue meeting all three of the `backlogrun-lanes.md` →
+  "Lanes — running more than one child at a time" conditions gets `run:solo`, **every other one `run:lane`**. Comment the reason; the offer commands enforce all
   three, answering `triage` while an issue has neither.
 - **`priority:high` puts an issue first** (joshuafolkken/kit#2928; ranking: `docs/josh-commands-automation.md` →
   `josh backlog:next`). Apply it only on a cited ground — a stated deadline or urgency, or a person's
@@ -313,96 +295,33 @@ stop at a time.**
   run does not wait on it.
 
 **`needs-decision`, `run:solo`, `run:lane` and `priority:high` are the workflow labels a run may
-apply, and none is `auto-ok` or `needs-human-review`.** Those two stay a person's alone (this file, `SKILL.md` → §2z); a
-run parks with `needs-decision` and a person clears it.
+apply by hand, and none is `auto-ok` or `needs-human-review`.** `needs-human-review` stays a
+person's alone (`needs-human-review.md`); `auto-ok` reaches only a run's own filing, through
+`issue:file`'s default ("What one invocation approves"). A run parks with `needs-decision` and a
+person clears it.
 
 Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the plan and the decision pass come first"
 
 ## The loop
 
-**The detached `run:wake` supervisor runs `backlog:drive`** after the carry record is handed off.
-Its driver keeps the loop below running without a parent AI turn. A returned judgment branch includes
-the first-line verdict, affected issue and `resume:` flags in the AI prompt; `stop` reports and ends
-inside the driver.
+**The loop is computed, not walked by hand.** The `run:wake` supervisor runs `pnpm josh backlog:drive`,
+whose head is `pnpm josh backlog:offer`: the answer-to-budget mapping, the retry count, the `--exclude`
+feedback and the lane count are its own (`docs/josh-commands-automation.md` → "`josh backlog:offer`"
+and "`josh backlog:drive`"). **An AI session reaches this section only when the driver hands a branch
+back** — the `Driver result:` line names it, and the session acts on it, then hands the loop back with
+`pnpm josh run:carry --cut --owner "$PPID"`:
 
-**The loop's head is one command — `pnpm josh backlog:offer`** (joshuafolkken/kit#2162). It runs
-`backlog:next`, maps its answer to the budget word the table below fixes, runs `backlog:budget`, and
-returns the verdict with the issues to start. It stays both halves' contract source: what an answer
-*means* changes here.
-
-```bash
-offer=$(pnpm josh backlog:offer --started "$started" --active "$active")
-offer=$(pnpm josh backlog:offer --started "$started" --active "$active" --exclude 1630,1631)   # after #1630, #1631 merged
-```
+| Handed back | What the session judges |
+| --- | --- |
+| `triage` | Label each issue stderr names `run:solo` or `run:lane` (with `blocked-by` where one must land first), as "Resolve what the plan can resolve" does; running children continue |
+| `offer` | `backlog:offer` itself could not answer. Report what stderr printed; **never pick an issue by hand** |
+| `launch #N` | A lane failed after it opened. Read the lane's log and park `#N` (`backlogrun-park.md` → "park and continue") |
+| `merge [<token>] #N` | `run:merge` stopped on `environment`, `busy`, `retry` or `over`, or printed nothing: `environment` ends the run, the others re-read the child (`backlogrun-progress.md` → "Running a named epic's children") |
+| `watch` | The backlog drained with nothing in flight; the retrospective is owed (`run:step`) |
+| `window` | The driver's wait window ran out with nothing to judge; hand the loop back as is |
 
-**The first line of standard output is the budget verdict; on `run`, the issue numbers to start
-follow, one per line.** `backlog:offer` forwards `--exclude` and `--repo` to `backlog:next` and
-`--started` / `--active` / `--merged` / `--running` / `--max` / `--idle` to `backlog:budget`, computes
-`--answer` itself, and carries the consecutive-retry count on the last stderr line (`retries: <n>`) and
-in `--json`. **The verdict table is "The two budgets" below; the answer-to-word mapping it applies is
-this section's table.**
-
-**`backlog:next`'s output contract is `docs/josh-commands-automation.md` → "`josh backlog:next`", and four parts
-of it decide how the mapping is written:**
-
-1. **Standard output is one token per line, and everything else is standard error.**
-2. **The tokens are bare issue numbers, scoped to the repository the command runs in.** A runnable
-   child in *another* repository is reported on standard error with its repository and checkout, and
-   is never a token; this repository having no candidate of its own is answered `wait`. **So
-   `backlogrun` takes no `owner/repo#N` token.** Report the other repository's candidates in the run
-   summary and leave them to a session running there (`backlogrun-lanes.md` → "Concurrency").
-3. **The verdict words are `wait`, `stop`, `triage`, `retry`, `error` and `none`** — `none` is
-   `epic:next`'s `complete` under this command's spelling, and there is no `complete` here. **`retry`
-   is the one with no `epic:next` counterpart**: it says GitHub did not answer.
-4. **Exit code 0 covers all six verdicts, and 1 means the listing could not be read** — no answer at
-   all. **`error` cannot be told apart by exit code, so read the token rather than the status.**
-
-**What the answer means is this table's; whether the run may act on it is `pnpm josh backlog:budget`'s**
-(joshuafolkken/kit#1632). The right-hand column ends in the word each answer is handed to that command
-as. Nothing here decides an ending on its own — the two budgets and every termination live in the next
-subsection.
-
-| Answer | What to do | Budget answer |
-| --- | --- | --- |
-| One or more issue numbers | Start each one as a child, up to the free lanes — `backlogrun-lanes.md` → "Lanes" and "Each child runs in a delegated unit", unchanged. Then **ask the command again**, with the merged numbers added to `--exclude` | `candidates` |
-| `wait`, with something of this run's own still in flight | Everything opted in is blocked or already running, so waiting can still change the answer. **Ask the command again on the in-flight wake — `pnpm josh lane:await` or the progress watcher's arrival exit, never a report** — the parent starts no sleep of its own, and the interval is a floor on the re-ask rather than a clock (`backlogrun-progress.md` → "Waiting, and never waiting forever" and "The parent keeps no clock of its own") | `blocked` |
-| `wait` this checkout can never resolve — the only candidates the command reported on standard error are in other repositories, and this run has nothing of its own in flight | Report those candidates with their checkouts. **Waiting cannot resolve them, but a person opting a new issue in here still can**, so the ending is the idle watch's rather than this row's | `exhausted` |
-| `stop` | Nothing can proceed without a person. Report the parked issues and finish | `parked` |
-| `triage` | A candidate lacks `run:solo` / `run:lane` (joshuafolkken/kit#2779). Judge each one stderr names as the pre-start pass does, then **ask again**; running children continue | `untriaged` |
-| `retry`, on fewer than three consecutive asks | GitHub did not answer, so the graph was never read. Sleep the polling interval and **ask the command again** — **this is one of the states with no watcher-delivered wake** (`backlogrun-progress.md` → "The wake exists only while something is in flight"). This is the one answer re-asking is allowed on, and the count is consecutive: any other answer resets it to zero | `blocked` |
-| `retry` for a third consecutive time | The outage is not a hiccup. Report what the command printed on standard error and finish | `unreadable` |
-| `error` | The graph could not be resolved — report what the command printed on standard error and finish. **Never re-ask hoping for a different answer**, and never fall back to picking an issue by hand | `unreadable` |
-| `none` | Nothing opted in is left | `exhausted` |
-| Exit 1, empty standard output | The listing could not be read. Report it and finish — **it is not `none`** | `unreadable` |
-
-**Three consecutive `retry` answers end the run**, and any other answer resets the count to zero, so
-`backlog:budget` is told `blocked` while retries remain and `unreadable` on the third.
-
-**Feed every issue this run has merged back through `--exclude`** — a just-merged issue can still read
-as open on the next ask. The flag takes a comma-separated list and may be repeated; it drops the issue
-from every bucket rather than only from the offer.
-
-**A short offer is not proof the backlog is empty**: the standalone half is capped at the five rows
-`🗒 Next issues` shows, so a sixth opted-in issue appears on the next ask; an epic's children come
-through its own graph, uncapped.
-
-**The epic side is found server-side by the `epic` label**, so an epic without it is invisible and
-tracks nothing — a known limit of the listing (joshuafolkken/kit#1633).
-
-**A child is offered on its own `auto-ok` unless the epic tracking it is opted in**
-(joshuafolkken/kit#1668). An epic that **is** opted in owns its children entirely and sequences them;
-ordering survives the standalone route on the children's own `blocked-by` relations, which `--ordered`
-records.
-
-**An order between two epics holds too** (joshuafolkken/kit#1943). A `blocked-by` relation whose
-blocker sits in another opted-in epic — or is an opted-in standalone issue — makes the child wait on
-time, so one `backlogrun` runs both epics in that order. A blocker outside the opted-in backlog, or one
-inside it that itself waits on a person, makes the child wait on a person instead, and a cycle across
-epics answers `error`. The table is `docs/josh-commands-automation.md` → "`josh epic:next`".
-
-**New work is picked up without restarting anything.** The command re-derives its pool from GitHub
-labels on every ask, so an issue filed and opted in while the run is going is offered on the next
-iteration, once triaged.
+**A candidate only in another repository is never a token** — report it with its checkout and leave it
+to a session running there (`backlogrun-lanes.md` → "Concurrency").
 
 Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the loop's contract is shaped this way"
 
@@ -428,13 +347,13 @@ at the first empty backlog. The default's single source is `scripts/backlog/back
 `DEFAULT_IDLE_MINUTES`. **A watch is polled every 5 minutes, not at the loop's 60-second interval** —
 read the interval from the reason `backlog:budget` prints rather than remembering it.
 
-**To become a candidate an issue needs `auto-ok`, which only a person applies** — except an issue this
-run filed and bundled under an already opted-in epic, which is admitted ("What one invocation
-approves") and bounded by the brake there, never the watch. No issue nobody opted in is ever picked up
-during a watch.
+**To become a candidate an issue needs `auto-ok`** — applied by a person, or by `issue:file`'s
+default to an issue this run filed ("What one invocation approves") — or to be a child this run
+filed and bundled under an already opted-in epic. Either is bounded by the brake there, never the
+watch. No issue that neither a person nor that default opted in is ever picked up during a watch.
 
 **`backlog:offer` asks `backlog:budget` for you on every iteration** — it maps `backlog:next`'s answer
-to the word the table above fixes and hands it over, so the loop makes the one call and reads back the
+to the word "The loop" points to and hands it over, so the loop makes the one call and reads back the
 verdict:
 
 ```bash
@@ -445,7 +364,7 @@ offer=$(pnpm josh backlog:offer --started "$started" --active "$active" \
 **`--active` is required of every ask, because the watch is on unless it was turned off** — an
 invocation whose watch is on and that carries no `--active` is **refused** by `backlog:budget`. Only
 `--idle 0` excuses it. **`--running` also decides `wait` and `--retries` decides `retry`** — the two
-context branches the table above carries, applied inside the command from the counts the loop already
+context branches that mapping carries, applied inside the command from the counts the loop already
 tracks.
 
 | Verdict | What the loop does |
@@ -511,12 +430,13 @@ Termination is decided by what the loop is told, never by a judgement that enoug
   rather than per epic: children per run, Issues filed per run, and consecutive child failures. The
   maximum above is a person's declaration of scale and does not replace any of them — whichever binds
   first ends the run.
-- **A `needs-human-review` child stops the whole run** before its commit — `SKILL.md` → §2z, which is
+- **A `needs-human-review` child stops the whole run** before its commit — `needs-human-review.md`, which is
   the single source, and `backlogrun-park.md` → "`needs-human-review` — the one stop that is not a park" for
   what happens to its lane.
 - **The hand-off check** — `pnpm josh cost --cut` at every child's merge, and the lane
   hand-over that follows an `over` — is `backlogrun-progress.md` → "The hand-off", unchanged. It is
-  **not** asked during an idle watch: "The cost check is not asked during a watch" above.
+  **not** asked during an idle watch: "The cost check is not asked during a watch" above, nor by the
+  supervisor's `backlog:drive`, which has no session to cut (joshuafolkken/kit#3156).
 - **Parking is not stopping.** A child that needs a decision, and a delegated unit that stopped
   without reporting, are **parked** and the run continues (`backlogrun-park.md` → "park and
   continue"); only the consecutive-failure guard above can turn repeated parks into a stop.
@@ -529,9 +449,9 @@ All of these are this file's, and are reached here in the same order and for the
 | --- | --- |
 | `git switch main && git pull`, then `pnpm josh latest:scope`, then `pnpm josh lane:prune` — in the primary checkout, before the first lane opens | `backlogrun-lanes.md` → "Once per repository, before the first lane opens" |
 | `josh latest` on `required` only, asked once at the first child and never in a lane | `backlogrun-child.md` → "`josh latest` runs once per session, not once per child" |
-| `pnpm josh run:hold <N>`'s preflight check, before each child that is not in a lane | `backlogrun-child.md` → "Preflight" |
-| `pnpm josh run:progress --wait` in the background, `--mark` at every real report | `backlogrun-progress.md` → "Progress while the run is quiet" |
-| `pnpm josh release:scope` once, after the last issue has merged and the last lane is closed | `followup-reference.md` → "When `pnpm josh release` runs" |
+| `pnpm josh run:hold <N>`'s preflight check, before each child that is not in a lane — act on what it prints | `docs/josh-commands-automation.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 issue has merged and the last lane is closed | `followup.md` → "When `pnpm josh release` runs" |
 
 **Two more run once per session and are this file's own**:
 `pnpm josh run:carry --begin "<the invocation, single-spaced>" --owner "$PPID"` before the plan and

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

@@ -45,11 +45,11 @@ Each step is a terse trigger and a pointer; the procedure is read on demand from
    `backlogrun-steps.md` → "The session cut is inside the invocation".
 3. **What this invocation approves** — `backlogrun-steps.md` → "What one invocation approves": the
    opted-in pool, a run's own filings once bundled, and the brake (`--max`, ten filings, the WIP cap)
-   that bounds the amount. `auto-ok` is a person's alone.
+   that bounds the amount. `auto-ok` reaches a run's own filings only through `issue:file`'s default.
 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. In the same pass, record `blocked-by`
    between issues that must land in order, and apply `run:solo` where all three of the
-   `wip-cap.md` → 「実行のしかた」 conditions hold, `run:lane` elsewhere. `backlogrun-steps.md` → "The plan,
+   `backlogrun-lanes.md` → "Lanes — running more than one child at a time" conditions hold, `run:lane` elsewhere. `backlogrun-steps.md` → "The plan,
    before the first child starts" and its "Resolve what the plan can resolve, before starting".
 5. **Named issues run first, in order** — `backlogrun-steps.md` → "Named issues run first, in order":
    the supervisor's driver dispatches each as a delegated `fullrun`, one at a time, then drains the
@@ -57,7 +57,7 @@ Each step is a terse trigger and a pointer; the procedure is read on demand from
 6. **The loop belongs to the supervisor** — `run:wake` runs `backlog:drive`; the driver uses
    `pnpm josh backlog:offer` as its loop head and returns a branch to an AI session only when it needs
    judgment. `backlogrun-steps.md` → "The loop"
-   fixes the answer-to-word mapping, "The two budgets" the `run` / `watch` / `stop` verdict, "The cost
+   fixes what a handed-back branch asks, "The two budgets" the `run` / `watch` / `stop` verdict, "The cost
    check is not asked during a watch", and "Where the run stops" every termination.
 7. **What runs once per session, not once per issue** — `backlogrun-steps.md` → "What runs once per
    session, not once per issue": the per-repository preflight, `josh latest` on `required`, the
@@ -80,7 +80,8 @@ named step reaches it, exactly as `backlogrun-steps.md` and the shared gate docu
 | --- | --- | --- |
 | `backlogrun-child.md` | dispatching the first child (`pnpm josh delegate epic-child`, `pnpm josh lane:dispatch`) | the shared per-child `fullrun`, a bare non-epic `#N`, the delegated unit and its summary bound, liveness recovery, and the once-per-session setup (audit, `josh latest`, preflight) |
 | `backlogrun-lanes.md` | opening the first lane (`pnpm josh lane:open`) | the per-repository lane ceiling and the lane lifecycle, and how a merge conflict is resolved |
-| `backlogrun-progress.md` | starting the progress watcher (`pnpm josh run:progress --wait`) and the hand-off check at a merge (`pnpm josh cost --cut`) | the heartbeat, the hand-off and the cut/resume, waiting without waiting forever, and the end-of-run summary and propagate |
+| `progress-watcher.md` | starting the progress watcher (`pnpm josh run:progress --wait`) | the heartbeat, shared with every implementing run |
+| `backlogrun-progress.md` | dispatching the first child and the hand-off check at a merge (`pnpm josh cost --cut`) | the hand-off and the cut/resume, waiting without waiting forever, and the end-of-run summary and propagate |
 | `backlogrun-park.md` | a child cannot finish | park-and-continue, the `needs-human-review` stop, a stale `in-progress`, a prerequisite discovered mid-run, and a mid-run split |
 
 ## Guards

package/.claude/skills/workflow-commands/chain-rule.md

@@ -10,7 +10,8 @@ Review results and successful pushes are never turn boundaries.
    whose prompt names `pnpm josh ship --log <N>` and (Anthropic lane, #2964) the re-detach to run after
    the fix — `pnpm josh ship --detach`, `--review` only if the stopped ship carried it and stopped before
    round 2, which is final (`scripts/run/run-ship-next.ts`); the supervisor skips a recorded round 1.
-   `failed` → step 1.
+   `failed` → step 1. A backgrounded `ship` issued alone is moved to the foreground by the hook
+   rather than refused (#3154).
 1. Run `pnpm josh main:merge`. **Then issue `pnpm josh run:cut <N>` alone, before the scoped pair and
    the gate** — the pre-gate cut (a no-op outside a lane, joshuafolkken/kit#2177). Then run the final scoped lint/test pair and `pnpm josh run:review`: it starts
    `pnpm josh gate` in the background and prints the `/code-review` brief in one call, so the two overlap
@@ -62,7 +63,7 @@ once here; the measurements that motivated each one live in the linked Issues.
 - **origin/main is merged in before the gate** — `pnpm josh main:merge` merges `origin/<default>` into
   the branch before the gate and the review start, so the gate verifies the tree that will actually
   merge rather than one that never existed (joshuafolkken/kit#1837). It is the last edit, so the scoped
-  pair and the gate run once over it. A conflict here fires `backlogrun-lanes.md` → "Conflicts are not predicted"
+  pair and the gate run once over it. A conflict here fires `backlogrun-recovery.md` → "Conflicts are not predicted"
   early. **This is the one place a conflicted merge's procedure is written** (joshuafolkken/kit#2445):
   `main:merge` refuses before merging when uncommitted changes touch a path the default branch also
   changed, or when the index still holds unresolved or staged paths — commit the work first with

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

@@ -1,4 +1,4 @@
-# Delegation decisions — `SKILL.md` §2b's procedure
+# Delegation decisions — the procedure
 
 Read this file when the first delegation decision arises during a run, not at workflow entry.
 
@@ -28,7 +28,7 @@ applies to named issues. `docs/josh-commands-automation.md` → "`josh fanout`"
 **`followup-filing` delegates the late review-finding filing chain** with the parent's finding text;
 the parent verifies the new Issue using `pnpm josh issue:state <new>`. For `epic-child`, the parent
 likewise verifies `pnpm josh issue:state <N>` after the unit returns. Read `human_review:` too: an open
-`needs-human-review` child is the authorized stop (`SKILL.md` → §2z), not a failed child. The per-entry
+`needs-human-review` child is the authorized stop (`needs-human-review.md`), not a failed child. The per-entry
 classification lives in `backlogrun-child.md` → "Each child runs in a delegated unit".
 
 ## The pre-implementation reading — what goes to a unit, and from which file
@@ -40,7 +40,11 @@ a temporary probe script and return its output.
 **The threshold is 3 files, and it is a count, not a forecast.** When the next read reaches it,
 delegate the unread investigation. Brief the unit on what was already read; do not re-read it there.
 **A delegation resets the counter rather than spending it**; `pnpm josh investigation:guard` counts
-unedited files and refuses the threshold read. `pnpm josh delegate --list` prints the threshold.
+unedited files and search turns and refuses the threshold call. `pnpm josh delegate --list` prints
+the threshold.
+
+**Dispatch the unit as the `investigator` agent** (`kit:investigator` in a consumer) — the parent's
+model at a lowered effort, read-only.
 `docs/josh-commands-automation.md` → "`josh investigation:guard`" carries the command's counting details.
 
 **The main line does not idle while the unit reads:** read files this run will edit, then verify the

package/.claude/skills/workflow-commands/entry-sequence.md

@@ -0,0 +1,62 @@
+# The entry sequence and the stop branches — shared by `fullrun`, `halfrun` and `prrun`
+
+**This file is the part of the three implementing manifests that is one procedure**
+(joshuafolkken/kit#3174). `fullrun.md`, `halfrun.md` and `prrun.md` name only how their own run
+differs from it; `pnpm josh run:step <N>` prints the run's next single action.
+
+## The ordered entry sequence
+
+**One call folds the mechanical steps** (joshuafolkken/kit#2372): `pnpm josh run:entry <N> --to
+<command>` claims the tree, reads the budget, bundles the reads and decides the pre-implementation
+step — steps 1, 3, 4 and 5 below in one round trip. Its `stage #<N>` line says where the run starts
+(`start: reached` redoes nothing — stop), and its `entry #<N> — hold: … · cost: … · verdict: …` line
+carries the three facts the run branches on; a `busy` / `unknown` hold or an `over` budget
+short-circuits with a non-zero exit. The numbered steps are the detail behind each fact.
+
+1. **Claim the working tree — first, before anything else.** `#N`: `pnpm josh run:entry <N> --to
+   <command>` (no `--to` is `fullrun`), which calls `run:hold` as its first step. `new`: bare `pnpm
+   josh run:hold`, ahead of the title and the filing. `hold` continues; `busy` / `unknown` stop with a
+   `confirmation` Telegram carrying stderr (`run:entry` sends it). `working-tree-hold.md` is the single
+   source; a cross-repository target resolves its checkout from `pnpm josh doctor` first
+   (`target-repository.md`).
+2. **`in-progress` rides on the hold** — for a `#N`, `run:entry` applies it once the tree is held and
+   the budget allows the run; a `new` entry applies it right after filing (`fullrun-steps.md`). Every
+   stop that leaves the tree clean ends with `pnpm josh run:release <N>`, which removes the label with
+   the record (a `new` entry's bare release does not — `working-tree-hold.md`).
+3. **Ask the session boundary in the same turn as the hold** — `pnpm josh cost --cut`. `under`
+   continues; `over` (or unanswerable) stops before the title — `run:entry` sends the `confirmation`
+   Telegram and runs `run:release` (`stop notified: …`); by hand only for `new`. **Skip it when
+   dispatched by a batch** (that batch owns the question). The verdict and the shared 135,000 threshold
+   are the command's own.
+4. **Gather the mechanical reads — `pnpm josh run:prep <N>`**: `issue:read`'s body and comments
+   (`issue-comments.md`), `issue:state`'s state, labels and `human_review`, and `latest:scope`'s
+   dependency scope in one report; a `new` entry runs it once filed. The comment stops, the
+   `human_review` stop (`needs-human-review.md`) and the dependency decision are read off it.
+5. **Print the next action — `pnpm josh run:step <N>`** — and follow it into the command's step list.
+   Before implementing, `git switch main && git pull`, then `pnpm josh latest:scope` — update
+   dependencies only on `required` (`latest-gate.md`), never on every run. `run:step` names every later
+   action in order, each read at the point-of-use document `SKILL.md` lists, never re-narrated here
+   (`residency.md` → "順序の問い").
+
+**Start the progress watcher once the hold is claimed** — `pnpm josh run:progress --wait` in the
+background, started once and relayed never, and `pnpm josh run:progress --mark` in the same turn as
+every real report (`progress-watcher.md` → "Progress while the run is quiet"). A run dispatched as a
+lane child starts none and never reads that document (`pnpm josh read:set lane-child`).
+
+## The stop branches
+
+- **`needs-human-review`** — implement and gate, then stop before the commit, keeping the hold and
+  `in-progress`; `needs-human-review.md`.
+- **A split** — the assessment (`split-assessment.md` → "The question") finds two or more
+  separately-mergeable deliverables over one gate: file the children (each `route:split`) and the epic,
+  then **STOP** with "Please run `backlogrun #<E> --only` to execute this epic." Typing the command
+  approved **one** Issue, never a batch.
+- **A prerequisite** — file it (`route:tier-a`), stash, record the dependency, and **STOP** with
+  "Please run `backlogrun #<E> --only` to execute this epic"; `prerequisite.md` is the single source of
+  the filing, the `-u` stash and the epic:bundle branch.
+- **An observation** — file it without asking and carry on; `observation-filing.md`.
+
+**Automatic filing is capped at 10 Issues per run.** On reaching it, stop and report.
+
+**The `into <target>` suffix** (a `new` entry) inserts the artifact into a named epic —
+`into-target.md`, read when the suffix is typed.