@joshuafolkken/kit 1.1166.0 → 1.1229.0

package/scripts/test/test-red-logic.ts

@@ -1,4 +1,5 @@
 import { issue_bug_label } from '#scripts/issue/issue-bug-label'
+import { observation_ledger } from '#scripts/observations/observation-ledger'
 import { z } from 'zod'
 import { test_declared_logic } from './test-declared-logic'
 
@@ -11,7 +12,7 @@ import { test_declared_logic } from './test-declared-logic'
 // that test catches anything — the added and changed tests run against the merge-base, and at least one
 // of them has to fail there.
 
-type RedVerdict = 'red' | 'green' | 'no-test'
+type RedVerdict = 'red' | 'green' | 'no-test' | 'test-only'
 
 // The declaration a bug-fix Issue carries under its background heading, in the same slot as the
 // behavior-change declaration (`behavior-change-lint.ts`). Read from the declaration, never inferred,
@@ -33,6 +34,18 @@ function unit_test_files(paths: ReadonlyArray<string>): Array<string> {
 		.filter((path) => test_declared_logic.is_test_file(path) && path.endsWith(UNIT_TEST_SUFFIX))
 }
 
+// **A change whose every path is a test file has no pre-fix code to run against**
+// (joshuafolkken/kit#3214). The merge-base then runs the same code as HEAD, so its result equals HEAD's
+// and says nothing about the fix. Exempt paths do not count: a document-rule test reads `*.md` and
+// `prompts/` files, so a change to one of those is pre-fix content the test can be red against.
+// Observation ledger paths do not count either way (joshuafolkken/kit#3230): a run commits its own
+// ledger entry, and no test reads it as pre-fix content.
+function is_test_only(paths: ReadonlyArray<string>): boolean {
+	const counted = paths.filter((path) => !observation_ledger.is_ledger_path(path))
+
+	return counted.length > 0 && counted.every((path) => test_declared_logic.is_test_file(path))
+}
+
 // Vitest's JSON report carries one `testResults` entry per file it loaded — a file that failed to load
 // included — and none for a file its config excluded, so this is how many files actually ran. The
 // changed-path count cannot stand in for it: a file the merge-base config does not include runs nothing
@@ -58,7 +71,8 @@ function verdict_for(test_count: number, is_failed: boolean): RedVerdict {
 }
 
 // Only `green` on a declared bug fix is refused. `no-test` is already `josh test:declared`'s refusal
-// when a runtime file changed, and a declared fix that touched only docs has nothing to reproduce.
+// when a runtime file changed, a declared fix that touched only docs has nothing to reproduce, and a
+// `test-only` fix runs the same code on the merge-base as on HEAD.
 function is_refused(body: string, verdict: RedVerdict): boolean {
 	return verdict === 'green' && is_bug_fix(body)
 }
@@ -67,6 +81,7 @@ const test_red_logic = {
 	BUG_DECLARATION_LINE,
 	is_bug_fix,
 	is_refused,
+	is_test_only,
 	ran_file_count,
 	unit_test_files,
 	verdict_for,

package/scripts/test/test-red.ts

@@ -11,7 +11,7 @@ import { execa } from 'execa'
 import { test_red_logic, type RedVerdict } from './test-red-logic'
 
 // `josh test:red` — run the added and changed Vitest files against the pre-fix tree and print `red`,
-// `green` or `no-test` (joshuafolkken/kit#2448).
+// `green`, `no-test` or `test-only` (joshuafolkken/kit#2448).
 //
 // **The pre-fix tree is a detached worktree at the merge-base, never the caller's checkout.** The tests
 // are copied in from the working tree, so what runs is the new test against the old code, and the
@@ -26,7 +26,7 @@ const REPORT_NAME = 'report.json'
 const NODE_MODULES = 'node_modules'
 const VITEST_BIN = path.join(NODE_MODULES, '.bin', 'vitest')
 const USAGE =
-	'Usage: josh test:red — prints red / green / no-test for the changed tests on the merge-base'
+	'Usage: josh test:red — prints red / green / no-test / test-only for the changed tests on the merge-base'
 
 interface RedRun {
 	verdict: RedVerdict
@@ -34,9 +34,7 @@ interface RedRun {
 }
 
 // The changed Vitest files that still exist — a deleted test has nothing to run.
-async function changed_tests(): Promise<Array<string>> {
-	const paths = await changed_paths.read_changed_paths(false)
-
+function changed_tests(paths: ReadonlyArray<string>): Array<string> {
 	return test_red_logic.unit_test_files(paths).filter((file) => existsSync(file))
 }
 
@@ -126,12 +124,15 @@ async function verdict_on(base: string, files: ReadonlyArray<string>): Promise<R
 }
 
 // The verdict over the current checkout. No merge-base (not a repository, no default branch) reads as
-// `no-test` — there is no pre-fix tree to run against, and a guard fails open.
+// `no-test` — there is no pre-fix tree to run against, and a guard fails open. A change whose every path
+// is a test file is `test-only` without a run: the merge-base runs the same code as HEAD.
 async function run(): Promise<RedRun> {
 	const base = await change_base.resolved()
-	const files = await changed_tests()
+	const paths = await changed_paths.read_changed_paths(false)
+	const files = changed_tests(paths)
 
 	if (base === undefined || files.length === 0) return { verdict: 'no-test', files }
+	if (test_red_logic.is_test_only(paths)) return { verdict: 'test-only', files }
 
 	return { verdict: await verdict_on(base, files), files }
 }

package/scripts/test/unit-worker-share.ts

@@ -227,6 +227,7 @@ async function with_run_marker<T>(run: () => Promise<T>): Promise<T> {
 const unit_worker_share = {
 	MIN_WORKERS,
 	NESTED_KEY,
+	NESTED_VALUE,
 	RUN_PREFIX,
 	SOLO_RUNS,
 	current_share,

package/scripts/time-runtime/time-background.ts

@@ -49,7 +49,11 @@ const NO_FINISH = 0
 
 // The launch's own result body, which is the only place the harness writes the id it assigns. Read
 // as a derived fact and the body discarded, exactly as `has_failure_line` and `followup_stages` are.
-const LAUNCH_PATTERN = /running in background with ID:\s*([\w-]+)/iu
+// **A foreground call that outran its timeout is a launch too** (joshuafolkken/kit#3304): the harness
+// moves it to the background and says so as `moved to the background (ID: <id>)`. Missing that spelling
+// let the #3273 lane child end its turn on a running task the stop hook never saw.
+const LAUNCH_PATTERN =
+	/(?:running in background with ID:|moved to the background \(ID:)\s*([\w-]+)/iu
 // A backgrounded subagent's launch result, which names its id on an `agentId:` line of its own.
 const AGENT_LAUNCH_PATTERN = /^Async agent launched[\s\S]*?\bagentId:\s*([\w-]+)/u
 // The notice the harness writes when a task it took into the background ends

package/scripts/time-runtime/time-instant.ts

@@ -10,7 +10,9 @@
 // clone `CLAUDE.md` prohibits, and the two copies would disagree the first time one of them learned
 // to accept another format.
 function parse_instant(raw: string | null | undefined): number | undefined {
-	const parsed = Date.parse(raw ?? '')
+	if (raw === null || raw === undefined) return undefined
+
+	const parsed = Date.parse(raw)
 
 	return Number.isNaN(parsed) ? undefined : parsed
 }

package/scripts/time-runtime/time-spans.ts

@@ -1,16 +1,14 @@
 import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
 import type { FollowupStage } from '#scripts/followup/git-followup-stages'
 import { time_background } from './time-background'
-import { time_bundle_call } from './time-bundle-call'
 import { time_followup_stage } from './time-followup-stage'
-import { time_markers, type PhaseMarker } from './time-markers'
 import { time_reported_failure } from './time-reported-failure'
 import { time_shell } from './time-shell'
-import { time_single_check } from './time-single-check'
+import { time_tool_call, type ToolCall } from './time-tool-call'
 import { time_transcript_line, type Block, type TranscriptLine } from './time-transcript-line'
-import { time_writes } from './time-writes'
 
 const { NO_MESSAGE_ID, parse_line } = time_transcript_line
+const { NO_CALL, UNKNOWN_CALL, UNKNOWN_TOOL, to_tool_call } = time_tool_call
 
 // Turning a session transcript into timed spans (joshuafolkken/kit#1267).
 //
@@ -24,6 +22,10 @@ const { NO_MESSAGE_ID, parse_line } = time_transcript_line
 // the move changed no call site. `cost_blocks`' three type constants are still imported rather than
 // restated.
 //
+// **Reading a `tool_use` block into a `ToolCall` is `time-tool-call.ts`'s** since
+// joshuafolkken/kit#3264, when this file reached its length limit again. `UNKNOWN_TOOL` and
+// `to_tool_call` are re-exported below, so that move changed no call site either.
+//
 // **The partition is by gap, not by pair.** Every span is the interval between two consecutive
 // events, classified by the *later* one: a span ending at an assistant line is model wait, one
 // ending at a tool result is that tool's execution, one ending at a user prompt is human wait.
@@ -34,7 +36,6 @@ const { NO_MESSAGE_ID, parse_line } = time_transcript_line
 
 const ASSISTANT_TYPE = 'assistant'
 const USER_TYPE = 'user'
-const UNKNOWN_TOOL = 'unknown'
 
 type SpanCategory = 'model' | 'tool' | 'human'
 
@@ -90,96 +91,6 @@ const NO_RESULT: ResultFacts = {
 	followup_stages: time_followup_stage.NO_STAGES,
 }
 
-// What a tool span is labelled with. `josh_command` is empty for everything that is not a
-// `pnpm josh <cmd>` invocation, and the report drops empty labels rather than printing a bucket.
-//
-// `marker` names the workflow boundary the call is, for the phase breakdown that slices the same
-// spans by stage (joshuafolkken/kit#1269). It is carried here rather than re-derived later because
-// the tool's *input* is what decides it, and a span keeps no input — only the label read off it.
-//
-// `is_bundleable` and `targets` are carried for exactly that reason too (joshuafolkken/kit#1344).
-// Whether a call could have gone out beside another, and what it names, are both read off the input —
-// so a module asking about them after the fact would have nothing to read. `time-bundle-call.ts`
-// decides both; the rule each one follows is stated there.
-//
-// `check_key` is the fourth, and the third time this reason has applied (joshuafolkken/kit#1383). Two
-// runs of one verification check are the same call only if they named the same files, and the files
-// are in the input — so `josh_command` alone cannot say, and nothing downstream could recover it.
-// `time-single-check.ts` decides it.
-//
-// `message_id` is the fifth, and it is the one that says which *turn* a call belongs to
-// (joshuafolkken/kit#1406). It is read off the line the `tool_use` block sat on rather than off the
-// result that closes the span, because a `tool_result` line carries no message id at all — so a span
-// that did not keep it here could never be attributed to the turn that issued it.
-//
-// `writes` is the sixth, and it is what `targets` could not say (joshuafolkken/kit#1472). `targets`
-// names what a call mentioned; `marker` says a call was *an* edit but not of what, and for a tool
-// outside `BUNDLEABLE_TOOLS` it arrived with no target at all. So a consumer subtracting edits from
-// reads — `investigation-reads.ts` — had nothing to subtract for `MultiEdit` / `NotebookEdit`, and
-// nothing at all to tell an in-place `sed -i` from the `sed -n` it shares a label with.
-// `time-writes.ts` decides it, from the input this span is about to discard.
-// `issue` is the seventh, and it is the one `branch` could not carry (joshuafolkken/kit#1617). Under
-// lanes the session writing the transcript stays on the default branch while the work runs in a linked
-// work tree, so `branch` names no issue on any line of the run; the `in-progress` label call does, and
-// like every field above it that answer is read off the *input* a span is about to discard.
-// `time_markers.NO_ISSUE` for every call that declares nothing, which is all but one call per run.
-interface ToolCall {
-	label: string
-	josh_command: string
-	// Every josh subcommand the call ran, where `josh_command` is only the first (joshuafolkken/kit#1883).
-	// A chained `pnpm josh lint:related && pnpm josh test:related` carries both; the count tables expand
-	// it so the ones `josh_command` drops are still counted.
-	josh_commands: ReadonlyArray<string>
-	check_key: string
-	marker: PhaseMarker
-	is_bundleable: boolean
-	targets: ReadonlyArray<string>
-	// Carried beside `targets` because sharing a target means something different depending on it: a
-	// second write to one file is independent work, a read of a file just written is not
-	// (joshuafolkken/kit#1509).
-	is_writing: boolean
-	// The conservative write answer `is_read_only_call` asks of a live call, carried so a reader of the
-	// transcript asks the same read-only question as the guard (joshuafolkken/kit#3139).
-	may_write: boolean
-	// Whether this is a subagent launch whose prompt builds on an earlier launch's finding
-	// (joshuafolkken/kit#1854). Carried for the reason every field here is — the prompt it is read from
-	// is the input, and a span keeps none. `time-agent-bundles.ts` reads it.
-	has_prior_reference: boolean
-	writes: ReadonlyArray<string>
-	message_id: string
-	issue: number
-	// The background run this call reads the output of, and `''` for every other call
-	// (joshuafolkken/kit#1662). It is the eighth field carried for the reason the seven above are:
-	// the id sits in the command string, which a span does not keep, and it is the only thing that
-	// says a `tail` two turns later is the join of a command started minutes ago.
-	reads_background: string
-}
-
-const NO_CALL: ToolCall = {
-	label: '',
-	josh_command: '',
-	josh_commands: [],
-	check_key: time_single_check.NO_CHECK,
-	marker: time_markers.NO_MARKER,
-	message_id: NO_MESSAGE_ID,
-	writes: [],
-	issue: time_markers.NO_ISSUE,
-	reads_background: time_background.NO_BACKGROUND,
-	...time_bundle_call.not_bundleable(),
-}
-const UNKNOWN_CALL: ToolCall = {
-	label: UNKNOWN_TOOL,
-	josh_command: '',
-	josh_commands: [],
-	check_key: time_single_check.NO_CHECK,
-	marker: time_markers.NO_MARKER,
-	message_id: NO_MESSAGE_ID,
-	writes: [],
-	issue: time_markers.NO_ISSUE,
-	reads_background: time_background.NO_BACKGROUND,
-	...time_bundle_call.not_bundleable(),
-}
-
 // `ended_ms` is the absolute instant the span closed, so `[ended_ms - duration_ms, ended_ms]` is the
 // interval it occupied. A duration alone cannot say *when*, and two things need that: the CI wait,
 // which is the part of the PR-open→merge window no span covers (joshuafolkken/kit#1268), and the
@@ -242,50 +153,6 @@ interface Timeline {
 	spans: Array<Span>
 }
 
-// Everything but Bash: the tool's own name is the label, and nothing it runs is a shell command to
-// read a check key, a josh command or a declared issue off.
-function non_bash_call(name: string, input: unknown, message_id: string): ToolCall {
-	return {
-		label: name,
-		josh_command: '',
-		josh_commands: [],
-		check_key: time_single_check.NO_CHECK,
-		marker: time_markers.tool_marker(name, input),
-		message_id,
-		writes: time_writes.tool_writes(name, input),
-		issue: time_markers.NO_ISSUE,
-		// A non-Bash tool joins a backgrounded command too — `BashOutput` carries the shell id in a
-		// field of its own, `Monitor` names the same `…/tasks/<id>.output` path in a command — so the
-		// same reader is asked here rather than the field being left empty for every tool but `Bash`.
-		reads_background: time_background.read_id_of(input),
-		...time_bundle_call.tool_facts(name, input),
-	}
-}
-
-function bash_call(input: unknown, message_id: string): ToolCall {
-	const command = time_shell.bash_command(input)
-	const josh_command = time_shell.josh_command_of(command)
-
-	return {
-		label: time_shell.bash_label(command),
-		josh_command,
-		josh_commands: time_shell.josh_commands_of(command),
-		check_key: time_single_check.check_key(josh_command, command),
-		marker: time_markers.bash_marker(command),
-		message_id,
-		writes: time_writes.bash_writes(command),
-		issue: time_markers.bash_issue(command),
-		reads_background: time_background.read_id_of(input),
-		...time_bundle_call.bash_facts(command),
-	}
-}
-
-function to_tool_call(name: string, input: unknown, message_id: string): ToolCall {
-	if (name !== cost_blocks.BASH_TOOL) return non_bash_call(name, input, message_id)
-
-	return bash_call(input, message_id)
-}
-
 // Identified calls only. A `tool_use` written without an `id` would otherwise be registered under
 // the empty string, where the next result that carries no `tool_use_id` would match it and be
 // labelled with an unrelated tool — a wrong name where `UNKNOWN_TOOL` is the honest one.

package/scripts/time-runtime/time-tool-call.ts

@@ -0,0 +1,160 @@
+import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
+import { time_background } from './time-background'
+import { time_bundle_call } from './time-bundle-call'
+import { time_markers, type PhaseMarker } from './time-markers'
+import { time_shell } from './time-shell'
+import { time_single_check } from './time-single-check'
+import { time_transcript_line } from './time-transcript-line'
+import { time_writes } from './time-writes'
+
+// Reading a `tool_use` block into the label a span carries — split out of `time-spans.ts` when it
+// reached its line limit (joshuafolkken/kit#3264). `time_spans` re-exports `UNKNOWN_TOOL` and
+// `to_tool_call` under the names they always had, so the move changed no call site.
+
+const { NO_MESSAGE_ID } = time_transcript_line
+
+const UNKNOWN_TOOL = 'unknown'
+
+// What a tool span is labelled with. `josh_command` is empty for everything that is not a
+// `pnpm josh <cmd>` invocation, and the report drops empty labels rather than printing a bucket.
+//
+// `marker` names the workflow boundary the call is, for the phase breakdown that slices the same
+// spans by stage (joshuafolkken/kit#1269). It is carried here rather than re-derived later because
+// the tool's *input* is what decides it, and a span keeps no input — only the label read off it.
+//
+// `is_bundleable` and `targets` are carried for exactly that reason too (joshuafolkken/kit#1344).
+// Whether a call could have gone out beside another, and what it names, are both read off the input —
+// so a module asking about them after the fact would have nothing to read. `time-bundle-call.ts`
+// decides both; the rule each one follows is stated there.
+//
+// `check_key` is the fourth, and the third time this reason has applied (joshuafolkken/kit#1383). Two
+// runs of one verification check are the same call only if they named the same files, and the files
+// are in the input — so `josh_command` alone cannot say, and nothing downstream could recover it.
+// `time-single-check.ts` decides it.
+//
+// `message_id` is the fifth, and it is the one that says which *turn* a call belongs to
+// (joshuafolkken/kit#1406). It is read off the line the `tool_use` block sat on rather than off the
+// result that closes the span, because a `tool_result` line carries no message id at all — so a span
+// that did not keep it here could never be attributed to the turn that issued it.
+//
+// `writes` is the sixth, and it is what `targets` could not say (joshuafolkken/kit#1472). `targets`
+// names what a call mentioned; `marker` says a call was *an* edit but not of what, and for a tool
+// outside `BUNDLEABLE_TOOLS` it arrived with no target at all. So a consumer subtracting edits from
+// reads — `investigation-reads.ts` — had nothing to subtract for `MultiEdit` / `NotebookEdit`, and
+// nothing at all to tell an in-place `sed -i` from the `sed -n` it shares a label with.
+// `time-writes.ts` decides it, from the input this span is about to discard.
+// `issue` is the seventh, and it is the one `branch` could not carry (joshuafolkken/kit#1617). Under
+// lanes the session writing the transcript stays on the default branch while the work runs in a linked
+// work tree, so `branch` names no issue on any line of the run; the `in-progress` label call does, and
+// like every field above it that answer is read off the *input* a span is about to discard.
+// `time_markers.NO_ISSUE` for every call that declares nothing, which is all but one call per run.
+interface ToolCall {
+	label: string
+	josh_command: string
+	// Every josh subcommand the call ran, where `josh_command` is only the first (joshuafolkken/kit#1883).
+	// A chained `pnpm josh lint:related && pnpm josh test:related` carries both; the count tables expand
+	// it so the ones `josh_command` drops are still counted.
+	josh_commands: ReadonlyArray<string>
+	check_key: string
+	marker: PhaseMarker
+	is_bundleable: boolean
+	targets: ReadonlyArray<string>
+	// Carried beside `targets` because sharing a target means something different depending on it: a
+	// second write to one file is independent work, a read of a file just written is not
+	// (joshuafolkken/kit#1509).
+	is_writing: boolean
+	// The conservative write answer `is_read_only_call` asks of a live call, carried so a reader of the
+	// transcript asks the same read-only question as the guard (joshuafolkken/kit#3139).
+	may_write: boolean
+	// Whether this is a subagent launch whose prompt builds on an earlier launch's finding
+	// (joshuafolkken/kit#1854). Carried for the reason every field here is — the prompt it is read from
+	// is the input, and a span keeps none. `time-agent-bundles.ts` reads it.
+	has_prior_reference: boolean
+	writes: ReadonlyArray<string>
+	message_id: string
+	issue: number
+	// The background run this call reads the output of, and `''` for every other call
+	// (joshuafolkken/kit#1662). It is the eighth field carried for the reason the seven above are:
+	// the id sits in the command string, which a span does not keep, and it is the only thing that
+	// says a `tail` two turns later is the join of a command started minutes ago.
+	reads_background: string
+}
+
+const NO_CALL: ToolCall = {
+	label: '',
+	josh_command: '',
+	josh_commands: [],
+	check_key: time_single_check.NO_CHECK,
+	marker: time_markers.NO_MARKER,
+	message_id: NO_MESSAGE_ID,
+	writes: [],
+	issue: time_markers.NO_ISSUE,
+	reads_background: time_background.NO_BACKGROUND,
+	...time_bundle_call.not_bundleable(),
+}
+const UNKNOWN_CALL: ToolCall = {
+	label: UNKNOWN_TOOL,
+	josh_command: '',
+	josh_commands: [],
+	check_key: time_single_check.NO_CHECK,
+	marker: time_markers.NO_MARKER,
+	message_id: NO_MESSAGE_ID,
+	writes: [],
+	issue: time_markers.NO_ISSUE,
+	reads_background: time_background.NO_BACKGROUND,
+	...time_bundle_call.not_bundleable(),
+}
+
+// Everything but Bash: the tool's own name is the label, and nothing it runs is a shell command to
+// read a check key, a josh command or a declared issue off.
+function non_bash_call(name: string, input: unknown, message_id: string): ToolCall {
+	return {
+		label: name,
+		josh_command: '',
+		josh_commands: [],
+		check_key: time_single_check.NO_CHECK,
+		marker: time_markers.tool_marker(name, input),
+		message_id,
+		writes: time_writes.tool_writes(name, input),
+		issue: time_markers.NO_ISSUE,
+		// A non-Bash tool joins a backgrounded command too — `BashOutput` carries the shell id in a
+		// field of its own, `Monitor` names the same `…/tasks/<id>.output` path in a command — so the
+		// same reader is asked here rather than the field being left empty for every tool but `Bash`.
+		reads_background: time_background.read_id_of(input),
+		...time_bundle_call.tool_facts(name, input),
+	}
+}
+
+function bash_call(input: unknown, message_id: string): ToolCall {
+	const command = time_shell.bash_command(input)
+	const josh_command = time_shell.josh_command_of(command)
+
+	return {
+		label: time_shell.bash_label(command),
+		josh_command,
+		josh_commands: time_shell.josh_commands_of(command),
+		check_key: time_single_check.check_key(josh_command, command),
+		marker: time_markers.bash_marker(command),
+		message_id,
+		writes: time_writes.bash_writes(command),
+		issue: time_markers.bash_issue(command),
+		reads_background: time_background.read_id_of(input),
+		...time_bundle_call.bash_facts(command),
+	}
+}
+
+function to_tool_call(name: string, input: unknown, message_id: string): ToolCall {
+	if (name !== cost_blocks.BASH_TOOL) return non_bash_call(name, input, message_id)
+
+	return bash_call(input, message_id)
+}
+
+const time_tool_call = {
+	UNKNOWN_TOOL,
+	NO_CALL,
+	UNKNOWN_CALL,
+	to_tool_call,
+}
+
+export type { ToolCall }
+export { time_tool_call }

package/scripts/time-runtime/time-transcript-line.ts

@@ -79,6 +79,13 @@ const ERROR_TEXT_LIMIT = 256
 // shared constant exists because each guard writes the literal in its own reason, so the one place a
 // refusal is *detected* names it here.
 const REFUSAL_MARKER = '⛔'
+// The label the harness puts in front of a PreToolUse hook's deny reason, naming the hook and the tool.
+const HOOK_ERROR_LABEL = /^PreToolUse:\S+ hook error: /u
+// A line that is one bare verdict token — `cut`, `busy`, `not-a-lane` — the single word a josh verdict
+// command prints on standard output (joshuafolkken/kit#3223). How many are kept bounds the field the
+// way `ERROR_TEXT_LIMIT` bounds `error_text`.
+const TOKEN_LINE = /^[a-z][a-z-]*$/u
+const TOKEN_LINE_LIMIT = 8
 
 interface Block {
 	type: string
@@ -111,6 +118,11 @@ interface Block {
 	// the parsed block rather than by re-scanning the body downstream. `''` where the result was not a
 	// `⛔` refusal, so a reader tells "no guard spoke" from "this guard spoke" without a second parse.
 	refusal_guard: string
+	// The bare-token lines of a result that did not fail, and `[]` for every other block
+	// (joshuafolkken/kit#3223). It obeys the same prohibition as `error_text` — what is kept is a few
+	// single words, never the body — and it exists so the verdict a josh command answered with
+	// (`run:cut`'s `cut`) is read from the parsed block rather than by searching the raw line.
+	token_lines: ReadonlyArray<string>
 	// The id the harness assigned to a command it took into the background, and `''` for every other
 	// block (joshuafolkken/kit#1662). It is the fourth field read off the body under the same
 	// prohibition as the three above — what is kept is the id, never the text it was read from — and
@@ -159,8 +171,12 @@ function block_names(
 // before the first `:` — `⛔ pre-gate cut: …` is `pre-gate cut`. A reason with no colon (a headline
 // like `⛔ scoped checks not green on this tree`) is taken whole. Reading the opening rather than
 // searching the body is what stops a result that merely quoted a reason being read as a refusal.
+//
+// **The harness writes the reason behind its own label** — `PreToolUse:Edit hook error: ⛔ …` — so that
+// label is stripped before the opening is read (joshuafolkken/kit#3223). Without it no live refusal
+// carried a guard: the fixtures wrote the bare `⛔` body and passed while every recorded one read `''`.
 function guard_from_refusal(text: string): string {
-	const trimmed = text.trimStart()
+	const trimmed = text.trimStart().replace(HOOK_ERROR_LABEL, '')
 	if (!trimmed.startsWith(REFUSAL_MARKER)) return ''
 
 	const headline = trimmed.slice(REFUSAL_MARKER.length).split('\n', 1)[0]?.trimStart() ?? ''
@@ -169,6 +185,14 @@ function guard_from_refusal(text: string): string {
 	return (colon === -1 ? headline : headline.slice(0, colon)).trim()
 }
 
+function token_lines_of(text: string): Array<string> {
+	return text
+		.split('\n')
+		.map((line) => line.trim())
+		.filter((line) => TOKEN_LINE.test(line))
+		.slice(0, TOKEN_LINE_LIMIT)
+}
+
 // **The body is flattened once and both readers are handed the text.** `result_text` is what turns a
 // content field that may be a string or a list of blocks into one string, and it is idempotent on a
 // string — so passing its own output back to `has_failure_line` reads exactly as passing the raw
@@ -185,6 +209,7 @@ function to_block(raw: z.infer<typeof BLOCK_SCHEMA>): Block {
 		followup_stages: time_followup_stage.read_stages(text),
 		error_text: is_error === true ? text.slice(0, ERROR_TEXT_LIMIT) : '',
 		refusal_guard: is_error === true ? guard_from_refusal(text) : '',
+		token_lines: is_error === true ? [] : token_lines_of(text),
 		background_id: time_background.launch_id(text),
 		agent_id: time_background.agent_launch_id(text),
 	}
@@ -248,6 +273,7 @@ function parse_line(line: string): TranscriptLine | undefined {
 const time_transcript_line = {
 	ERROR_TEXT_LIMIT,
 	NO_MESSAGE_ID,
+	TOKEN_LINE_LIMIT,
 	guard_from_refusal,
 	parse_line,
 }

package/scripts/version/effective-upstream.ts

@@ -1,13 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
+import { ancestor_directories } from '#scripts/lib/ancestor-directories'
 import { json_value } from '#scripts/lib/json-value'
 import { package_named_version_schema } from '#scripts/lib/schemas'
 
 const PACKAGE_JSON = 'package.json'
-// Node module paths never nest anywhere near this deep; the bound only guards against an unexpected
-// filesystem cycle so the walk-up cannot loop forever.
-const MAX_WALK_DEPTH = 64
 
 // Options for `resolve_effective_upstream_version`. `resolve_marker` is a subpath specifier used for
 // `createRequire().resolve()` when the package root itself is not directly resolvable — e.g. kit does
@@ -31,26 +29,10 @@ function read_matching_version(manifest_path: string, package_name: string): str
 	return parsed.data.version
 }
 
-// The directory itself and each of its ancestors up to the filesystem root, nearest-first. Bounded
-// by MAX_WALK_DEPTH so an unexpected filesystem cycle cannot produce an unbounded list.
-function ancestor_directories(start_directory: string): Array<string> {
-	const directories: Array<string> = []
-	let current = start_directory
-
-	for (let depth = 0; depth < MAX_WALK_DEPTH; depth += 1) {
-		directories.push(current)
-		const parent = path.dirname(current)
-		if (parent === current) break
-		current = parent
-	}
-
-	return directories
-}
-
 // Walk up from a resolved file's directory to the package root, returning the version of the first
 // ancestor package.json whose `name` matches the target — or undefined when no matching root exists.
 function walk_up_for_version(start_directory: string, package_name: string): string | undefined {
-	for (const directory of ancestor_directories(start_directory)) {
+	for (const directory of ancestor_directories.list(start_directory)) {
 		const version = read_matching_version(path.join(directory, PACKAGE_JSON), package_name)
 		if (version !== undefined) return version
 	}