@joshuafolkken/kit 1.1455.0 → 1.1471.0

package/scripts/report/report-lint.ts

@@ -102,8 +102,7 @@ function overview_lines(summary: string): ReadonlyArray<string> {
 function item_sentence(line: string): string {
 	const open = line.indexOf(BOLD_MARKER)
 	const close = open === -1 ? -1 : line.indexOf(BOLD_MARKER, open + BOLD_MARKER.length)
-	const raw =
-		close === -1 ? line.slice(ITEM_LINE_PREFIX.length) : line.slice(close + BOLD_MARKER.length)
+	const raw = line.slice(close === -1 ? ITEM_LINE_PREFIX.length : close + BOLD_MARKER.length)
 
 	return raw.replace(LEADING_LABEL_PUNCTUATION, '').trim()
 }
@@ -199,8 +198,12 @@ function break_condition_count(lines: ReadonlyArray<string>): number {
 }
 
 function case_line_violations(summary: string): ReadonlyArray<string> {
-	if (!has_changes_section(summary)) return []
-	if (changes_region_lines(summary).some((line) => line.includes(CASE_LABEL))) return []
+	if (
+		!has_changes_section(summary) ||
+		changes_region_lines(summary).some((line) => line.includes(CASE_LABEL))
+	) {
+		return []
+	}
 
 	return [`✖ no case tier (${CASE_LABEL}:) in ${CHANGES_LABEL}`]
 }

package/scripts/review/review-record-cli.ts

@@ -58,8 +58,12 @@ interface Parsed {
 // A finding spec is `<category>:<severity>:<file>`; the file field keeps any `:line` a citation
 // carries, so only the first two colons separate fields.
 function to_finding(category: string, severity: string, file: string): Finding | undefined {
-	if (!review_finding_ledger.is_category(category)) return undefined
-	if (!review_finding_ledger.is_severity(severity)) return undefined
+	if (
+		!review_finding_ledger.is_category(category) ||
+		!review_finding_ledger.is_severity(severity)
+	) {
+		return undefined
+	}
 
 	return review_finding_ledger.is_valid_file(file) ? { category, severity, file } : undefined
 }

package/scripts/rules/destructive-command.ts

@@ -97,21 +97,18 @@ function is_destructive_command(command: string): boolean {
 }
 
 const DESTRUCTIVE_COMMAND_REASON =
-	'⛔ destructive command: a recursive forced `rm` (`rm -rf`, `rm -fr`, `rm -r -f`, `rm --recursive ' +
-	'--force`), `gh repo delete` / `archive`, `gh repo edit --visibility`, `gh pr close`, or a `gh api ' +
-	'-X DELETE repos/…` call deletes or closes something that cannot be restored, which is Tier C and ' +
-	'needs explicit current-turn user instruction (`prompts/collaboration-workflow/operating-rules.md`). ' +
-	'The `.claude/settings.json` deny list matches prefix globs, so it misses these spellings; this row ' +
-	'reads the argv instead. Remove a file or directory one path at a time without `-f`, or ask the user ' +
-	'to run the command in their own terminal. `gh issue close` and removing a label from an Issue ' +
-	'(`DELETE repos/<o>/<r>/issues/<N>/labels/<name>`) are not refused. **This rule fires on every ' +
-	'occurrence, not once per run.**'
+	'⛔ destructive command: a recursive forced `rm`, a `gh repo delete` / `archive` / visibility edit, ' +
+	'`gh pr close` or a `gh api -X DELETE` cannot be undone, which is Tier C. Remove one path at a ' +
+	'time without `-f`, or ask the user to run it. It fires on every occurrence ' +
+	'(`prompts/collaboration-workflow/operating-rules.md`).'
 
 const ROW = {
 	id: 'destructive-command',
 	is_trigger: bash_triggers.on_bash_command(is_destructive_command),
 	reason: DESTRUCTIVE_COMMAND_REASON,
 	decide: (): boolean => true,
+	// The opening the reason carried before it was cut to the action and the next command.
+	former_reasons: ['⛔ destructive command: a recursive forced `rm` (`rm -rf`'],
 }
 
 const destructive_command = { DESTRUCTIVE_COMMAND_REASON, ROW, is_destructive_command }

package/scripts/rules/direct-filing.ts

@@ -9,13 +9,9 @@ import { bash_triggers } from './bash-triggers'
 
 const DIRECT_FILING_REASON =
 	'⛔ direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> ' +
-	'--depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>]`, never with `gh api …/issues` ' +
-	'or `gh issue create`. The command runs every filing step in order — the duplicate scout, the body ' +
-	'lint and its classification labels, the depth and `route:` labels, the `## Origin` check when filing ' +
-	'into another repository, and `epic:bundle` after the create — so none of them is a step to remember. ' +
-	'When the scout prints candidates it holds the filing: read each, then reissue with `--distinct <N,…>` ' +
-	'for the ones that are separate deliverables. Reference: `docs/josh-commands-backlog.md` → "`josh issue:file`". ' +
-	'**This rule fires on every occurrence, not once per run.**'
+	'--depth <0|1|2>`, never with `gh api …/issues` or `gh issue create` — it runs the scout, the lint, ' +
+	'the labels and `epic:bundle` itself. It fires on every occurrence (`docs/josh-commands-backlog.md` ' +
+	'→ "`josh issue:file`").'
 
 function is_any_filing(command: string): boolean {
 	return bash_triggers.is_direct_filing(command) || bash_triggers.is_issue_filing(command)

package/scripts/rules/early-heartbeat.ts

@@ -178,25 +178,14 @@ function decide(call: GuardedCall, run: GuardRun, can_record: boolean): boolean
 }
 
 // The instruction in the shape a refusal can carry: what the call is about to do, what already does it
-// properly, and the one command an explicit ask is answered with. The observed failure is named
-// because it is what makes the rule believable.
+// properly, and the one command an explicit ask is answered with. The observed failure behind it is in
+// `docs/maintainers/rule-delivery-rationale.md`.
 const EARLY_HEARTBEAT_REASON =
-	'⛔ early heartbeat: this call arms a wait timer of its own, and the progress clock is not yours ' +
-	'to keep. `pnpm josh run:progress --wait` keeps it for you ' +
-	'(`JOSH_PROGRESS_INTERVAL_MINUTES`, or `josh.progress_interval_minutes` in `package.json`, ' +
-	'default 20 minutes): start it once in the background and it reports the five labelled lines to ' +
-	"the run's event stream on its own, without waking you — relay nothing, and start it again only " +
-	'after it exits, which it does when newly runnable work arrives. Two timers armed at ' +
-	'once is what produced reports 3–5 minutes apart on a 15-minute setting ' +
-	'(joshuafolkken/kit#1570): a new one was armed on the turn a timer fired and again on the turn a ' +
-	"child's completion woke the run, and `--mark` recorded each report without anything refusing the " +
-	'early ones. **An explicit ask is not a heartbeat**: if the person asked for progress now, run ' +
-	'`pnpm josh run:progress --once`, which prints the five labelled lines whatever the clock says — ' +
-	'under `backlogrun`, `pnpm josh run:board --chat` instead. If you are ' +
-	'waiting on something rather than on a clock, wait on the thing itself — `pnpm josh followup` ' +
-	'waits for CI. The procedure is `.claude/skills/workflow-commands/backlogrun.md` → "Progress while ' +
-	'the run is quiet". **This rule fires on every early arm, not once per run**, so reissuing the ' +
-	'same sleep will be refused again.'
+	'⛔ early heartbeat: this call arms a wait timer of its own. Start `pnpm josh run:progress --wait` ' +
+	"once in the background: it reports to the run's event stream on its own — relay nothing. When " +
+	'asked, `pnpm josh run:progress --once` — under `backlogrun`, `pnpm josh run:board --chat`; ' +
+	'for CI, `pnpm josh followup`. It fires on every occurrence ' +
+	'(`.claude/skills/workflow-commands/progress-watcher.md`).'
 
 // **Keeping this rule is letting the watcher hold the clock** — `pnpm josh run:progress --wait` waits
 // the interval out, and `--once` answers an explicit ask. `--mark` is neither: it records a report

package/scripts/rules/file-body.ts

@@ -171,20 +171,13 @@ function carries_a_file_body(
 	)
 }
 
-// The instruction in the shape a refusal can carry: what the command is doing, the safe tool, and the
-// file forms that stay allowed. The measured cost is named because it is the half that reads as
-// surprising — the command body is billed on every later request of the run.
+// The instruction in the shape a refusal can carry: what the command is doing and the safe tool. The
+// measured cost behind it is in `file-edits.md`.
 const FILE_BODY_REASON =
-	"⛔ file body in a shell command: this carries a file's new text inline — a heredoc rewriting an " +
-	'existing file, an interpreter (`python3 - <<`, `node -e`) whose body writes, a script file (`cat > ' +
-	'edit.py <<EOF`) whose body writes, or an in-place `perl -0pi -e`. `CLAUDE.md` forbids it because ' +
-	'the command body is re-read on every later request of the run, so an editing script written early ' +
-	'is billed for the rest of it (`file-edits.md` measured one run at ~2m45s spent retyping existing ' +
-	'lines). Edit a region with the Edit tool (old / new); a change scattered so widely that the ' +
-	'partial edits would carry more than the file is rewritten whole with the Write tool, never a ' +
-	'heredoc. Pass a body by path (`--field body=@<path>`, `--body-file <path>`). A new-file creation (`cat > ' +
-	'<new-file> <<EOF`), a read-only heredoc (`cat <<EOF`), and a short `sed -i` stay allowed. **This ' +
-	'rule fires on every occurrence, not once per run.**'
+	"⛔ file body in a shell command: this carries a file's new text inline, which is re-read on every " +
+	'later request. Edit a region with the Edit tool, rewrite a whole file with the Write tool, and ' +
+	'pass a body by path (`--body-file <path>`); a new-file `cat > <new-file> <<EOF` stays allowed. ' +
+	'This rule fires on every occurrence (`prompts/collaboration-workflow/file-edits.md`).'
 
 const ROW = {
 	id: 'file-body',

package/scripts/rules/filing-cap.ts

@@ -104,12 +104,9 @@ function decide(_call: unknown, run: GuardRun): boolean {
 }
 
 const FILING_CAP_REASON =
-	`⛔ filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling — on ` +
-	'reaching it, stop and report rather than filing more. Automatic filing is capped so a run cannot ' +
-	'manufacture Issues faster than they can be closed (`.claude/skills/workflow-commands/SKILL.md` → ' +
-	"`prerequisite.md`, `observation-filing.md`). A further Issue that genuinely must exist is a person's call, not " +
-	"this run's. **This rule fires on every filing past the cap, not once per run**, so reissuing the " +
-	'same filing will be refused again.'
+	`⛔ filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling. Stop ` +
+	"filing and report; a further Issue is a person's call. It fires on every occurrence " +
+	'(`.claude/skills/workflow-commands/observation-filing.md`).'
 
 // The enumeration row itself, so `delivered-rules.ts` spreads one entry rather than restating the
 // trigger and reason it already single-sources here. It declares no `keeps`: staying under a cap is

package/scripts/rules/git-force.ts

@@ -69,19 +69,15 @@ function is_force_or_delete(command: string): boolean {
 	return shell_segments.segments_of(command).some((segment) => is_destructive_segment(segment))
 }
 
-// The instruction in the shape a refusal can carry: what the command does, why the deny list did not
-// stop it, and the one route left. There is no "safe reissue" the way a backgrounded push is for
+// The instruction in the shape a refusal can carry: what the command does and the one route left. The
+// spellings the deny glob misses are pinned on `is_force_or_delete`, not repeated in the text. There is no "safe reissue" the way a backgrounded push is for
 // `run-tail` — a force push and a branch delete are Tier C, so the honest next move is a person's, in
 // their own terminal.
 const GIT_FORCE_REASON =
 	'⛔ force push or branch delete: this rewrites or removes shared history, which is Tier C and needs ' +
-	'explicit current-turn user instruction — never an AI decision, even to fix a problem you caused ' +
-	'(`prompts/collaboration-workflow/operating-rules.md`). The `.claude/settings.json` deny list ' +
-	'matches globs, so it misses this spelling: a combined short cluster (`git push -uf`), a `git -C ' +
-	'<path>` prefix, and the colon-form delete (`git push origin :branch`) all pass it. This row reads ' +
-	'the argv instead, so the spelling does not matter. For an ordinary push use `pnpm josh git`; a ' +
-	"force push, a `git push --delete` / `:branch`, or a `git branch -d` / `-D` is the user's to run in " +
-	'their own terminal. **This rule fires on every occurrence, not once per run.**'
+	'explicit current-turn user instruction. Push with `pnpm josh git`; leave a force push or branch ' +
+	"delete to the user's own terminal. This rule fires on every occurrence " +
+	'(`prompts/collaboration-workflow/operating-rules.md`).'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. `decide` returns true so it refuses every
 // occurrence; it declares no `keeps` — not force-pushing is the absence of a call, not a call, so the

package/scripts/rules/implementation-cut.ts

@@ -7,7 +7,9 @@ import type { GuardRun } from '#scripts/josh/hook-decision'
 import { lane_child_marker, type MarkerSource } from '#scripts/lane/lane-child-marker'
 import { lane_paths } from '#scripts/lane/lane-paths'
 import { run_cut, type RunCut } from '#scripts/run/cut/run-cut'
+import { run_cut_decline } from '#scripts/run/cut/run-cut-decline'
 import { run_cut_handoff } from '#scripts/run/cut/run-cut-handoff'
+import { run_cut_ready } from '#scripts/run/cut/run-cut-ready'
 import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { bash_triggers } from './bash-triggers'
 import { implementation_cut_verdict } from './implementation-cut-verdict'
@@ -62,6 +64,16 @@ interface LaneCostState {
 	// held outside a lane is told apart from a person's tree.
 	held_issue: () => string | undefined
 	verdict: () => CostVerdict
+	// Whether `run:cut --impl` could take the cut for this issue now — see `can_cut_sync`.
+	can_cut: (issue: string) => boolean
+}
+
+// **The guard asks for a cut only where `run:cut --impl` could take one** (joshuafolkken/kit#3881).
+// A run held on the default branch, or one whose cut was already answered `not-a-lane` / `unready`
+// under this hold, can only be refused again, so each refusal was a round trip that cut nothing. The
+// decline record is a file read and comes first; the tree read spawns git and comes second.
+function can_cut_sync(issue: string): boolean {
+	return !run_cut_decline.is_declined_sync(issue) && run_cut_ready.is_ready_sync()
 }
 
 function current_state(): LaneCostState {
@@ -75,6 +87,7 @@ function current_state(): LaneCostState {
 		// the window collapses one turn's burst of edits to a single whole-transcript price.
 		verdict: (): CostVerdict =>
 			implementation_cut_verdict.reused_verdict(() => cost_cli.session_verdict()),
+		can_cut: can_cut_sync,
 	}
 }
 
@@ -140,14 +153,19 @@ function warrants_the_cut(state: LaneCostState): boolean {
 // **The unmeasurable direction matches the pre-gate cut**. A session that
 // cannot be priced reads as warranting the cut, the same safety-net direction `pre-gate-cut.ts`'s
 // `warrants_the_cut` takes (`verdict !== UNDER_VERDICT`): the two rules read one statistic against one
-// threshold, so they must not disagree about whether an unmeasurable session is due a cut.
+// threshold, so they must not disagree about whether an unmeasurable session is due a cut. Whether the
+// cut could be taken is asked only once it is warranted, so an under-threshold edit spawns no git.
 function is_over_threshold_edit(
 	call: GuardedCall,
 	state: LaneCostState = current_state(),
 ): boolean {
-	if (!is_edit_tool(call.name) || uncut_run_issue(state) === undefined) return false
+	if (!is_edit_tool(call.name)) return false
+
+	const issue = uncut_run_issue(state)
+
+	if (issue === undefined) return false
 
-	return warrants_the_cut(state)
+	return warrants_the_cut(state) && state.can_cut(issue)
 }
 
 // **The threshold in the refusal text is assembled from the constant, never spelled**.
@@ -155,36 +173,14 @@ function is_over_threshold_edit(
 // building it from `CONTEXT_CUT_THRESHOLD` keeps the two from drifting. `cost_format.format_tokens` renders it the way every cost report does.
 const THRESHOLD_TEXT = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`
 
-// The instruction in the shape a refusal can carry: what the cut is for, what each verdict means, and
-// the reissue sentence every delivery needs. The verdicts are spelled out rather than pointed at,
-// because `cut` is the only one that ends the turn and a run told merely to "take the cut" would have to
-// read which of the others leave it implementing — the same reason `pre-gate-cut.ts` spells them out.
+// The instruction in the shape a refusal can carry: the handoff in the format the parser reads, the
+// cut, and the one verdict that ends the turn — `cut` is the only one, so a run told merely to "take
+// the cut" is not left to look it up.
 const IMPLEMENTATION_CUT_REASON =
-	'⛔ implementation-phase cut: this checkout is a lane dispatched for this issue, or a run holds it for ' +
-	'this issue (joshuafolkken/kit#2760), and its recent-context ' +
-	`cost has crossed the shared ${THRESHOLD_TEXT} threshold mid-implementation, so the thinking accumulated ` +
-	'so far is now re-read on every later request. Take the cut before this edit. ' +
-	`First write a handoff file at \`${run_cut_handoff.HANDOFF_PATH}\` (ignored, so it is never committed) with the Write tool — the user’s instruction verbatim, what you have ` +
-	'completed, what remains, and what you deliberately did not touch, as ' +
-	`${run_cut_handoff.HANDOFF_FORMAT} (Markdown is refused) — and pass it as \`--handoff <path>\`, ` +
-	'so the fresh process resumes on the original instruction rather than the working tree alone ' +
-	'(joshuafolkken/kit#2354); a resume that finds no instruction is refused `incomplete` rather than ' +
-	'continuing blind. ' +
-	'`pnpm josh run:cut --impl <N> --handoff <path>` ends this process and relaunches a fresh one that resumes back into ' +
-	'implementation (`resume-impl`), dropping the accumulated context rather than carrying it — ' +
-	'joshuafolkken/kit#1933 built the boundary and joshuafolkken/kit#2310 measured it firing 0 times ' +
-	'because the verdict was only ever read at session entry, where the context has not yet grown. The ' +
-	"verdict is `pnpm josh cost --cut`'s exactly — the same per-request billed-input statistic against the " +
-	'same threshold, never a second measurement. Issue `pnpm josh run:cut --impl <N> --handoff <path>` now and read the ' +
-	'verdict: on `cut`, read what the command printed. Where it relaunched a fresh process, **end the turn ' +
-	'immediately** — that process owns the run and continues implementing, so it must not be waited for, ' +
-	'and **no Telegram is owed**: a cut that resumes itself leaves a person nothing to act on. Where it printed that nothing was relaunched, do what it prints, then end the turn; on `not-a-lane`, `unready`, `busy`, `failed` or ' +
-	'`unknown`, this process carries the run on and the edit is simply the next call. Never relaunch a ' +
-	'second process after `busy`. This fired because the dispatch mark names this lane or the run hold ' +
-	'names this issue; a person working here carries no mark and holds no run, so sees no refusal, so there is no human-or-child judgement left to make. The ' +
-	'procedure is `.claude/skills/workflow-commands/pre-gate-cut.md`. Reissue this edit once the cut has ' +
-	'answered — an edit reissued right after this refusal passes, so `busy` / `failed` cannot wedge the ' +
-	'run edit after edit; this fires again on the next threshold crossing rather than once per run.'
+	`⛔ implementation-phase cut: refused on every edit past the ${THRESHOLD_TEXT} line. ` +
+	`Write \`${run_cut_handoff.HANDOFF_PATH}\` as ${run_cut_handoff.HANDOFF_FORMAT}, run ` +
+	'`pnpm josh run:cut --impl <N> --handoff <path>`; `cut`: end the turn immediately, no Telegram ' +
+	'is owed; else reissue the edit (`.claude/skills/workflow-commands/pre-gate-cut.md`).'
 
 // **A refusal younger than this window is this edit's own refusal being answered**.
 // A `decide` row that refused every over-threshold edit would wedge a run whose cut came back `busy` /
@@ -201,7 +197,8 @@ function is_reissued_refusal(now_ms: number, delivered_at_ms: number): boolean {
 // silenced the row for the rest of a process the moment its first refusal landed — and a `busy` /
 // `failed` / `unready` verdict, or an edit reissued unchanged, left the context to grow unwatched to
 // 282,747 tokens with the cut never taken. `decide` re-asks on every over-threshold edit; the reissue
-// window is what keeps that from wedging a run that genuinely cannot cut. `delivered_at_ms` is this
+// window keeps that from wedging a run whose cut came back `busy` / `failed`, and a run that cannot
+// cut at all never reaches here — `can_cut_sync` keeps the trigger silent for it. `delivered_at_ms` is this
 // row's own last refusal, written by `fire_once` only when a refusal actually fired, so a passed
 // reissue does not move it.
 function decide(
@@ -213,8 +210,8 @@ function decide(
 	return !is_reissued_refusal(run.now_ms, delivered_at_ms)
 }
 
-// The row itself, so `delivered-rules.ts` spreads one entry. `decide` fires it per threshold crossing;
-// `keeps` is the implementation cut command, read from a `Bash` call the same
+// The row itself, so `delivered-rules.ts` spreads one entry. `decide` fires it per threshold crossing
+// in a run that can cut; `keeps` is the implementation cut command, read from a `Bash` call the same
 // way `pre-gate-cut`'s is.
 const ROW = {
 	id: 'implementation-cut',
@@ -222,6 +219,11 @@ const ROW = {
 	reason: IMPLEMENTATION_CUT_REASON,
 	decide,
 	keeps: bash_triggers.on_bash_command(takes_the_impl_cut),
+	// The opening the reason carried before it was cut to the action and the next command.
+	former_reasons: [
+		'⛔ implementation-phase cut: this checkout is a lane dispatched',
+		"⛔ implementation-phase cut: this run's context crossed the",
+	],
 }
 
 const implementation_cut = {

package/scripts/rules/index-guard.ts

@@ -51,13 +51,10 @@ function is_index_mutation(command: string): boolean {
 
 const INDEX_MUTATION_REASON =
 	'⛔ git index mutation: `git add` / `stage` / `commit` / `reset` / `rm` / `mv` and `git restore ' +
-	"--staged` overwrite the user's staged snapshot, which `CLAUDE.md` → Git Rules forbids on your own " +
-	'judgement (`prompts/collaboration-workflow/operating-rules.md` → "no-self-staging"). The ' +
-	'`.claude/settings.json` deny list matches prefix globs, so it misses `git -C . commit`, `git -c ' +
-	'k=v commit` and `env git commit`; this row reads the argv instead, so the spelling does not matter. ' +
-	'A commit goes through `pnpm josh git -y`; any other staging needs explicit current-turn user ' +
-	'instruction, run by the user in their own terminal. **This rule fires on every occurrence, not once ' +
-	'per run.**'
+	"--staged` overwrite the user's staged snapshot. Commit with `pnpm josh git -y`; any other staging " +
+	"is the user's, on explicit instruction. It fires on every occurrence " +
+	'(`prompts/collaboration-workflow/operating-rules.md` → ' +
+	'"no-self-staging").'
 
 const ROW = {
 	id: 'index-mutation',

package/scripts/rules/issue-comments.ts

@@ -89,21 +89,11 @@ function reads_issue_comments(command: string): boolean {
 // the fix. The label keeps `time_transcript_line.guard_from_refusal` naming this guard, not the command.
 const ISSUE_COMMENTS_REASON =
 	'⛔ issue comments: pnpm josh issue:read <N>\n' +
-	"Run that in place of this read: <N> is the Issue it names, and an Issue's comments are part of " +
-	'the Issue, so the body and every comment come back together. Without josh, add ' +
-	"`gh api repos/{owner}/{repo}/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, " +
-	"body}'` beside the body read, or `gh issue view <N> --comments` where GraphQL is reachable.\n" +
-	'Why: a decision recorded after the body was written lives only in a comment — a corrected ' +
-	'diagnosis (joshuafolkken/kit#1537), a changed default and an added acceptance criterion ' +
-	'(joshuafolkken/kit#1520), a scope handed to another Issue (joshuafolkken/kit#1304) — and ' +
-	'nothing in the body says it was superseded, so a body-only reader builds the wrong thing and ' +
-	'sees no contradiction. ' +
-	'Then the later text is the agreement in force — a comment supersedes the body it contradicts — ' +
-	"except for two answers that are not the run's to make: work a comment reassigns to another " +
-	'Issue is out of scope and is not implemented, and a comment saying the Issue no longer has a ' +
-	'reason to exist stops the run with a `confirmation` Telegram. The procedure is ' +
-	'`.claude/skills/workflow-commands/issue-comments.md`. ' +
-	'Every body-only read is refused until the comments are read.'
+	"Run that in place of this read — an Issue's comments are part of it, and a later comment " +
+	'supersedes the body it contradicts; refused until that command is on the transcript. Without ' +
+	'josh, read ' +
+	'`gh api repos/{owner}/{repo}/issues/<N>/comments` beside the body ' +
+	'(`.claude/skills/workflow-commands/issue-comments.md`).'
 
 // The enumeration row itself, so `delivered-rules.ts` spreads one entry. `already_satisfied` stands it
 // down once the comments are on the transcript tail, and until then it refuses every body-only read.

package/scripts/rules/josh-git-bare.ts

@@ -52,12 +52,9 @@ function is_bare_josh_git(command: string): boolean {
 // sibling reasons do.
 const JOSH_GIT_BARE_REASON =
 	'⛔ bare `pnpm josh git`: this prompts to confirm the staging, and with no TTY the prompt falls to ' +
-	'its cancel branch — `Checking unstaged files... Found` then `Operation cancelled.` — so the call ' +
-	'throws away the time it takes to fail (about 31 seconds in one measured lane) and you reissue it ' +
-	'with `-y` anyway (joshuafolkken/kit#2297). Run it unattended from the start: ' +
-	'`pnpm josh git -y "<title> #<N>"`. The recovery form that opens the PR for a push that already ' +
-	'landed is `pnpm josh git -y --skip-commit --skip-push`. This rule fires on every occurrence, not ' +
-	'once per run.'
+	'its cancel branch. Run `pnpm josh git -y "<title> #<N>"`, or ' +
+	'`pnpm josh git -y --skip-commit --skip-push` to open the PR for a push that already landed. It ' +
+	'fires on every occurrence.'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. `is_trigger` reads the input through
 // `on_bash_command` — the `Bash` tool-name gate every command row shares — and `decide` returns true so

package/scripts/rules/lane-background.ts

@@ -109,9 +109,9 @@ function foreground_input(
 	call: GuardedCall,
 	is_lane_child: () => boolean = () => lane_child_marker.is_child_of(process.cwd()),
 ): Record<string, unknown> | undefined {
-	if (!is_backgrounded_ship(call) || !json_value.is_record(call.input)) return undefined
-
-	if (!is_lane_child()) return undefined
+	if (!is_backgrounded_ship(call) || !json_value.is_record(call.input) || !is_lane_child()) {
+		return undefined
+	}
 
 	return { ...call.input, [BACKGROUND_KEY]: false, [TIMEOUT_KEY]: FOREGROUND_TIMEOUT_MS }
 }
@@ -119,7 +119,7 @@ function foreground_input(
 const FOREGROUND_NOTE =
 	'lane background: this lane child backgrounded `josh ship`, which would die with the headless turn ' +
 	'before its supervisor exists — so it was run in the foreground instead, where it detaches itself ' +
-	'after the preflight. End the turn on `launched` / `busy` (joshuafolkken/kit#3154).'
+	'after the preflight. End the turn on `launched` / `busy`.'
 
 // The launches `launched_ids` reads off the transcript tail that never saw their finish. A launch is
 // read off its own tool result and a finish off the harness notice, both by `time_transcript_line`.
@@ -149,26 +149,15 @@ function pending_agent_ids(tail: string): ReadonlyArray<string> {
 
 const LANE_BACKGROUND_REASON =
 	'⛔ lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless ' +
-	'`claude -p` process whose background Bash tasks are killed when the turn ends — so a backgrounded ' +
-	'`josh gate` / `josh git` / `josh followup` / `josh ship` never re-invokes you; it dies at `exit code ' +
-	'143` (joshuafolkken/kit#2704, measured on the #2606 child: implementation, review and live ' +
-	'verification done, the run parked instead of merged). Hand the gate-to-merge region to the detached ' +
-	'supervisor instead: `pnpm josh ship --detach --review "<title> #<N>"` (add `--cite <N>`) issued in ' +
-	'the foreground — its preflight runs in this process before the supervisor exists, so a backgrounded ' +
-	'`ship` dies with the turn (joshuafolkken/kit#3027; a backgrounded `ship` issued alone is moved to ' +
-	'the foreground for you, joshuafolkken/kit#3154) — then end the turn on `launched` / `busy`. ' +
-	'`.claude/skills/workflow-commands/chain-rule.md` step 0 is the single source. A ' +
-	'single check you must read before continuing runs in the foreground within the tool timeout; the ' +
-	'commit-push step does not — in a child it too belongs to the detached ship, in either spelling. This ' +
-	'rule fires on every occurrence, not once per run.'
+	'process whose background tasks die when the turn ends. Hand over to ' +
+	'`pnpm josh ship --detach --review "<title> #<N>"`, issued in the foreground, then end the turn on ' +
+	'`launched` / `busy`. It fires on every occurrence ' +
+	'(`.claude/skills/workflow-commands/chain-rule.md` step 0).'
 
 const LANE_BACKGROUND_STOP_REASON =
 	'⛔ lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task ' +
-	'it launched has not finished — ending this headless turn kills it, and nothing re-invokes you ' +
-	'afterwards (joshuafolkken/kit#2704). Do not send a notification and do not stop: wait for the task ' +
-	'in the foreground and act on its result, or re-issue the work through `pnpm josh ship --detach`, ' +
-	'whose supervisor outlives the turn (`.claude/skills/workflow-commands/chain-rule.md` step 0). Do ' +
-	'not repeat your previous reply.'
+	'it launched has not finished, and ending this turn kills it. Wait for it in the foreground, or ' +
+	're-issue the work through `pnpm josh ship --detach` — do not notify, stop or repeat your reply.'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. It fires on every occurrence (`decide`
 // returns true): a child must never background these, so the route is always the detached ship, never

package/scripts/rules/lane-carry-conflict.ts

@@ -89,25 +89,15 @@ function is_carry_conflict(
 }
 
 // The instruction in the shape a refusal can carry: what the child cannot do, why the record is not a
-// conflict, and the mechanical branch to take instead — continue, never park or ask. **The procedure
-// is named, not restated** — its single sources are `pre-gate-cut.md` and `backlogrun-progress.md` →
-// "The hand-off", and a second copy here would be the clone `CLAUDE.md` prohibits. Apostrophes are
-// avoided so the single-quoted literal needs no escaping, as the sibling reasons do.
+// conflict, and the mechanical branch to take instead — continue, never park or ask. Its history is
+// `docs/maintainers/rule-delivery-rationale.md` → "Why a refusal is the action and the next command".
+// Apostrophes are avoided so the single-quoted literal needs no escaping, as the sibling reasons do.
 const LANE_CARRY_CONFLICT_REASON =
 	'⛔ lane child carry conflict: this session is a dispatched lane child, and ' +
-	'`pnpm josh run:merge` / `pnpm josh run:carry` are the parent backlogrun budget commands — a child ' +
-	'must never run them. The live carry record here belongs to the parent that launched this child, ' +
-	'not to a competing run: the parent holds the one run budget for the repository, and every lane ' +
-	'shares the common git directory it is keyed on, so a live owner a lane child reads is always its ' +
-	'parent (joshuafolkken/kit#2267, measured 2026-09-21 in backlogrun #2252 — a child read run:merge ' +
-	'`busy` as a competitor and parked #2258 unimplemented). Do not run this command, and do not treat ' +
-	'it as a conflict: no `needs-decision`, no `confirmation` Telegram, no question to a person — a ' +
-	'dispatched child cannot ask, and there is nothing to decide. Continue implementing this Issue; the ' +
-	'parent owns the budget and counts the outcome at the return. The procedure is ' +
-	'`.claude/skills/workflow-commands/pre-gate-cut.md` and `backlogrun-progress.md` → "The hand-off". ' +
-	'Live evidence of `run:carry` is taken with a fresh `JOSH_TEMP_ROOT` prefixed to the call, which this ' +
-	'rule lets through (joshuafolkken/kit#3458); `run:merge` is refused under any root, because it also ' +
-	'syncs main, closes lanes and writes to GitHub. This rule fires on every occurrence, not once per run.'
+	'`run:merge` / `run:carry` are the parent budget commands; the live record belongs to the parent, ' +
+	'not to a competing run. Continue implementing this Issue: no `needs-decision`, no Telegram. ' +
+	'Live `run:carry` evidence takes a fresh `JOSH_TEMP_ROOT`; `run:merge` is refused under any root, ' +
+	'on every occurrence.'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. `is_trigger` reads the input through
 // `on_bash_command` — the `Bash` tool-name gate every command row shares — and `decide` returns true

package/scripts/rules/lane-interactive-ask.ts

@@ -41,17 +41,12 @@ function is_interactive_ask(
 // `backlogrun-park.md` → "park and continue", and a second copy here would be the clone `CLAUDE.md`
 // prohibits. The one command is spelled so the child is not left to reconstruct it from a doc read.
 const LANE_INTERACTIVE_ASK_REASON =
-	'⛔ lane child interactive ask: this session is a dispatched lane child and cannot ask a person, so ' +
-	'this call is refused. Left to run it would end the turn with nothing on the Issue — the parent then ' +
-	'finds an OPEN Issue with `in-progress` and no question (joshuafolkken/kit#2201; joshuafolkken/kit#2034 ' +
-	'placed the same rule one tool-call too late). Do not ask: park the decision instead. Apply ' +
-	'`needs-decision` and post a comment carrying the question, the options and whether work was stashed — ' +
-	"`gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'` then " +
-	'`pnpm josh issue:comment <N> --body-file <path>` — then send the ' +
-	'`confirmation` Telegram and stop. The procedure is ' +
-	'`.claude/skills/workflow-commands/pre-gate-cut.md` → "A lane child records its park before it stops", ' +
-	'and the park itself is `backlogrun-park.md` → "park and continue". This rule fires on every ' +
-	'occurrence, not once per run.'
+	'⛔ lane child interactive ask: this session is a dispatched lane child and cannot ask a ' +
+	'person, so park instead: ' +
+	"`gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'`, " +
+	'`pnpm josh issue:comment <N> --body-file <path>`, ' +
+	'the `confirmation` Telegram, stop. It fires on every occurrence ' +
+	'(`.claude/skills/workflow-commands/pre-gate-cut.md`, `backlogrun-park.md`).'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. `decide` returns true so it refuses every
 // occurrence; it declares no `keeps` — not asking is the absence of a call, not a call, so the row is

package/scripts/rules/lane-park.ts

@@ -108,19 +108,11 @@ function records_the_park(command: string): boolean {
 // single source is `backlogrun-park.md` → "park and continue", and a second copy here would be the
 // clone `CLAUDE.md` prohibits.
 const LANE_PARK_REASON =
-	'⛔ lane child park: this session is a dispatched lane child, and a stop that waits on a person must ' +
-	'leave the question on the Issue before it sends this Telegram — otherwise the parent finds an OPEN ' +
-	'Issue with `in-progress` and no question, and a person cannot tell what to answer ' +
-	'(joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows ' +
-	'the question, the options and whether it stashed, so it records the park itself rather than leaving ' +
-	'the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a ' +
-	'comment carrying the question, the options, and whether work was stashed — ' +
-	"`gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'` then " +
-	'`pnpm josh issue:comment <N> --body-file <path>`. If this stop is a ' +
-	'`needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing ' +
-	'to add. Then reissue this notify — it fires once per run and cannot repeat on the call in hand. The ' +
-	'procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` → "A lane child records its park ' +
-	'before it stops", and the park itself is `backlogrun-park.md` → "park and continue".'
+	'⛔ lane child park: this session is a dispatched lane child, so a stop for a person parks first: ' +
+	"`gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'`; " +
+	'`pnpm josh issue:comment <N> --body-file <path>` (question, options, stash); a ' +
+	'`needs-human-review` / `already-done` stop already is. Reissue this notify, once per run ' +
+	'(`.claude/skills/workflow-commands/pre-gate-cut.md`).'
 
 // The row itself, so `delivered-rules.ts` spreads one entry. **Once per run rather than `decide`, and
 // no `already_satisfied`.** The stop ends the turn, so it is not the recurring act `decide` is for. It carries no `already_satisfied` because the park it asks for is a GitHub label a

package/scripts/rules/lane-split-park.ts

@@ -101,13 +101,8 @@ function decide(_call: unknown, run: GuardRun): boolean {
 
 const LANE_SPLIT_PARK_REASON =
 	'⛔ lane split park: this session is a dispatched lane child that promoted its own Issue to an epic ' +
-	'this run, and a split is not a park — do not apply `needs-decision` to the promoted epic and do not ' +
-	'send a `confirmation` Telegram. The parent reads an open Issue carrying `epic` as a split and ' +
-	'continues through its children; a question here has nobody to answer it (joshuafolkken/kit#3296, ' +
-	'measured 2026-10-06 when the child for #3255 parked its promoted epic). If what remains of the ' +
-	'original work needs a person, park that child issue instead, then end the turn. The procedure is ' +
-	'`.claude/skills/workflow-commands/backlogrun-park.md` → "Splitting a child mid-run". This rule fires ' +
-	'on every occurrence, not once per run.'
+	'this run, and a split is not a park: no `needs-decision` on the epic, no `confirmation` Telegram, ' +
+	'on every occurrence. Park a child issue if the rest needs a person, else end the turn (`.claude/skills/workflow-commands/backlogrun-park.md` → "Splitting a child mid-run").'
 
 // It declares no `keeps`: not parking is the absence of a call, so the row is reported unmeasured
 // rather than scored on an act that does not exist (`lane-carry-conflict.ts`).