@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/scripts/rules/issue-comments.ts

@@ -1,3 +1,7 @@
+import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
+import { json_value } from '#scripts/lib/json-value'
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+import { time_shell } from '#scripts/time-runtime/time-shell'
 import { bash_triggers } from './bash-triggers'
 import { gh_api } from './gh-api'
 import { prior_comment_read } from './prior-comment-read'
@@ -77,6 +81,9 @@ function reads_issue_comments(command: string): boolean {
 	return shell_segments.segments_of(command).some((segment) => fetches_issue_comments(segment))
 }
 
+const RULE_DOC = '`.claude/skills/workflow-commands/issue-comments.md`'
+const COMMENTS_FALLBACK = 'gh api repos/{owner}/{repo}/issues/<N>/comments'
+
 // **The refusal hands over the command that fixes it**, because reading is not the same as
 // obeying: a sentence saying "also read the comments" is prose that moves nothing, while a refused
 // body read leaves the run holding the reissue that makes the comments *present*. The conflict rule
@@ -88,22 +95,62 @@ function reads_issue_comments(command: string): boolean {
 // being the Issue the refused call named — so a run that reads only the opening still leaves holding
 // 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.'
+	`⛔ issue comments: pnpm josh issue:read <N>\n` +
+	`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 \`${COMMENTS_FALLBACK}\` beside the body (${RULE_DOC}).`
+
+// **A `gh api` body read is rewritten rather than refused** (joshuafolkken/kit#3920): the fix is the
+// same Issue's comments endpoint, read on the same line, and the path the call already names is all
+// it needs. Prepended on lines of their own, so a trailing comment or a `&&` chain on the typed line
+// cannot swallow or skip them, and the typed line stays last — its exit status is still the call's.
+// A `gh issue view` read is left to the refusal — its global flags (`--repo`) and its `--json`
+// projection have no one comments spelling to add.
+const COMMENTS_JQ = String.raw`'.[] | "— \(.user.login) \(.created_at)\n\(.body)\n"'`
+
+const COMMENTS_NOTE =
+	"↻ issue comments: this read returned only the Issue's body, so the Issue's comments were fetched " +
+	`on the same line — a later comment supersedes the body it contradicts (${RULE_DOC}).`
+
+// **Only a line that opens with the body read is rewritten.** Prepended ahead of a `cd` or a
+// subshell, the comments read would resolve `{owner}/{repo}` in another directory and print another
+// repository's comments; and the line is cut on its quote-blanked reading, so a body-read spelling
+// quoted in a string or a heredoc body is never prepended as a real call. Every other line keeps the
+// refusal.
+function rewritable_path(command: string): string | undefined {
+	const read = shell_segments.first_of(command)
+
+	if (read === undefined || ISSUE_VIEW_COMMAND.test(read)) return undefined
+
+	return is_body_read_segment(read) ? ISSUE_BODY_PATH.exec(read)?.[0] : undefined
+}
+
+function comments_command(command: string): string | undefined {
+	if (!is_body_only_issue_read(command)) return undefined
+
+	const path = rewritable_path(command)
+
+	if (path === undefined) return undefined
+
+	return `gh api --paginate ${path}/comments --jq ${COMMENTS_JQ}\n${command}`
+}
+
+// The call's input with the comments read prepended, or `undefined` where the comments are already on
+// the tail or the read has no rewritable spelling.
+function comments_input(
+	call: GuardedCall,
+	tail: () => string,
+): Record<string, unknown> | undefined {
+	if (call.name !== cost_blocks.BASH_TOOL || !json_value.is_record(call.input)) return undefined
+
+	const command = comments_command(time_shell.bash_command(call.input))
+
+	if (command === undefined || prior_comment_read.already_read_for_call(tail(), call)) {
+		return undefined
+	}
+
+	return { ...call.input, command }
+}
 
 // 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.
@@ -113,13 +160,17 @@ const ROW = {
 	reason: ISSUE_COMMENTS_REASON,
 	already_satisfied: prior_comment_read.already_read_for_call,
 	keeps: bash_triggers.on_bash_command(reads_issue_comments),
+	rewrite: comments_input,
+	rewrite_note: COMMENTS_NOTE,
 	// The opening the reason carried before it led with the command.
 	former_reasons: ["⛔ an Issue's comments are part of the Issue: read them before implementing"],
 }
 
 const issue_comments = {
+	COMMENTS_NOTE,
 	ISSUE_COMMENTS_REASON,
 	ROW,
+	comments_input,
 	is_body_only_issue_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`).

package/scripts/rules/lane-switch-main.ts

@@ -61,8 +61,12 @@ const FLAG_PREFIX = '-'
 function switch_target(segment: string): string | undefined {
 	const call = git_argv.parse(segment)
 
-	if (call?.subcommand !== SWITCH_SUBCOMMAND) return undefined
-	if (call.args.some((argument) => NON_COLLIDING_FLAGS.has(argument))) return undefined
+	if (
+		call?.subcommand !== SWITCH_SUBCOMMAND ||
+		call.args.some((argument) => NON_COLLIDING_FLAGS.has(argument))
+	) {
+		return undefined
+	}
 
 	return call.args.find((argument) => !argument.startsWith(FLAG_PREFIX))
 }
@@ -103,16 +107,9 @@ function is_switch_away_from_lane(
 // prohibits. Apostrophes are avoided so the single-quoted literal needs no escaping, as the siblings do.
 const LANE_SWITCH_MAIN_REASON =
 	'⛔ lane child on `git switch main`: this session is a dispatched lane child, and switching to the ' +
-	'default branch here always fails — a lane is a linked work tree, the primary checkout holds the ' +
-	'default branch, and git allows one branch in one work tree at a time (`fatal: main is already used ' +
-	'by worktree at <the primary checkout>`, measured 11 times in the 2026-09-21 backlogrun). Do not ' +
-	'switch: the lane is already on its own issue branch, branched from a fresh default before it opened, ' +
-	'and the latest default is brought in during the gate by `pnpm josh main:merge`. So skip this step ' +
-	'and keep implementing on the current branch — no `git switch`, no `git pull`. `pnpm josh main:sync` ' +
-	'(`josh ms`) is refused in a lane for the same reason, and a lane is finished with `pnpm josh ' +
-	'lane:close <issue-number>`. The parent runs `pnpm josh ms` in the primary checkout ' +
-	'before each lane opens, never the child — `backlogrun-lanes.md` and `backlogrun-child.md` are the ' +
-	'single sources. This rule fires on every occurrence, not once per run.'
+	'default branch here always fails (`already used by worktree`: the primary checkout holds it). Skip ' +
+	'this step and keep implementing on the current branch; `pnpm josh main:merge` brings the default ' +
+	'in during the gate. Refused on every occurrence (`backlogrun-lanes.md`, `backlogrun-child.md`).'
 
 // 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/last-prompt.ts

@@ -30,10 +30,13 @@ const KEYWORD_BEFORE_ARGUMENT = -2
 
 const PROMPT_LINE_SCHEMA = z.object({
 	isMeta: z.boolean().nullish(),
+	timestamp: z.string().nullish(),
 	origin: z.object({ kind: z.string().nullish() }).nullish(),
 	message: z.object({ content: z.unknown() }),
 })
 
+const TIMED_LINE_SCHEMA = z.object({ timestamp: z.string() })
+
 type PromptLine = z.infer<typeof PROMPT_LINE_SCHEMA>
 
 function is_person(line: PromptLine): boolean {
@@ -42,13 +45,20 @@ function is_person(line: PromptLine): boolean {
 	return line.origin === null || line.origin === undefined || line.origin.kind === HUMAN_ORIGIN
 }
 
-// The prompt line's text, or `undefined` when the harness wrote it or it does not read as one.
-function person_text(line: string): string | undefined {
+// The prompt line as the person wrote it, or `undefined` when the harness wrote it or it does not
+// read as one.
+function person_line(line: string): PromptLine | undefined {
 	const parsed = PROMPT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line))
 
-	if (!parsed.success || !is_person(parsed.data)) return undefined
+	return parsed.success && is_person(parsed.data) ? parsed.data : undefined
+}
 
-	return time_reported_failure.result_text(parsed.data.message.content)
+// The prompt line's text, or `undefined` when the harness wrote it or it does not read as one.
+function person_text(line: string): string | undefined {
+	const person = person_line(line)
+	if (person === undefined) return undefined
+
+	return time_reported_failure.result_text(person.message.content)
 }
 
 // A keyword opening the prompt is what a person types; a keyword before its one trailing argument is a
@@ -75,6 +85,41 @@ function prompt_text(tail: string): string {
 	return text === undefined || is_invocation(text) ? NO_PROMPT : text
 }
 
-const last_prompt = { prompt_text }
+// **The prompt that opened this turn, when a person typed it** — '' when the harness opened it (a task
+// notification, a subagent's hand-back), so a question asked turns ago does not answer for a stop the
+// run reached on its own since (`stop-decision.ts` → `is_question`).
+function turn_prompt(tail: string): string {
+	const opener = tail.split('\n').findLast((line) => filing_cap.is_prompt_line(line))
+	if (opener === undefined) return NO_PROMPT
+
+	return person_text(opener) ?? NO_PROMPT
+}
+
+// When the person last prompted on the tail, or `undefined` when no prompt of theirs is on it.
+function prompt_time(tail: string): string | undefined {
+	return tail
+		.split('\n')
+		.filter((line) => filing_cap.is_prompt_line(line))
+		.map((line) => person_line(line)?.timestamp ?? undefined)
+		.findLast((time) => time !== undefined)
+}
+
+// The first dated line on the tail, or `undefined` when none is.
+function tail_time(tail: string): string | undefined {
+	return tail
+		.split('\n')
+		.map((line) => TIMED_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line)).data?.timestamp)
+		.find((time) => time !== undefined)
+}
+
+// **When the current pause began, as far as the tail shows** — what a recorded notify is compared
+// against. A person's prompt ends the pause it reported, so the last one opens the next; with none on
+// the tail, only a send dated inside the tail is provably after every prompt, and an older send is
+// announced again (joshuafolkken/kit#3961).
+function pause_start(tail: string): string | undefined {
+	return prompt_time(tail) ?? tail_time(tail)
+}
+
+const last_prompt = { pause_start, prompt_text, turn_prompt }
 
 export { last_prompt }

package/scripts/rules/oracle-consulted.ts

@@ -48,11 +48,10 @@ function command_line(oracle: Oracle): string {
 // the single source of the procedure.
 function reason_for(oracle: Oracle, firing_point: FiringPoint): string {
 	return (
-		`⛔ decision oracle not consulted: this is ${firing_point.describes}, but the run has not run ` +
-		`\`${command_line(oracle)}\` first — the oracle that decides ${oracle.decision.toLowerCase()}. ` +
-		`It answers ${oracle.vocabulary.join(' | ')}; single source ${oracle.single_source}. Reissue ` +
-		`after running it and reading its verdict. Every such call is refused until that command is on ` +
-		`the transcript.`
+		`⛔ decision oracle not consulted: this is ${firing_point.describes}. Run ` +
+		`\`${command_line(oracle)}\` first — it decides ${oracle.decision.toLowerCase()} and answers ` +
+		`${oracle.vocabulary.join(' | ')} (${oracle.single_source}). Every such call is refused until ` +
+		`that command is on the transcript.`
 	)
 }
 

package/scripts/rules/oracle-list-cli.ts

@@ -12,6 +12,10 @@ import { oracle_firing } from './oracle-firing'
 const ARGV_OFFSET = 2
 const INDENT = '  '
 const FIELD_WIDTH = 10
+// The rule-prose guard sends a rule author here first, so the list closes on the placement order a new
+// rule is weighed against before it becomes a guard or a document line.
+const AUTOMATION_ORDER =
+	'automate first: a command > a hook that runs it > a refusal guard > a document — a lower rung states why the higher cannot hold (`principles.md` → "automate-first"; a guard\'s `why` is `scripts/rules/guard-remedy.ts`)'
 
 function pad_field(label: string): string {
 	return label.padEnd(FIELD_WIDTH)
@@ -51,6 +55,8 @@ function print_list(): void {
 	for (const oracle of decision_oracle.DECISION_ORACLES) {
 		console.info(format_oracle(oracle))
 	}
+
+	console.info(AUTOMATION_ORDER)
 }
 
 function run(argv: ReadonlyArray<string>): number {
@@ -70,6 +76,7 @@ function main(argv: ReadonlyArray<string>): void {
 }
 
 const oracle_list_cli = {
+	AUTOMATION_ORDER,
 	print_list,
 }