@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/test/vitest-failure-summary.ts

@@ -0,0 +1,111 @@
+import { stripVTControlCharacters } from 'node:util'
+import { gate_log } from '#scripts/gate/gate-log'
+import { verification_tail } from '#scripts/gate/verification-tail'
+import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { stamp_file } from '#scripts/josh/stamp-file'
+
+// A failed vitest run's answer, put where a `tail` reaches it (joshuafolkken/kit#4869).
+//
+// **The console's end is the last failure's stack, not the list of what failed.** vitest prints its
+// failures in order and then a summary of counts, so `josh test:related 2>&1 | tail -40` kept one stack
+// and no names, and the only way to learn the rest was to run the suite again. So every run's output
+// goes to a file, and a failed one ends with the failed tests' names and that file's path — the same
+// log and notice `josh gate` uses, imported rather than re-derived.
+
+const UNIT_LOG_PREFIX = 'josh-unit-log-'
+const UNIT_LOG_HEADER = 'vitest'
+const FAILED_LINE = /^FAIL\s+(?<name>\S.*)$/u
+const FAILED_HEADING = 'failed tests:'
+const NONE_NAMED = '  (none named in the output — read the full output)'
+const NONE_NAMED_VERDICT = 'none named'
+// A name is `<file> > <suite> > <test>` or `<file> [ <file> ]`, prefixed `|<project>| ` in a workspace —
+// or, with color on, ` <project>  ` once its badge's escapes are stripped (joshuafolkken/kit#5171).
+const FAILED_FILE = /^(?:\|[^|]*\|\s+|\S+\s{2,})?(?<file>\S+)/u
+// The guarded unit run, filtered to those files: it reserves its cores and ends a failure with this
+// same summary (joshuafolkken/kit#5023).
+const RERUN_PREFIX = 'rerun failed: pnpm josh test:unit '
+
+// One path per checkout and vitest mode, overwritten by each run, beside the gate's own log. **The
+// mode is in the name** because the gate's whole-suite `run` and a `related` run started beside it
+// overlap, and one shared file would hand the failed run's reader the other run's output.
+function unit_log_path(vitest_arguments: ReadonlyArray<string>): string {
+	const prefix = `${UNIT_LOG_PREFIX}${vitest_arguments[0] ?? UNIT_LOG_HEADER}-`
+
+	return stamp_file.stamp_path(prefix, PROJECT_ROOT, gate_log.GATE_LOG_SUFFIX)
+}
+
+function failed_name(line: string): string | undefined {
+	return FAILED_LINE.exec(stripVTControlCharacters(line).trim())?.groups?.['name']
+}
+
+// vitest names each failed test on a ` FAIL  <file> > <suite> > <test>` line, and a file that could
+// not load on ` FAIL  <file> [ <file> ]`. A name printed twice is listed once.
+function failed_tests(output: string): ReadonlyArray<string> {
+	const names = output.split('\n').map((line) => failed_name(line))
+
+	return [...new Set(names.filter((name) => name !== undefined))]
+}
+
+// The files the failed names belong to, each once — what to run after a fix, before the whole related
+// set again (joshuafolkken/kit#5023).
+function failed_files(names: ReadonlyArray<string>): ReadonlyArray<string> {
+	const files = names.map((name) => FAILED_FILE.exec(name)?.groups?.['file'])
+
+	return [...new Set(files.filter((file) => file !== undefined))]
+}
+
+function name_lines(names: ReadonlyArray<string>): ReadonlyArray<string> {
+	if (names.length === 0) return [NONE_NAMED]
+
+	return [...names.map((name) => `  ${name}`), `${RERUN_PREFIX}${failed_files(names).join(' ')}`]
+}
+
+// The verdict names the failed files, so the last line alone says what to fix (joshuafolkken/kit#5162).
+function format_failure_summary(
+	output: string,
+	log_path: string | undefined,
+	label: string = UNIT_LOG_HEADER,
+): string {
+	const names = failed_tests(output)
+	const failures = `${[FAILED_HEADING, ...name_lines(names)].join('\n')}\n`
+	const failed = names.length === 0 ? [NONE_NAMED_VERDICT] : failed_files(names)
+	const verdict = verification_tail.format_verdict(label, failed)
+
+	return verification_tail.format_tail({ failures, log: { path: log_path }, verdict })
+}
+
+function format_green_summary(log_path: string | undefined, label: string): string {
+	const verdict = verification_tail.format_verdict(label, [])
+
+	return verification_tail.format_tail({ failures: '', log: { path: log_path }, verdict })
+}
+
+// Written on every run, as the gate's is, headed by the run's own invocation, and ended as every josh
+// check ends (`verification-tail.ts`): a green run's last line is its verdict, not vitest's counts.
+function report(
+	vitest_arguments: ReadonlyArray<string>,
+	output: string,
+	exit_code: number,
+	target: string = unit_log_path(vitest_arguments),
+): void {
+	const header = [UNIT_LOG_HEADER, ...vitest_arguments].join(' ')
+	const log_path = gate_log.write_gate_log([{ header, output }], target)
+	const label = [UNIT_LOG_HEADER, ...vitest_arguments.slice(0, 1)].join(' ')
+	const summary =
+		exit_code === 0
+			? format_green_summary(log_path, label)
+			: format_failure_summary(output, log_path, label)
+
+	process.stdout.write(summary)
+}
+
+const vitest_failure_summary = {
+	RERUN_PREFIX,
+	failed_files,
+	failed_tests,
+	format_failure_summary,
+	report,
+	unit_log_path,
+}
+
+export { vitest_failure_summary }

package/scripts/test/whole-suite-files.ts

@@ -0,0 +1,74 @@
+import path from 'node:path'
+import { unit_setup_files } from './unit-setup-files'
+
+// The files every test depends on without importing or reading them: the package and its lock,
+// the vitest configuration, and the setup files every worker runs before every test.
+const SETUP_FILES: ReadonlyArray<string> = [
+	...unit_setup_files.NETWORK_GUARD,
+	...unit_setup_files.STATE_GUARD,
+	...unit_setup_files.WORKER_GUARDS,
+	...unit_setup_files.READ_RECORDER,
+]
+
+const ROOT_FILES: ReadonlyArray<string> = [
+	'package.json',
+	'pnpm-lock.yaml',
+	'pnpm-workspace.yaml',
+	'tsconfig.json',
+	'vitest.config.ts',
+	'vitest.harness.config.ts',
+	// What the read recorder runs in every worker, which no test imports through the setup file.
+	'tools/test/test-read-capture.ts',
+	'scripts/test/test-read-trace.ts',
+]
+
+// **What the vitest config and the worker setup files import** (joshuafolkken/kit#4465). Vitest runs
+// every test when a file it is given is a config dependency — every module the config imports,
+// statically or not — and the setup files are in every test's graph, so `vitest related` widens to the
+// whole suite on any of these with no word of why. Named here, they print the reason instead.
+// `whole-suite-files.test.ts` holds the list to both graphs, so an import added to either fails there.
+const IMPORTED_BY_EVERY_TEST: ReadonlyArray<string> = [
+	'scripts/git/constants.ts',
+	'scripts/git/git-location-environment.ts',
+	'scripts/init/init-paths.ts',
+	'scripts/josh/agent-session-environment.ts',
+	'scripts/josh/platform-temporary.ts',
+	'scripts/josh/process-identity.ts',
+	'scripts/josh/process-owner.ts',
+	'scripts/josh/stamp-file.ts',
+	'scripts/lane/lane-child-mark-keys.ts',
+	'scripts/lib/atomic-write.ts',
+	'scripts/lib/json-value.ts',
+	'scripts/lib/read-file.ts',
+	'scripts/lib/timeouts.ts',
+	'scripts/test/unit-durations.ts',
+	'scripts/test/unit-run-marker.ts',
+	'scripts/test/unit-setup-files.ts',
+	'scripts/test/vitest-cache-directory.ts',
+	'scripts/test/vitest-cli-excludes.ts',
+	'tools/test/duration-sequencer.ts',
+	'tools/test/duration-shard.ts',
+	'tools/test/pure-files.ts',
+	'tools/test/test-module-elapsed.ts',
+	'tools/test/test-repository-guard.ts',
+	'tools/test/unit-duration-record.ts',
+	'tools/test/unit-guard-environment.ts',
+	'tools/test/unit-projects.ts',
+	'tools/test/vitest-config-workers.ts',
+	'tools/test/vitest-include-globs.ts',
+]
+
+const WHOLE_SUITE_FILES: ReadonlySet<string> = new Set(
+	[...ROOT_FILES, ...IMPORTED_BY_EVERY_TEST, ...SETUP_FILES].map((file) => path.normalize(file)),
+)
+
+// The part of `WHOLE_SUITE_FILES` a scoped run narrows to the test files importing it directly
+// (`direct-importers.ts`, joshuafolkken/kit#5122): each is a module some test imports by name, unlike a
+// root or setup file, which only the whole suite reaches.
+const EVERY_TEST_IMPORTS: ReadonlySet<string> = new Set(
+	IMPORTED_BY_EVERY_TEST.map((file) => path.normalize(file)),
+)
+
+const whole_suite_files = { EVERY_TEST_IMPORTS, WHOLE_SUITE_FILES }
+
+export { whole_suite_files }

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

@@ -51,8 +51,15 @@ const NO_FINISH = 0
 // 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
+// A backgrounded subagent's launch result, which names its id on an `agentId:` line of its own — or
+// the JSON result of a `SendMessage` that resumed one, which names it as `resumedAgentId`. A resumed
+// subagent runs in the background under the same id and ends with the same notice; missing that
+// spelling let the #4344 lane child's stop hook release its hold and `in-progress` while the resumed
+// investigator was still running (joshuafolkken/kit#4347). It is anchored on the result's own first
+// key: a command that printed a transcript line, which nests the same key under `toolUseResult`,
+// would otherwise open a resume that never finishes.
+const AGENT_LAUNCH_PATTERN =
+	/^(?:Async agent launched[\s\S]*?\bagentId:\s*|\{"success":[^\n]*?"resumedAgentId":")([\w-]+)/u
 // The notice the harness writes when a task it took into the background ends.
 // It is anchored at the start because the whole content of that line *is*
 // the notice — a body merely quoting one is text, the same hazard `read_id` unquotes for — and it
@@ -65,6 +72,11 @@ const AGENT_LAUNCH_PATTERN = /^Async agent launched[\s\S]*?\bagentId:\s*([\w-]+)
 // an enumeration of the harness's spellings, and a spelling it added later would silently start
 // reporting finished commands as never finished.
 const FINISH_PATTERN = /^<task-notification>[\s\S]*?<task-id>([\w-]+)<\/task-id>/u
+// The other end of a backgrounded task: the result of a `TaskStop` call. The harness writes no
+// task-notification for a task it was told to stop, so reading the notice alone left a stopped task
+// open for ever, and the lane stop guard blocked every stop after it (joshuafolkken/kit#4472). It is
+// anchored on the result's own first key for the reason `AGENT_LAUNCH_PATTERN` is.
+const STOP_PATTERN = /^\{"message":"Successfully stopped task:\s*([\w-]+)/u
 // The output file every reader of a backgrounded command names, whichever command it uses to read
 // it — `tail`, `cat`, `sed`, `grep`, or the `Monitor` tool, all of which carry the path.
 const OUTPUT_PATTERN = /tasks\/([\w-]+)\.output/u
@@ -113,6 +125,11 @@ function finished_id(text: string): string {
 	return FINISH_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND
 }
 
+// The background run a `TaskStop` result reports stopping, or nothing for every other tool result.
+function stopped_id(text: string): string {
+	return STOP_PATTERN.exec(text)?.[1] ?? NO_BACKGROUND
+}
+
 // One line, as much of it as this reading needs. Taken structurally rather than as a `TranscriptLine`
 // so the import stays one-way: `time-transcript-line.ts` already imports this module to read the two
 // ids off a body, and asking for its type back would close the cycle.
@@ -300,6 +317,7 @@ const time_background = {
 	launch_id,
 	agent_launch_id,
 	finished_id,
+	stopped_id,
 	finished_at,
 	read_id,
 	read_id_of,

package/scripts/time-runtime/time-batch-guard.ts

@@ -1,7 +1,9 @@
 import { time_bundle_call, type BundleFacts } from './time-bundle-call'
 import { time_bundles } from './time-bundles'
 import { time_call_identity } from './time-call-identity'
+import { time_search_call } from './time-search-call'
 import { time_spans, type Span } from './time-spans'
+import type { ToolCall } from './time-tool-call'
 import { time_transcript_line } from './time-transcript-line'
 
 // Whether the call about to go out should be refused because the run has stopped batching. What a
@@ -154,6 +156,16 @@ function is_reissued_refusal(spans: ReadonlyArray<Span>, call: GuardedCall): boo
 	)
 }
 
+// The closed history a refusal judges; empty where the call is not refusable or is a reissue, and an
+// empty history never reaches the limit.
+function refusable_spans(text: string, call: GuardedCall): ReadonlyArray<Span> {
+	if (!is_guarded_call(call)) return []
+
+	const { spans } = time_spans.parse_timeline(text)
+
+	return is_reissued_refusal(spans, call) ? [] : spans
+}
+
 // The lane-child notice passes `NOTICE_REFIRE_EVERY` to recur on the notice's cadence.
 function should_block(
 	text: string,
@@ -161,13 +173,37 @@ function should_block(
 	refused_at_ms: number,
 	refire_every: number = REFIRE_EVERY,
 ): boolean {
-	if (!is_guarded_call(call)) return false
+	return is_at_limit(refusable_spans(text, call), call, refused_at_ms, refire_every)
+}
 
-	const { spans } = time_spans.parse_timeline(text)
+function as_tool_call(call: GuardedCall): ToolCall {
+	return time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
+}
+
+// Asked before the transcript is read, like `is_guarded_call`, for the search-chain refusal alone.
+function is_search_chain_call(call: GuardedCall): boolean {
+	return is_guarded_call(call) && time_search_call.is_search_chain_call(as_tool_call(call))
+}
+
+// The turns that make the limit — the last closed ones and the call in hand — are all searches.
+function is_search_chain(spans: ReadonlyArray<Span>, call: GuardedCall): boolean {
+	const recent = time_bundles.open_sequence(spans).slice(-SEQUENCE_BEFORE_LIMIT)
+
+	return [...recent, as_tool_call(call)].every((turn) =>
+		time_search_call.is_search_chain_call(turn),
+	)
+}
 
-	if (is_reissued_refusal(spans, call)) return false
+// The narrower refusal a lane child keeps (`search-batching` in `lane-guard-policy.ts`): only a chain
+// of searches issued one per turn, the largest share of the child's single-call pairs.
+function should_block_search_chain(
+	text: string,
+	call: GuardedCall,
+	refused_at_ms: number,
+): boolean {
+	const spans = refusable_spans(text, call)
 
-	return is_at_limit(spans, call, refused_at_ms, refire_every)
+	return is_search_chain(spans, call) && is_at_limit(spans, call, refused_at_ms, REFIRE_EVERY)
 }
 
 // `notified_at_ms` is the notice's own record, so a notice never silences a later refusal.
@@ -279,9 +315,11 @@ const time_batch_guard = {
 	is_guarded_call,
 	is_notice_call,
 	is_read_only_call,
+	is_search_chain_call,
 	pairing_candidates,
 	recent_candidates,
 	should_block,
+	should_block_search_chain,
 	should_notify,
 }
 

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

@@ -1,5 +1,5 @@
 import { cost_blocks } from '#scripts/cost-runtime/cost-blocks'
-import { canonical_command } from '#scripts/josh/josh-command-map'
+import { canonical_command } from '#scripts/josh/josh-aliases'
 import { json_value } from '#scripts/lib/json-value'
 import { time_shell } from './time-shell'
 

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

@@ -1,3 +1,4 @@
+import { figure_format } from '#scripts/lib/figure-format'
 import { time_agent_bundles } from './time-agent-bundles'
 import { time_format } from './time-format'
 import { time_round_trips } from './time-round-trips'
@@ -94,15 +95,29 @@ interface BundleTotals {
 	recoverable_round_trips: number
 	by_tool: ReadonlyArray<BundleToolRow>
 	unattributed_round_trips: number
+	single_call: SingleCallSplit
 	is_measured: boolean
 }
 
+// The consecutive single-call turns alone, split by the target test — what `josh time:density` reads.
+// **The spread-apart `Agent` launch series is left out** of every field here: the walk never sees a
+// launch, so it can be neither dependent nor independent, and folding its count into one side would
+// make the two sides measure different populations.
+interface SingleCallSplit {
+	// Turns that could have gone out beside the single-call turn before them.
+	independent_round_trips: number
+	// Turns whose call shared a target with the open sequence, so needed the turn before.
+	dependent_round_trips: number
+	by_tool: ReadonlyArray<BundleToolRow>
+}
+
 const NO_BUNDLES: BundleTotals = {
 	sequence_count: 0,
 	longest_sequence: 0,
 	recoverable_round_trips: 0,
 	by_tool: [],
 	unattributed_round_trips: 0,
+	single_call: { independent_round_trips: 0, dependent_round_trips: 0, by_tool: [] },
 	is_measured: false,
 }
 
@@ -111,7 +126,7 @@ const NO_BUNDLES: BundleTotals = {
 // `scripts/time-x` inside `scripts/time-xyz`.
 //
 // **The tail position is what makes an absolute path comparable with a relative one.** A `Read` call
-// names `/Users/…/kit/scripts/time/x.ts` while the `grep` before it named `scripts/time`, and nothing
+// names `/Users/…/kit/tools/time/x.ts` while the `grep` before it named `tools/time`, and nothing
 // here knows the working directory the second was relative to — so the search-then-read pair, which is
 // the whole reason the target test exists, would escape it on the two shapes it occurs in most.
 function contains_segments(whole: string, part: string): boolean {
@@ -124,7 +139,7 @@ function contains_segments(whole: string, part: string): boolean {
 }
 
 // Equal, or one inside the other. The containing form is what catches the search-then-read pair:
-// `grep -rn foo scripts` names `scripts`, and the `cat scripts/time/x.ts` that follows it names a path
+// `grep -rn foo scripts` names `scripts`, and the `cat tools/time/x.ts` that follows it names a path
 // beneath — which is exactly how the second call learned the first one's answer.
 function is_related(left: string, right: string): boolean {
 	if (left === right) return true
@@ -190,10 +205,11 @@ interface Walk {
 	pending: Array<Span>
 	sequence: Array<Span>
 	closed: Array<Array<Span>>
+	dependent: number
 }
 
 function new_walk(): Walk {
-	return { pending: [], sequence: [], closed: [] }
+	return { pending: [], sequence: [], closed: [], dependent: NONE }
 }
 
 function flush(walk: Walk): void {
@@ -203,9 +219,13 @@ function flush(walk: Walk): void {
 }
 
 // A conflicting call does not end the run of single-call turns; it starts a new sequence at itself,
-// because everything after it may still have been bundleable with it.
+// because everything after it may still have been bundleable with it. The conflict is the one place a
+// dependent pair is seen, so it is counted here rather than by a second walk.
 function extend(walk: Walk, span: Span): void {
-	if (conflicts(span, walk.sequence)) flush(walk)
+	if (conflicts(span, walk.sequence)) {
+		walk.dependent += ONE_CALL
+		flush(walk)
+	}
 
 	walk.sequence.push(span)
 }
@@ -358,6 +378,14 @@ function with_agent_row(
 	return [...rows, row].toSorted(by_weight)
 }
 
+function single_call_split(walk: Walk, sizes: ReadonlyArray<number>): SingleCallSplit {
+	return {
+		independent_round_trips: recoverable_of(sizes),
+		dependent_round_trips: walk.dependent,
+		by_tool: tool_rows(walk.closed),
+	}
+}
+
 function build_bundles(spans: ReadonlyArray<Span>): BundleTotals {
 	const walk = new_walk()
 
@@ -372,8 +400,9 @@ function build_bundles(spans: ReadonlyArray<Span>): BundleTotals {
 	// is never bundleable, so it cannot have entered a sequence above — so their counts simply add.
 	const sizes = sizes_of(walk.closed)
 	const agent_sizes = time_agent_bundles.agent_bundles(spans)
-	const by_tool = with_agent_row(tool_rows(walk.closed), agent_sizes)
-	const recoverable_round_trips = recoverable_of(sizes) + recoverable_of(agent_sizes)
+	const single_call = single_call_split(walk, sizes)
+	const by_tool = with_agent_row(single_call.by_tool, agent_sizes)
+	const recoverable_round_trips = single_call.independent_round_trips + recoverable_of(agent_sizes)
 
 	return {
 		sequence_count: sizes.length + agent_sizes.length,
@@ -381,6 +410,7 @@ function build_bundles(spans: ReadonlyArray<Span>): BundleTotals {
 		recoverable_round_trips,
 		by_tool,
 		unattributed_round_trips: recoverable_round_trips - attributed_of(by_tool),
+		single_call,
 		is_measured: time_spans.has_transcript_data(spans.length),
 	}
 }
@@ -422,7 +452,7 @@ interface TripPrice {
 }
 
 function recoverable_suffix(totals: BundleTotals, round_trip_count: number): string {
-	const share = time_format.format_share(totals.recoverable_round_trips, round_trip_count)
+	const share = figure_format.format_share(totals.recoverable_round_trips, round_trip_count)
 
 	return `${share} of ${String(round_trip_count)} round trip(s)`
 }
@@ -523,9 +553,11 @@ const time_bundles = {
 	NO_BUNDLES,
 	build_bundles,
 	bundle_lines,
+	by_weight,
 	is_dependent,
 	open_sequence,
 	shares_target,
 }
 
+export type { BundleToolRow }
 export { time_bundles }

package/scripts/time-runtime/time-density-hook.ts

@@ -66,22 +66,22 @@ const notice_schema = z.object({ notified_at_ms: z.number() })
 const call_schema = z.object({ tool_name: z.string().min(1), tool_input: z.unknown() })
 
 function parse_transcript_path(raw_payload: string): string | undefined {
-	const parsed = payload_schema.safeParse(JSON.parse(raw_payload))
+	const payload = json_value.parse_with(raw_payload, payload_schema)
 
-	if (!parsed.success || parsed.data.transcript_path === undefined) return undefined
+	if (payload?.transcript_path === undefined) return undefined
 
-	return time_hook_transcript.transcript_of(parsed.data.transcript_path, parsed.data.agent_id)
+	return time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id)
 }
 
 // The call that has just run, as the payload names it — what the line checks
 // against the turns behind it, so a call that needed their result is never offered as one that could
 // have shared their turn. A payload without a tool name answers `undefined`, judged on those turns alone.
 function parse_call(raw_payload: string): GuardedCall | undefined {
-	const parsed = call_schema.safeParse(JSON.parse(raw_payload))
+	const call = json_value.parse_with(raw_payload, call_schema)
 
-	if (!parsed.success) return undefined
+	if (call === undefined) return undefined
 
-	return { name: parsed.data.tool_name, input: parsed.data.tool_input }
+	return { name: call.tool_name, input: call.tool_input }
 }
 
 // The last `max_bytes` of a file, as text. The leading line is usually cut mid-way, which every
@@ -173,6 +173,8 @@ function density_notice(raw_payload: string, now_ms: number = Date.now()): strin
 const time_density_hook = {
 	density_notice,
 	notice_path,
+	parse_call,
+	parse_transcript_path,
 	read_tail,
 }
 

package/scripts/time-runtime/time-followup-stage.ts

@@ -1,4 +1,5 @@
 import { git_followup_stages, type FollowupStage } from '#scripts/followup/git-followup-stages'
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 
 // Reading `followup`'s own stage rows back out of what it printed.
 //
@@ -35,9 +36,6 @@ const LINE_SEPARATOR = '\n'
 // so the tail is the one part of the row whose shape the alignment cannot move.
 const SECONDS_SUFFIX = ' s'
 const DIGIT_OR_POINT = /[\d.]/u
-// Written here rather than imported: `time-format.ts` keeps its own copy private, and reaching for
-// `run-progress.ts` would pull a command module into the parse for one number.
-const MS_PER_SECOND = 1000
 const NO_STAGES: ReadonlyArray<FollowupStage> = []
 
 // Leading whitespace is trimmed for the same reason `time-reported-failure.ts` trims it: the printer

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

@@ -1,3 +1,6 @@
+import { figure_format } from '#scripts/lib/figure-format'
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
+
 // The column and number formatting every timing report is laid out through.
 //
 // It was `time-report.ts`'s until three renderers shared it: the run scope's own tables, the epic
@@ -12,13 +15,9 @@
 // imports either of them. **The words two blocks must spell identically are the exception**, and they
 // are here for the reason `NO_CALLS` is: a label printed by two renderers, one of which cannot import
 // the other, has to be written once or the two reports come to disagree about what a row is called.
+// The figures themselves are `figure_format`'s, shared with the cost reports.
 
-const MS_PER_MINUTE = 60_000
-const MS_PER_SECOND = 1000
-const MINUTE_DECIMALS = 1
 const SECOND_DECIMALS = 1
-const PERCENT_SCALE = 100
-const PERCENT_DECIMALS = 1
 const LABEL_WIDTH = 24
 // Wide enough for a three-digit run (`335.4 min`), so a long session's rows stay in column with a
 // short one's rather than pushing the share out by a character.
@@ -53,32 +52,12 @@ function overflow_line(row_count: number): Array<string> {
 	]
 }
 
-function format_minutes(duration_ms: number): string {
-	return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`
-}
-
 // Seconds rather than minutes for a per-turn figure: one turn is tens of seconds, and `0.1 min` is
 // too coarse to show the rise across a batch that this scale exists to make visible.
 function format_seconds(duration_ms: number): string {
 	return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`
 }
 
-function format_share(part: number, whole: number): string {
-	if (whole === 0) return 'n/a'
-
-	return `${((part / whole) * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`
-}
-
-// A dollar figure, to the caller's own precision. Two cost blocks print money now — the phase costs
-// and the per-subagent context-construction costs — and each rounds to a different place (a run total
-// to the cent, a per-round-trip figure finer), so the decimals are the caller's and only the `$` and
-// the `toFixed` are shared. It sits here beside the other number formatters rather than in one block,
-// for the reason `format_minutes` does: a second copy beside the second renderer is how two cost rows
-// of one report come to punctuate a dollar amount two ways.
-function usd(amount: number, decimals: number): string {
-	return `$${amount.toFixed(decimals)}`
-}
-
 // The one place the three columns are laid out, so a row carrying words instead of a duration lines
 // up with the rows that carry one rather than overrunning the numeric column.
 function format_columns(label: string, minutes: string, suffix: string): string {
@@ -86,7 +65,7 @@ function format_columns(label: string, minutes: string, suffix: string): string
 }
 
 function format_row(label: string, duration_ms: number, suffix: string): string {
-	return format_columns(label, format_minutes(duration_ms), suffix)
+	return format_columns(label, figure_format.format_minutes(duration_ms), suffix)
 }
 
 // **A share nobody read says so rather than totalling zero.** The duration column is left empty
@@ -101,8 +80,6 @@ const time_format = {
 	NO_CALLS,
 	overflow_line,
 	format_seconds,
-	format_share,
-	usd,
 	format_columns,
 	format_row,
 	// `format_clock` stays private: `format_window` is its only caller, and a namespace that offers

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

@@ -32,8 +32,8 @@ import { json_value } from '#scripts/lib/json-value'
 // which the main line loaded the skill itself.
 //
 // **The launch is recognized by its prompt carrying both `/code-review` and `review:attest`.** The
-// first is the instruction to invoke the review skill; the second is the attestation line
-// `pnpm josh review:brief` emits into the brief the launch passes verbatim.
+// first is the instruction to invoke the review skill; the second is the attestation step the launch
+// prompt `pnpm josh run:review` prints beside each brief file names (joshuafolkken/kit#4863).
 // Neither alone is enough: an investigation subagent about the review tooling quotes `/code-review`
 // in prose and is handed no brief, so `review:attest` is what tells a genuine review launch from a
 // discussion of one — measured against five real launches, it admits the review and rejects every
@@ -89,6 +89,11 @@ const BODY_FIELD_PATTERN = /\bbody=/u
 const ISSUE_COMMENT_PATTERN = /\bgh\s+issue\s+comment\b/u
 const BODY_FLAG_PATTERN = /--body(?:-file)?\b/u
 
+// `josh issue:plan` posts the plan under no API path of its own, so it is named outright — **as the
+// command run**, at the start or after a `;` / `&&` / `|`, so a grep or a commit message that merely
+// quotes it is not the call.
+const ISSUE_PLAN_PATTERN = /(?:^|[;&|]\s*)pnpm\s+josh\s+issue:plan\b/u
+
 // **The add form, not the label's name anywhere in the command.** The prerequisite branch removes the
 // same label with `-X DELETE …/labels/in-progress`, which is a run ending its hold on an issue rather
 // than opening one — matched loosely, that call would move the run's start to somewhere near its end.
@@ -159,6 +164,10 @@ function is_issue_comment(command: string): boolean {
 	return ISSUE_COMMENT_PATTERN.test(command) && BODY_FLAG_PATTERN.test(command)
 }
 
+function is_plan_write(command: string): boolean {
+	return is_api_body_write(command) || is_issue_comment(command) || ISSUE_PLAN_PATTERN.test(command)
+}
+
 function is_in_progress_label(command: string): boolean {
 	return ISSUE_LABELS_PATTERN.test(command) && command.includes(IN_PROGRESS_FIELD)
 }
@@ -216,7 +225,7 @@ function bash_issue(command: string): number {
 function bash_marker(command: string): PhaseMarker {
 	if (is_run_start(command)) return WORKFLOW_MARKER
 
-	return is_api_body_write(command) || is_issue_comment(command) ? PLAN_MARKER : NO_MARKER
+	return is_plan_write(command) ? PLAN_MARKER : NO_MARKER
 }
 
 const time_markers = {