@joshuafolkken/kit 1.1136.0 → 1.1166.0

package/.claude/skills/workflow-commands/pre-gate-cut.md

@@ -166,103 +166,43 @@ built for the lane child.
 
 ### It is a guard, fired at the edit that crosses the threshold
 
-Rationale: `docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose".
-`pnpm josh rule:guard` **refuses an `Edit` / `Write`** while this checkout is a dispatched lane child
-whose recent-context cost is over threshold, handing back `pnpm josh run:cut --impl <N> --handoff <path>` — the
-refusal lands _before_ the edit. `cut` ends the turn, the rest leave this process implementing; a fresh
-process's `pnpm josh run:cut --resume <N>` then answers **`resume-impl`**, so it **skips the title, plan,
-hold claim and split assessment** and **continues implementation** rather than gating. Unlike the
-pre-gate cut, **the implementation resume clears the record** — it may fire again, unlike the
-once-per-lane pre-gate cut (joshuafolkken/kit#1935); `begin_cut`'s exclusive create still gives each
-crossing one successor.
-
-- **It fires for a marked child, or a run held outside a lane on a measured `over`**
-  (joshuafolkken/kit#2760); a person's tree holds no run. Outside a lane `cut` relaunches nothing: keep
-  the hold, send a `confirmation` Telegram naming `fullrun #<N>`, end the turn.
-- **It fires on every threshold crossing, not once per run** — it re-asks on
-  each over-threshold edit, including after a `busy` / `failed` / `unready` verdict.
-- **An edit reissued right after a refusal passes** — so a `busy` / `failed` cut cannot wedge the run:
-  the reissue lands inside a short window and goes through, a genuinely new crossing past it refuses
-  again.
-- **An unmeasurable session warrants the cut** in a lane, as the pre-gate cut's does.
-- **It is silent between a cut and its resume** — a carried record naming this issue keeps it quiet; the
-  resume clears it, and the fresh process reads its own transcript under threshold.
-- **The verdict read is reused over a short window** — cached per checkout for a few seconds, so a
-  turn's burst of edits shares one read.
-
-`scripts/rules/implementation-cut.ts` implements the trigger, and the row joins
-`prompts/collaboration-workflow/rule-delivery.md`. **A child that ended
-without cutting is still detected after the fact by `pnpm josh run:ending <N> --output <path>`**
-(joshuafolkken/kit#2139). **A single check (`lint:related` / `test:related`) is run after a batch of
-edits, not after each one.**
-
-## The threshold, and the statistic it is measured against
-
-**`CONTEXT_CUT_THRESHOLD` (135_000) is one value, and `cost_verdict.per_request_cost` — the one
-statistic the parent and the lane child both read — averages the most recent `RECENT_REQUEST_WINDOW`
-(10) requests, not the whole session**. The value is computed by
-`scripts/cost-runtime/context-cut-payback.ts`, its single source.
-
-**The cut is conditional**: taken only when the recent-window per-request cost
-is over `CONTEXT_CUT_THRESHOLD` — the same statistic and threshold the implementation-phase cut reads, so
-no second threshold exists. Below it `run:cut` answers `under-threshold` and the gate runs uncut; the
-guard reads the same verdict and stays silent. An **unmeasurable** session is always cut.
-Rationale: `docs/maintainers/pre-gate-cut-rationale.md` → "Why the threshold is a break-even".
-
-## Consistency with the chain rule
-
-The chain forbids ending a turn at the push, with CI in flight and nothing set to resume. **The pre-gate
-cut and the detached hand-off end it _before_ the gate** and start what carries the run on in the same
-act — a fresh process, or the supervisor — so the push is never a turn boundary. The implementation-phase
-cut is the same pattern one boundary earlier.
+**The trigger**: `pnpm josh rule:guard` refuses an `Edit` / `Write` in a dispatched lane child whose
+recent-context cost is over threshold, handing back `pnpm josh run:cut --impl <N> --handoff <path>`.
+`cut` ends the turn; a fresh process's `run:cut --resume <N>` answers `resume-impl` and continues
+implementation — **the implementation resume clears the record**, so the cut may fire again. Outside
+a lane, a held run on a measured `over` keeps the hold, sends a `confirmation` Telegram naming
+`fullrun #<N>` and ends the turn. The refusal states the rest — **It fires on every threshold crossing,
+not once per run**; **An edit reissued right after a refusal passes**; **An unmeasurable session
+warrants the cut**; **It is silent between a cut and its resume**. Rationale:
+`docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose";
+`scripts/rules/implementation-cut.ts` implements it. A child that ended without cutting is detected
+after the fact by `pnpm josh run:ending <N> --output <path>` (joshuafolkken/kit#2139).
+
+## The threshold
+
+`CONTEXT_CUT_THRESHOLD` and the recent-window `cost_verdict.per_request_cost` (the last
+`RECENT_REQUEST_WINDOW` requests) are computed by `scripts/cost-runtime/context-cut-payback.ts`, their
+single source; both cuts and the parent hand-off read the same verdict, and an unmeasurable session is
+always cut. Rationale: `docs/maintainers/pre-gate-cut-rationale.md` → "Why the threshold is a
+break-even". Both cuts end the turn **before** the gate, in the same act that starts the successor, so
+the push is never a turn boundary (`chain-rule.md`).
 
 ## A lane child records its park before it stops
 
-**A dispatched lane child records its park on the Issue before it stops for a decision**
-(joshuafolkken/kit#2034). A headless child's only route to ask a person is to park the Issue (#2012,
-#2011). Rationale:
-`docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose".
-
-**The record, before the Telegram, is the park procedure exactly** — `needs-decision` plus a comment
-carrying the question, the options, and whether work was stashed. Its single source is
-`backlogrun-park.md` → "park and continue", followed against the child's own Issue before the
-`confirmation` notify; with the label on the Issue, the parent's `pnpm josh run:liveness` reads the
-child as `settled`.
-
-**A `needs-human-review` or `already-done` stop needs nothing added** — those labels are already on the
-Issue. It is only a decision-stop (a Tier B toss-up, a Tier C action, an upstream defect, a split) that
-would otherwise leave the Issue bare.
-
-### The stop notify refuses until the park is recorded
-
-`pnpm josh rule:guard` **refuses `pnpm josh notify --task-type confirmation`** while this checkout is a
-lane child — the mark `JOSH_LANE_CHILD` names this lane's own issue — handing back the park commands.
-
-- **It fires for a marked child and nowhere else.** A person's own `fullrun` carries no mark and sends
-  its stop notify untouched.
-- **It fires once per run.** The child records the park and reissues the same notify; a
-  `needs-human-review` or `already-done` stop reissues after the one delivery, its label already on the
-  Issue.
-- **The park state is not readable synchronously**, so the delivery is a checklist — one wasted reissue
-  on the compliant path is safe.
-
-This section is the single source of the lane-child park rule; `scripts/rules/lane-park.ts` implements
-the trigger, and the row joins the enumeration in
-`prompts/collaboration-workflow/rule-delivery.md`.
+**The trigger**: a dispatched lane child about to stop for a decision (a Tier B toss-up, a Tier C
+action, an upstream defect, a split) parks its own Issue first — `backlogrun-park.md` → "park and
+continue" — so the parent's `pnpm josh run:liveness` reads it `settled` (joshuafolkken/kit#2034),
+after #2012 and #2011. A `needs-human-review` or `already-done` stop already carries its label.
+`pnpm josh rule:guard` refuses `pnpm josh notify --task-type confirmation` from a marked child until
+then — **It fires once per run.**, and a person's own `fullrun` is never refused
+(`scripts/rules/lane-park.ts`).
 
 ### The interactive ask is refused one call earlier
 
-(joshuafolkken/kit#2201) The harness refuses an interactive ask in a headless session by **ending the
-turn**, so the notify guard never fires (#2178 — the failure joshuafolkken/kit#2034 set out to prevent,
-one call upstream). So `pnpm josh rule:guard` **refuses `AskUserQuestion` for a marked lane child**; the
-deny returns to the model, and the instruction is to park the question. It fires on **every occurrence**
-and stays silent for a person working in a lane. Rationale:
-`docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose".
-
-**A child that slips past it is still recoverable** — `pnpm josh run:ending` lifts the refused ask out
-of the exit record's `permission_denials` into the `abandoned` verdict's park basis, so the parent puts
-it into the park comment. `scripts/rules/lane-interactive-ask.ts` implements the trigger, and
-`scripts/agent/interactive-ask.ts` is the
-shared extractor the guard and `run:ending` both read.
+**The trigger**: a headless session ends the turn on an interactive ask, so the notify guard never
+fires (#2178). `pnpm josh rule:guard` therefore refuses `AskUserQuestion` for a marked lane child on
+every occurrence — park the question instead (joshuafolkken/kit#2201), completing
+joshuafolkken/kit#2034. A child that slips past is recovered by `pnpm josh run:ending`, which lifts
+the refused ask into the park basis; `scripts/rules/lane-interactive-ask.ts` and the shared
+`scripts/agent/interactive-ask.ts` implement it.
 
-This file is the single source of the rule.

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

@@ -1,8 +1,8 @@
 # A prerequisite discovered mid-run — a dependency, not a park
 
-**This is the body of `SKILL.md` §2d, relocated here so the entry read carries the trigger and the
-pointer, not the procedure** (joshuafolkken/kit#2189). `SKILL.md` §2d is the resident stub, and each
-entry file (`fullrun.md` / `halfrun.md` / `backlogrun-park.md`) routes here for the definition. It is
+**This file is the single source, so the entry read carries the trigger and the pointer, not the
+procedure** (joshuafolkken/kit#2189). `SKILL.md` → §2's table keeps the trigger, and each entry file
+(`entry-sequence.md` / `backlogrun-park.md`) routes here for the definition. It is
 read at its point of use — the moment a run discovers that another Issue in this repository has to
 land first.
 
@@ -18,12 +18,12 @@ another is the failure this section exists to prevent:
 | A defect originating in **another package**                                 | File the upstream Issue and **stop** — Tier A for a first-party target; a third-party one is Tier C, recorded and drafted rather than filed (`CLAUDE.md` → "Cross-package problems"; `prompts/collaboration-workflow/upstream-interrupt.md`) |
 | This Issue was really **several** (a split)                                 | File the children and the epic and **stop** — except under `backlogrun`, whose authorization already covers a batch, so the children are filed and run through (`split-assessment.md`) |
 | Another Issue in **this** repository has to land first (**a prerequisite**) | This section                                                                                                            |
-| Something worth filing that is **none of the three** (**an observation**)   | File it **without asking** — Tier A for a first-party target — and **carry the run straight on**: nothing is stashed, nothing is parked (§2i). **A delegated child does not file here**, and a filing at depth 1 or deeper cites the depth-0 work it blocked; one that cannot cite it goes to the run's own `docs/maintainers/observations/<N>.md` and is filed on its second sighting — all of them §2i's |
+| Something worth filing that is **none of the three** (**an observation**)   | File it **without asking** — Tier A for a first-party target — and **carry the run straight on**: nothing is stashed, nothing is parked (`observation-filing.md`). **A delegated child does not file here**, and a filing at depth 1 or deeper cites the depth-0 work it blocked; one that cannot cite it goes to the run's own `docs/maintainers/observations/<N>.md` and is filed on its second sighting — all of them `observation-filing.md`'s |
 
 **File the prerequisite with the `route:tier-a` label**, so a Tier A filing made during implementation
 stays countable by filing route afterwards. **This paragraph belongs to the prerequisite row, not to
 the table** — the label means a filing the run is *blocked by*, so the observation row carries no
-`route:` label of its own (§2i):
+`route:` label of its own (`observation-filing.md`):
 
 ```bash
 pnpm josh issue:file "<title>" --body-file <body-file> --depth <n> --route tier-a
@@ -35,7 +35,7 @@ classification labels it declares, and runs the duplicate scan and `epic:bundle`
 
 Every "file the prerequisite" below means that labelled filing, and it always happens **first**: the
 steps after it name a number that does not exist until it is. **Its duplicate scan is read exactly as
-it is for a `new` entry** (§2e): a filing made mid-run is the one most likely to duplicate something.
+it is for a `new` entry** (`issue-scout.md`): a filing made mid-run is the one most likely to duplicate something.
 
 **Each entry point's own branch stays in that entry's file:**
 

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

@@ -0,0 +1,90 @@
+# The progress watcher — every implementing run
+
+**Read this file in full when the run's hold is claimed, before the watcher starts.** It is a
+point-of-use document, never an entry read, and the single source of the heartbeat for `fullrun`,
+`halfrun`, `prrun` and the `backlogrun` parent alike (joshuafolkken/kit#3172). `kickoff` starts none.
+
+## Progress while the run is quiet
+
+**Start the progress step without being asked** — in a single-issue run immediately after
+`pnpm josh run:hold` succeeds, in a `backlogrun` before step 1 of its loop.
+
+```bash
+pnpm josh run:progress --wait --output <the transcript path of each delegated unit>   # in the background
+```
+
+**Start it once; it reports by itself** (joshuafolkken/kit#3102). Each silence interval appends the
+five labelled lines to the run's event stream as a heartbeat and to the ambient log, prints nothing to
+standard output and keeps running — so a scheduled report never wakes the session, and the session
+relays none. **It exits only on one of three, and the command computes which:**
+
+| Exit                                                    | What the session does                                                  |
+| ------------------------------------------------------- | ---------------------------------------------------------------------- |
+| Newly runnable backlog work (the `ready #N` line)       | Read the ready line, act on it, and restart the watcher in that turn  |
+| `pnpm josh followup` removed the run's life record      | Nothing — the run has ended                                            |
+| `--hours` elapsed (8 by default for `--wait`)           | Restart the watcher in that turn                                       |
+
+**A report is not an exit, and neither is a decline** — with no run recorded it keeps waiting, and the
+`--hours` exit says so on standard error.
+
+**`pnpm josh run:watcher:guard` detects a missed restart** (joshuafolkken/kit#2113): wired into
+`pretool-guard` (joshuafolkken/kit#2353), it refuses the next tool call while lane children are in
+flight and the watcher's life record has gone stale — once per run, so the restart is not blocked.
+
+**`--mark` at every real report.** Whenever the run reports something of its own, run
+`pnpm josh run:progress --mark` in the same turn to restart the silence clock. The clock is silence,
+never a timer (`docs/josh-commands-automation.md` → "`josh run:progress`").
+
+**Do not keep a progress clock of your own** — the hook refuses the arm rather than asking
+(`scripts/rules/early-heartbeat.ts` → `decide`), though a single correctly-spaced arm is allowed.
+`--wait` is not a wait timer.
+
+**The default interval is twenty minutes, overridable — by the person, not the run.**
+`JOSH_PROGRESS_INTERVAL_MINUTES` moves both sides (the guard reads it through the watcher's reader);
+`josh` → `progress_interval_minutes` in `package.json` sits one step below the variable. **`--interval`
+moves the watcher alone** — it makes the watcher quieter than the floor, never the guard stricter.
+Rationale: `docs/maintainers/progress-watcher-rationale.md` → "Why the heartbeat reads as it does".
+
+### What a report says
+
+**Every unscheduled progress statement is answered by `pnpm josh run:progress --once`** — the reply to
+an explicit ask and the note just after a run starts alike; it is exempt from the interval and records
+the report itself, so no `--mark` beside it. **Relay its five field lines verbatim** — round, rephrase
+or re-label nothing, and **never write a clock time the command did not print**; where a field is
+missing, say so. **A field's empty value is an observation, never a state** (`record unread` is not
+*not stalled*), and **nothing in the lines is a verification result** — no gate, CI or check rollup.
+
+**The heartbeat is ambient, never a Telegram.** `pnpm josh run:event --watch` is its reader, in a pane
+of the person's own; **no session relays the stream** — name the watch command once, at the first cut
+or when asked. `pnpm josh run:wake --list` is the one-line read for a person who types for it.
+
+**A stop is the only interrupt** (joshuafolkken/kit#2136): a `backlogrun` that has stopped ends with
+`pnpm josh run:carry --end --stopped "<reason>"`, which sends one ⏸️ confirmation; a parked child sends
+its own (`backlogrun-park.md`). Rationale: `docs/maintainers/progress-watcher-rationale.md` → "Why the
+signal tiers are split this way".
+
+### Who starts it, and what counts as a report
+
+**One watcher per run, and the outermost invocation is the one that starts it.** `fullrun`, `halfrun`,
+`prrun` and `backlogrun` start the same watcher under these rules. A `fullrun` running as a
+`backlogrun` named issue or child starts none. **A dispatched lane child is refused a watcher by its
+`JOSH_LANE_CHILD` mark** — it still runs `--mark` for the parent's clock, but every reporting form
+(`--wait`, `--once`, the default watch) exits at once with a notice.
+
+**It is started in the target repository's checkout, and `--mark` is run there too.** A heartbeat is
+emitted from the moment a run has started — a registered lane, a held work tree or a carried budget —
+even before any child carries `in-progress`; only a checkout with no run recorded stays silent.
+
+**In a single-issue run, a real report is any turn that puts a progress statement in front of the
+person** — four of them, `--mark` run in the same turn as each: **the Step 0 work summary, the pull
+request opening, each review round's verdict, and any `confirmation` / `failure` / `completion`
+notification or stop.** **A tool result only you read is not one** — a gate run, a `gh` read, an edit.
+`--output` is omitted there, and `record` reads `unread`. In a `backlogrun`, a child merged, parked or
+stopped is the report.
+
+**A run that merges needs no teardown; a run that stops has to end the reporting itself.** A stop
+keeps the `in-progress` label on purpose, so **no further `--wait` is started** after the stop
+notification, and the running `--wait` is stopped in the same turn, since no report ends it. That
+covers `halfrun`'s stop before commit, a `needs-human-review` stop, a split or prerequisite stop, and a
+`backlogrun` named issue's failure stop. Rationale: `docs/maintainers/progress-watcher-rationale.md` →
+"Why the watcher runs where it does".

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

@@ -2,16 +2,16 @@
 
 `prrun` sits between `halfrun` (stop before commit) and `fullrun` (auto-merge). It runs `fullrun`
 up to a green, mergeable pull request and **stops before the merge**, so a person merges by hand
-(joshuafolkken/kit#3023). **Read `fullrun.md` for every step** — the entry sequence, the step lists,
-the gate, the review and the stop branches are `fullrun`'s, unchanged. This file names only the
-difference, never a second copy of the procedure.
+(joshuafolkken/kit#3023). **Read `fullrun.md` and `entry-sequence.md` for every step** — the entry
+sequence, the step lists, the gate, the review and the stop branches are `fullrun`'s, unchanged. This
+file names only the difference, never a second copy of the procedure.
 
 ## The difference — the entry
 
 `prrun #<N>` opens with `pnpm josh run:entry <N> --to prrun` where `fullrun` passes no `--to`
-(`SKILL.md` → §2k): a planned Issue starts at the implementation, a `halfrun` stop is adopted and
+(`docs/how-to/run-issues.md`): a planned Issue starts at the implementation, a `halfrun` stop is adopted and
 resumes at the gate, and an Issue already stopped by a `prrun` is reached — report the stage line and
-stop. A merged Issue is reached too, but the `entry #<N>` line after the stage line answers it (§2k).
+stop. A merged Issue is reached too, but the `entry #<N>` line after the stage line answers it.
 
 ## The difference — the end of the run
 

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

@@ -1,10 +1,10 @@
-# The end-of-run retrospective — `SKILL.md` §2j's body
+# The end-of-run retrospective
 
-**This is `SKILL.md` → §2j's procedure, and it is read when `run:step` prints the retrospective step —
-not at the entry** (joshuafolkken/kit#2328). §2j keeps the rule itself: run what `run:step` prints once,
+**This is the retrospective's procedure, and it is read when `run:step` prints the retrospective step —
+not at the entry** (joshuafolkken/kit#2328). `SKILL.md` → §2's table keeps the rule itself: run what `run:step` prints once,
 file the improvements worth carrying into the next run, stack the rest, and mark the step done.
 Everything that decides *how* — what the four sections mean, how the top two are chosen rather than
-rationed, the exclusions, and the `auto-ok` carve-out that lets the next run pick them up — is here,
+rationed, the exclusions, and the `auto-ok` default that lets the next run pick them up — is here,
 because none of it binds until a run has actually drained its backlog. A run that never empties its pool
 never reads it; the one that does reads it in full, in the same turn, before it files.
 
@@ -53,7 +53,7 @@ ceiling on what may be recorded. **File nothing when nothing passes** — a run
 improvement worth carrying files zero Issues, and that is what makes the "file → drain → file again"
 loop converge.
 
-**Exclude what is already filed or already done, through the existing scout** (`SKILL.md` → §2e). File
+**Exclude what is already filed or already done, through the existing scout** (`issue-scout.md`). File
 each with `pnpm josh issue:file`, which runs the scout before creating anything: an **open** candidate
 covering the same work means do not file it, and a `(closed)` candidate covering it means the work is
 already merged. Neither exclusion is a new mechanism. The same call runs `epic:bundle` on each new
@@ -61,10 +61,10 @@ Issue, as after any filing.
 
 ## `auto-ok`, and closing the step
 
-**A retrospective may apply `auto-ok` to what it files** — the one path on which a run labels its own
-input, so the next run picks the improvements up without waiting for a person. **`backlogrun-steps.md` →
-"What one invocation approves" is that carve-out's single source**; it is written there, beside the
-brakes that bound it, rather than restated here. Every brake still counts a retrospective's filings: the
+**What a retrospective files carries `auto-ok`** — it files while the carry record is live, so
+`issue:file`'s default applies the label and the next run picks the improvements up without waiting
+for a person. **`backlogrun-steps.md` → "What one invocation approves" is that default's single
+source**; it is written there, beside the brakes that bound it, rather than restated here. Every brake still counts a retrospective's filings: the
 ten-per-invocation ceiling, the WIP cap, `--max`, the 150,000-token session budget and the 8-hour
 whole-run bound.
 

package/.claude/skills/workflow-commands/split-assessment.md

@@ -29,7 +29,7 @@ whether *several findings from one session* are one Issue — and reads the **sa
 same conjunction**: separability, and whether the whole clearly exceeds one gate.
 `pnpm josh issue:fold "<title>" …` answers `fold` / `separate` / `no-fold-needed`; its size half is
 `pnpm josh split:assess`, called not recomputed, and `separate` needs both halves exactly as `split`
-does. **There is no second criterion.** §2i's observation, the review round cap's branch 2 and §2d's
+does. **There is no second criterion.** `observation-filing.md`'s observation, the review round cap's branch 2 and `prerequisite.md`'s
 prerequisite each route a second filing through it, delivered by `pnpm josh rule:guard` at the run's
 second `pnpm josh issue:file` call, never the first.
 
@@ -60,7 +60,7 @@ why a `split` from this command is the size condition met, not a decision to div
 
 "This needs something else done first" is a different answer from "this is really several things". A
 split means the request in hand contains two or more deliverables; a prerequisite means it is still
-**one** deliverable that has another one in front of it. The prerequisite rule is `SKILL.md` → §2d, its
+**one** deliverable that has another one in front of it. The prerequisite rule is `prerequisite.md`, its
 single source; each entry's own branch is in `backlogrun-park.md` → "A prerequisite discovered mid-run" and, for
 the stopping entry points, in `fullrun.md` / `halfrun.md`.
 

package/.claude/skills/workflow-commands/target-repository.md

@@ -1,9 +1,9 @@
 # The `owner/repo#` prefix — which repository the run acts on
 
-**This is `SKILL.md` → §2c's body, read at its point of use — the moment an entry is typed with an
+**This file is the prefix's single source, read at its point of use — the moment an entry is typed with an
 `owner/repo#` prefix (or a short `repo#` name), not at any entry** (joshuafolkken/kit#2161). A run
 given a bare `#N` or `new` targets the session's own repository and never reaches it, so it costs a
-workflow entry nothing to leave it here. `SKILL.md` → §2c keeps the trigger and points here.
+workflow entry nothing to leave it here. `SKILL.md` → §2's table keeps the trigger and points here.
 
 Every entry point takes the target repository in front of the Issue reference. Without it the target
 is the repository the session runs in.

package/.claude/skills/workflow-commands/working-tree-hold.md

@@ -1,8 +1,8 @@
 # The working-tree hold — one run per tree
 
-**This is the body of `SKILL.md` §2f, relocated here so the entry read carries the trigger and the
-pointer, not the procedure** (joshuafolkken/kit#2189). `SKILL.md` §2f is the resident stub, and
-`fullrun.md` / `halfrun.md` route here for the definition. It is read at its point of use — the moment
+**This file is the single source, so the entry read carries the trigger and the pointer, not the
+procedure** (joshuafolkken/kit#2189). `SKILL.md` → §2's table keeps the trigger, and
+`entry-sequence.md` routes here for the definition. It is read at its point of use — the moment
 a run is about to claim or release the tree.
 
 **Ask `pnpm josh run:hold` before anything else, and obey what it answers.** It is the first call of
@@ -47,12 +47,14 @@ ordinary one.
 **Release what the claim recorded, which is not always the Issue number.** A `#N` entry claimed `<N>`
 and releases `<N>`; a **`new` entry claimed before its Issue existed**, so it releases with the
 **bare** form however many numbers the run has acquired since — so a `fullrun new` that stops on a
-split types `pnpm josh run:release`, not `pnpm josh run:release <N>`.
+split types `pnpm josh run:release`, not `pnpm josh run:release <N>`. The bare form removes no
+label, so every `new` stop that releases — a split, a prerequisite or a third-party target — also runs `gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress
+2>/dev/null || true`.
 
 **Releasing is the run's, not a person's memory.** `pnpm josh followup` releases the hold on a merged
 run, and a record abandoned by a crashed session expires after 8 hours. **A stop that leaves the tree
 clean releases it explicitly**: a `fullrun` / `halfrun` that stops on a split, a prerequisite or a
-third-party target ends with `pnpm josh run:release <N>` (bare where that run entered as `new`).
+third-party target ends with `pnpm josh run:release <N>` (bare where that run entered as `new`, followed by the label DELETE above).
 **`halfrun`'s stop before commit keeps the hold**, and so does a `needs-human-review` stop: the
 uncommitted work still in the tree is exactly what a second run would trample, so the release command
 goes in the stop report and the Telegram for the person to type. **`fullrun #<N>` of the same issue

package/.codex/hooks.json

@@ -17,7 +17,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/session-lang.js; else pnpm josh session:lang; fi",
+						"command": "project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null || git rev-parse --show-toplevel)\" && cd \"$project_root\" && sh scripts/hooks/run-hook.sh session-lang",
 						"timeout": 10
 					}
 				]
@@ -29,7 +29,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/codex-hook-adapter.js pretool; else pnpm exec tsx scripts/hooks/codex-hook-adapter.ts pretool; fi",
+						"command": "project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null || git rev-parse --show-toplevel)\" && cd \"$project_root\" && sh scripts/hooks/run-hook.sh codex-hook-adapter pretool",
 						"timeout": 20
 					}
 				]
@@ -41,7 +41,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/codex-hook-adapter.js posttool; else pnpm exec tsx scripts/hooks/codex-hook-adapter.ts posttool; fi",
+						"command": "project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null || git rev-parse --show-toplevel)\" && cd \"$project_root\" && sh scripts/hooks/run-hook.sh codex-hook-adapter posttool",
 						"timeout": 90
 					}
 				]
@@ -53,7 +53,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/stop-guard.js; else pnpm josh stop:guard; fi",
+						"command": "project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null || git rev-parse --show-toplevel)\" && cd \"$project_root\" && sh scripts/hooks/run-hook.sh stop-guard",
 						"timeout": 20
 					}
 				]

package/AGENTS.md

@@ -3,9 +3,4 @@
 > **All rules for this repository live in [`CLAUDE.md`](./CLAUDE.md). Read it in full before doing
 > any work here, and follow every rule in it.** This file exists only to point at it.
 
-**Codex runs the same hooks from `.codex/hooks.json`**, generated from `.claude/settings.json`; where
-it does not show a hook's output, apply that rule yourself. How to read `CLAUDE.md`'s Claude Code
-features here is `prompts/collaboration-workflow/principles.md` → "Claude Code 以外のエージェントでの読み替え".
-
-**Do not copy rules back into this file.** Every change to how agents work in this repository belongs
-in `CLAUDE.md`.
+**Codex runs the same hooks from `.codex/hooks.json`** (generated from `.claude/settings.json`) — apply any rule whose hook output you do not see yourself, per `prompts/collaboration-workflow/principles.md` → "Claude Code 以外のエージェントでの読み替え". Do not copy rules back into this file.