@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/scripts/gate/core-weights.ts

@@ -0,0 +1,86 @@
+// The weights heavy tools declare to the core budget (`core-budget.ts`), in their own module so the
+// ledger's file stays under its line ceiling.
+
+// One tool's measured run: its CPU seconds over its wall seconds, the cores it kept busy on average.
+interface Measurement {
+	cpu_s: number
+	wall_s: number
+}
+
+// **What each heavy tool was measured at, on the 11-core machine.** The whole-tree eslint scan behind
+// `josh lines` and `josh refactor:scan`, cold on 2026-10-06. eslint over 40 staged files
+// (`pre-commit-lint.ts`), which the gate's lint also runs beside its sibling linters, so it is the
+// lint's floor; whole runs were observed at 124–147% CPU. The type check and the spell check with
+// `/usr/bin/time -l` on 2026-10-21 under a load average of 14. `prettier --check` over 40 staged
+// files, `josh retrospective` and a fresh lane's `pnpm install --frozen-lockfile` with
+// `/usr/bin/time -l` on 2026-10-17 under a load average of 16. The gate ledger records each check's
+// CPU beside its duration (`check-cpu.ts`), so these can be re-measured from it.
+const MEASURED = {
+	lint: { cpu_s: 16.9, wall_s: 14 },
+	type_check: { cpu_s: 31.2, wall_s: 27.3 },
+	spell_check: { cpu_s: 6, wall_s: 5.6 },
+	eslint_scan: { cpu_s: 113, wall_s: 98 },
+	format: { cpu_s: 2.1, wall_s: 1.7 },
+	retrospective: { cpu_s: 16.5, wall_s: 19.8 },
+	install: { cpu_s: 1.9, wall_s: 6.1 },
+} as const satisfies Readonly<Record<string, Measurement>>
+
+// **Rounded up, never down** (joshuafolkken/kit#4362): a weight is a whole number of cores, and the
+// floored table of joshuafolkken/kit#3354 let a 1.15-core eslint scan claim one, so the budget admitted
+// more than the machine had.
+function rounded_up(measurement: Measurement): number {
+	return Math.ceil(measurement.cpu_s / measurement.wall_s)
+}
+
+// **The cores each heavy tool occupies, declared once for both places that reserve them**
+// `gate-plan.ts`'s checks and the `josh` commands that run the same tools
+// directly read these, so a direct `josh lint` claims what the gate's lint claims. Each is its
+// measurement rounded up. `e2e` is the Playwright worker count `josh test:e2e` passes locally — the
+// two-worker run CI already sizes for its four-core runner — since kit has no e2e suite of its own to
+// time.
+const CORE_WEIGHTS = {
+	lint: rounded_up(MEASURED.lint),
+	type_check: rounded_up(MEASURED.type_check),
+	spell_check: rounded_up(MEASURED.spell_check),
+	eslint_scan: rounded_up(MEASURED.eslint_scan),
+	format: rounded_up(MEASURED.format),
+	retrospective: rounded_up(MEASURED.retrospective),
+	install: rounded_up(MEASURED.install),
+	e2e: 2,
+} as const
+
+// **The memory each heavy tool holds, declared beside its cores**: peak
+// resident size in MB, rounded up. Measured with `/usr/bin/time -l` on the 11-core / 18 GB machine on
+// 2026-10-07: the type check 1,244 MB, the spell check 330 MB, and one unit worker 319 MB over 54 test
+// files. Typed eslint was 1,207 MB over one directory and was observed at 1.6–2.4 GB per whole-tree
+// `eslint .` with three lanes running the same day, so lint and the whole-tree scan take that peak.
+// On 2026-10-17: prettier 260 MB, the retrospective 862 MB and a lane install 65 MB. On 2026-10-22
+// (joshuafolkken/kit#4528) the whole suite, 1,830 files at `--maxWorkers=3` beside four lanes, sampled
+// each worker's resident size once a second: the largest peaked at 381 MB, so the 54-file
+// measurement had read a worker short of the files it lives through.
+const MEMORY_MB = {
+	lint: 2400,
+	type_check: 1300,
+	spell_check: 350,
+	eslint_scan: 2400,
+	unit_worker: 400,
+	format: 300,
+	retrospective: 900,
+	install: 100,
+} as const
+
+// **The program a command launches, mapped to the `MEMORY_MB` row it holds** — the one table
+// `command-memory.ts` reads a wrapped command's memory off. `install` is `pnpm install` read past its
+// `pnpm` wrapper (`git_argv.program_of`).
+const TOOL_MEMORY: Readonly<Partial<Record<string, keyof typeof MEMORY_MB>>> = {
+	eslint: 'lint',
+	tsc: 'type_check',
+	cspell: 'spell_check',
+	vitest: 'unit_worker',
+	prettier: 'format',
+	install: 'install',
+}
+
+const core_weights = { CORE_WEIGHTS, MEASURED, MEMORY_MB, TOOL_MEMORY }
+
+export { core_weights }

package/scripts/gate/free-cores.ts

@@ -0,0 +1,72 @@
+import { availableParallelism } from 'node:os'
+import type { FreeCapacity } from '#scripts/test/unit-worker-share'
+import { core_admission } from './core-admission'
+import { core_budget, type LiveReservation } from './core-budget'
+import { core_weights } from './core-weights'
+import { held_mark } from './held-mark'
+import { machine_capacity, type MachineReading } from './machine-capacity'
+
+// The cores a unit suite may open workers on: the core count less the load from outside the core
+// budget's ledger, the figure the ledger admits against (`machine_capacity.machine_budget`). The run
+// count in `unit-run-marker.ts` divides the machine between unit runs; this is what bounds that
+// division when something else holds the cores.
+//
+// Its own module because the reading needs the ledger, and `core-budget.ts` already imports
+// `unit-worker-share.ts` — reading it from there would close a cycle.
+
+interface FreeCoresOptions {
+	available_cores?: number
+	read_machine?: () => Promise<MachineReading>
+	directory?: string
+}
+
+// **The claim a parent command holds for this run is left out of the ledger.** It is admitted before
+// this run starts a worker, so none of its weight is in the reading yet; counting it would subtract
+// it from load it never added and mask that much outside load (`held_mark.held_reservation`).
+function running_claims(directory: string | undefined): Array<LiveReservation> {
+	const own = held_mark.held_reservation()
+
+	return core_budget.live_reservations(directory).filter((entry) => entry.key !== own)
+}
+
+// `undefined` where the machine could not be read — a CI runner, a CPU quota narrower than the host —
+// which `unit_worker_share.cap_to_free` reads as the share as it was.
+function free_of(reading: MachineReading, options: FreeCoresOptions): number | undefined {
+	if (reading.busy_cores === undefined) return undefined
+
+	const ledger = core_admission.ledger_load(running_claims(options.directory), Date.now())
+
+	return machine_capacity.machine_budget(
+		options.available_cores ?? availableParallelism(),
+		reading,
+		ledger,
+	).cores
+}
+
+// **The workers the free memory holds** (joshuafolkken/kit#4528): the free memory over one worker's
+// peak (`core_weights.MEMORY_MB.unit_worker`, where its measurement is recorded). Divided here, not in
+// `unit-run-marker.ts`, which the vitest config imports — `core-weights.ts` there would widen every
+// related run on it to the whole suite. The memory is the reading's own available figure, not the
+// budget's: the ledger's held memory is added back there for admission's walk, and it is not free for
+// this run's workers. `undefined` — a platform `machine-capacity.ts` reads no memory on — leaves the
+// share as it was; a Linux CI runner reads `/proc/meminfo`, whose memory holds more workers than cores.
+function workers_in_memory(available_mb: number | undefined): number | undefined {
+	if (available_mb === undefined) return undefined
+
+	return available_mb / core_weights.MEMORY_MB.unit_worker
+}
+
+// One reading answers both halves: the sample window is waited out once.
+async function read(options: FreeCoresOptions = {}): Promise<FreeCapacity> {
+	const reading = await (options.read_machine ?? machine_capacity.read_machine)()
+
+	return {
+		cores: free_of(reading, options),
+		memory_workers: workers_in_memory(reading.available_mb),
+	}
+}
+
+const free_cores = { read }
+
+export type { FreeCoresOptions }
+export { free_cores }

package/scripts/gate/gate-ledger.ts

@@ -1,9 +1,10 @@
 import { process_identity } from '#scripts/josh/process-identity'
-import { lane_ledger } from '#scripts/lane/lane-ledger'
+import { lane_ledger, type GateCheckRecord } from '#scripts/lane/lane-ledger'
+import { related_scope } from '#scripts/test/test-related-scope'
 import { core_admission } from './core-admission'
 import { core_budget } from './core-budget'
 import { gate_plan } from './gate-plan'
-import type { GateStepResult } from './gate-report'
+import { gate_report, type GateStepResult } from './gate-report'
 import { machine_capacity } from './machine-capacity'
 
 // A finished gate's line in the lane ledger: its duration, its verdict, its
@@ -13,8 +14,8 @@ import { machine_capacity } from './machine-capacity'
 //
 // **The machine is read where none of the gate's own checks runs — before the first starts and after
 // the last ends.** The load average cannot tell the two apart: a solo gate started at 4 on the 11-core
-// machine ended at 21, its own load. The reading is the core budget's own, so "quiet" means what
-// admission means by it: no whole core busy beyond the baseline the gate's weights were measured beside.
+// machine ended at 21, its own load. The reading is the core budget's own; "quiet" is no whole core
+// busy beyond the background a developer machine always carries.
 //
 // **Between the ends, the load is read off the core budget's ledger, not the CPU**.
 // Two readings missed every lane whose lint, tests or `ship` ran only while
@@ -23,7 +24,11 @@ import { machine_capacity } from './machine-capacity'
 // is what tells the two apart: another `josh` run's admitted claim is another process's place, and its
 // weight is the cores it holds. A claim still waiting holds none.
 
-const NO_LEDGER_CORES = 0
+// **The background a quiet machine still carries.** On 2026-10-07 the 11-core machine idled at about
+// 1.5 cores outside `josh` — Claude sessions 0.55, the window server 0.47, a browser 0.5. Admission
+// counts it (`machine_capacity.external_cores`, joshuafolkken/kit#4238), but a gate timed beside it is
+// still a solo gate for `josh metrics`, so it is no external load here.
+const BACKGROUND_CORES = 2
 // Often enough to catch another lane's shortest related lint, seldom enough that reading the markers —
 // a process probe each — costs the gate nothing it could measure.
 const SAMPLE_INTERVAL_MS = 3000
@@ -48,7 +53,7 @@ async function read_external_cores(): Promise<number | undefined> {
 
 	if (busy_cores === undefined) return undefined
 
-	return machine_capacity.external_cores(busy_cores, NO_LEDGER_CORES)
+	return machine_capacity.external_cores(busy_cores, BACKGROUND_CORES)
 }
 
 // The cores other processes' admitted claims hold now. This gate's own claims are written by this
@@ -88,6 +93,36 @@ async function start(ledger_path: string | undefined): Promise<GateLedgerStart>
 	return { ledger_path, readings, sampler: start_sampler(readings) }
 }
 
+// The unit leg's own facts: the whole-suite fallback it took, or the since-green no-op that ran no
+// test (joshuafolkken/kit#4457) — the two `josh lane:stats` must not time as an ordinary run.
+function unit_facts(result: GateStepResult): Pick<GateCheckRecord, 'fallback' | 'is_unmoved'> {
+	if (result.label !== gate_plan.UNIT_LABEL) return {}
+
+	return {
+		fallback: related_scope.fallback_kind(result.output),
+		...(related_scope.is_unmoved(result.output) && { is_unmoved: true }),
+	}
+}
+
+function check_records(results: ReadonlyArray<GateStepResult>): Array<GateCheckRecord> {
+	return results.map((result) => ({
+		label: result.label,
+		elapsed_ms: result.elapsed_ms,
+		is_passed: !gate_report.is_gate_step_failed(result),
+		is_reused: result.reused_at !== undefined,
+		...(result.cpu_ms !== undefined && { cpu_ms: Math.round(result.cpu_ms) }),
+		...unit_facts(result),
+		claim: result.claim,
+	}))
+}
+
+// A gate that reused a green record started no check: its line is counted as reused, never timed.
+async function record_reused(ledger_path: string | undefined, elapsed_ms: number): Promise<void> {
+	if (ledger_path === undefined) return
+
+	await lane_ledger.record_gate(ledger_path, { elapsed_ms, is_passed: true, is_reused: true })
+}
+
 // The caller measures the elapsed time before this, so the end's reading is never part of it.
 async function record(
 	begun: GateLedgerStart,
@@ -101,12 +136,19 @@ async function record(
 	const unit_ms = results.find((result) => result.label === gate_plan.UNIT_LABEL)?.elapsed_ms
 	const external_cores = peak([...begun.readings, await read_external_cores()])
 
-	await lane_ledger.record_gate(begun.ledger_path, { ...outcome, unit_ms, external_cores })
+	await lane_ledger.record_gate(begun.ledger_path, {
+		...outcome,
+		unit_ms,
+		external_cores,
+		checks: check_records(results),
+	})
 }
 
 const gate_ledger = {
+	BACKGROUND_CORES,
 	SAMPLE_INTERVAL_MS,
 	record,
+	record_reused,
 	start,
 }
 

package/scripts/gate/gate-plan.ts

@@ -49,8 +49,10 @@ interface GateCheck {
 const LINT_LABEL = 'lint'
 const TYPE_CHECK_LABEL = 'check'
 const UNIT_LABEL = 'test:unit'
+const UNIT_TARGET = 'test:related'
 const BEHAVIOR_LABEL = 'behavior'
 const METRICS_LABEL = 'metrics'
+const EXPORTS_LABEL = 'exports'
 
 // The checks whose warnings must survive the green record: eslint (the `lint` step) and svelte-check
 // (the `check` step) both exit 0 while reporting per-tree warnings a developer needs to see again, so
@@ -77,15 +79,18 @@ const WARNING_CHECKER_LABELS: ReadonlyArray<string> = [LINT_LABEL, TYPE_CHECK_LA
 //
 // **The two zero weights are measured, and they stay zero.** These are warm runs on the 11-core
 // machine. `behavior` took 0.6s of wall for 0.7s of CPU, which
-// is node starting up. `exports:unused` took 5.5s of wall for 9.0s of CPU, about 1.6 cores. Floored,
-// that would be one core, but a reservation lasts the whole gate's plan, not the check's five seconds.
-// It would lower `RESERVED_CORES` from 4 to 5 and cut the solo unit cap from 7 workers to 6 for the
-// full length of the unit suite, to cover a burst that ends before lint does. Nothing has measured
+// is node starting up. `exports:unused` took 5.5s of wall for 9.0s of CPU, about 1.6 cores. Rounded
+// up, that would be two cores, but a reservation lasts the whole gate's plan, not the check's five
+// seconds. It would raise `RESERVED_CORES` from 6 to 8 and cut the solo unit cap from 5 workers to 3
+// for the full length of the unit suite, to cover a burst that ends before lint does. Nothing has measured
 // that trade, so the measured shape stays.
 const STATIC_CHECKS: ReadonlyArray<GateCheck> = [
+	// **The lint reads the branch's changed files, not the whole tree** (joshuafolkken/kit#4085), and
+	// falls back to the whole tree in CI and on a changed configuration (`lint-gate-scope.ts`).
 	{
 		label: LINT_LABEL,
 		target: 'lint',
+		args: ['--changed'],
 		reserved_cores: core_budget.CORE_WEIGHTS.lint,
 		memory_mb: core_budget.MEMORY_MB.lint,
 	},
@@ -106,7 +111,7 @@ const STATIC_CHECKS: ReadonlyArray<GateCheck> = [
 	// program and walks it for about 5s, and it is over well before lint and the type check. A
 	// reservation would only take a place from the four-core CI runner's fan-out and a worker from the
 	// unit suite for the whole gate.
-	{ label: 'exports', target: 'exports:unused', reserved_cores: 0 },
+	{ label: EXPORTS_LABEL, target: 'exports:unused', reserved_cores: 0 },
 	// **The metrics ratchet is kit's own**: it holds kit's repository-wide
 	// totals to the merge-base's. It is one in-process eslint pass with only `max-lines` enabled, over
 	// in a few seconds, so it reserves no core for the reason the unused-member check above does not.
@@ -119,13 +124,23 @@ const STATIC_CHECKS: ReadonlyArray<GateCheck> = [
 		memory_mb: core_budget.MEMORY_MB.eslint_scan,
 		is_kit_only: true,
 	},
+	// The lockfile policy check is network-bound and usually instant: it verifies only when the
+	// lockfile or `pnpm-workspace.yaml` moved from the merge-base (joshuafolkken/kit#4090), so it
+	// reserves no core. Kit's own until a consumer's private-registry entries are known to verify.
+	{ label: 'lockfile', target: 'lockfile:policy', reserved_cores: 0, is_kit_only: true },
 ]
 
 // The checks, in the order their output is printed — the static set, then the unit suite last (the
 // one check that fans out across every core, and the one the `--no-unit` split drops).
+//
+// **The unit check runs the tests the change can reach, not the whole suite**
+// (joshuafolkken/kit#4065): `josh test:related` narrows through the module graph and the test-read
+// map, and runs the whole suite — refreshing that map — whenever it cannot tell. The label stays
+// `test:unit`, the name every ledger, reservation and record knows the check by. CI runs the whole
+// sharded suite regardless.
 const GATE_CHECKS: ReadonlyArray<GateCheck> = [
 	...STATIC_CHECKS,
-	{ label: UNIT_LABEL, target: UNIT_LABEL, reserved_cores: 0 },
+	{ label: UNIT_LABEL, target: UNIT_TARGET, reserved_cores: 0 },
 ]
 
 // **Selecting is not skipping, and the difference is where the unit suite runs rather than whether
@@ -151,7 +166,7 @@ function has_unit_check(checks: ReadonlyArray<GateCheck>): boolean {
 	return checks.some((check) => check.label === UNIT_LABEL)
 }
 
-// What the non-elastic checks hold between them: 2 + 1 + 1. Reduced over `STATIC_CHECKS`
+// What the non-elastic checks hold between them: 2 + 2 + 2. Reduced over `STATIC_CHECKS`
 // rather than over every check, because that is the set the sentence above names: `resolve_unit_worker_cap`
 // spends this as the cores the unit suite must leave to its siblings, so summing the unit check into
 // it would have the suite subtract its own reservation from its own budget the day that reservation
@@ -218,7 +233,7 @@ function shared_cores(available_cores: number, concurrent_runs: number): number
 
 // Admit checks in declaration order while the running set's reserved cores still fit **this run's
 // share** of the machine. On a machine running one gate that share is the machine, so this bites
-// only below four cores — the three reserving checks want four between them — and there it is the
+// only below six cores — the three reserving checks want six between them — and there it is the
 // difference between two checks sharing a core and four fighting over it.
 //
 // **Under concurrency it is the only lever there is, and that is a measurement rather than a
@@ -308,8 +323,9 @@ function solo_unit_weight(available_cores: number): number {
 // once**: no second set of weights is introduced, so a change to the measured reservation moves the
 // admission with it.
 //
-// **A solo gate's four weights sum to exactly the core count** — `reserved(2 + 1 + 1) +
-// unit_cap(cores - 4)` is `cores` — which is what lets every check of a lone gate be admitted at once,
+// **A solo gate's four weights sum to exactly the core count** — `reserved(2 + 2 + 2) +
+// unit_cap(cores - 6)` is `cores` — which is what lets every check of a lone gate on a machine with room
+// (its busy cores within what the ledger holds, `core-budget.ts`) be admitted at once,
 // its concurrency unchanged. A machine below the measured one leaves the unit suite uncapped and reads
 // its weight from the same identity, `cores - RESERVED_CORES` clamped at zero, so the sum is the core
 // count there too.
@@ -338,22 +354,33 @@ function check_memory(check: GateCheck, plan: GatePlan, available_cores: number)
 // and hold every later claim behind it. One weight for the suite however it is started. **Floored at one
 // worker**: on a machine the static checks fill, a four-core CI runner among them, the gate's solo
 // weight is zero because its siblings hold every core — a direct run has no siblings, and vitest still
-// occupies a core.
+// occupies a core. **Plus vitest's own process** (joshuafolkken/kit#4362): the workers are the share,
+// and the claim holds the process that drives them on top (`unit_worker_share.cap_to_claim` takes it
+// back off).
 function direct_unit_weight(
 	available_cores: number = availableParallelism(),
 	live_runs: number = unit_worker_share.live_run_count(),
 ): number {
-	const weight =
+	const workers =
 		unit_worker_share.current_share(available_cores, live_runs) ?? solo_unit_weight(available_cores)
 
-	return Math.max(unit_worker_share.MIN_WORKERS, weight)
+	return Math.max(unit_worker_share.MIN_WORKERS, workers) + unit_worker_share.MAIN_PROCESS_CORES
 }
 
-// What a unit run started directly holds: one worker's peak for each worker `direct_unit_weight` gives it.
+// What a unit run started directly holds: one worker's peak for each core `direct_unit_weight` gives
+// it, vitest's own process counted as one more.
 function direct_unit_memory(): number {
 	return unit_memory(direct_unit_weight())
 }
 
+// The claim every unit run started directly declares — `josh test:unit`, `josh test:related` and the
+// pre-push hook — declared once so the three cannot drift apart.
+const DIRECT_UNIT_CLAIM = {
+	core_weight: direct_unit_weight,
+	memory_mb: direct_unit_memory,
+	is_unit_claim: true,
+} as const
+
 function unit_cap_for(
 	checks: ReadonlyArray<GateCheck>,
 	available_cores: number,
@@ -440,6 +467,8 @@ function format_gate_plan(
 }
 
 const gate_plan = {
+	DIRECT_UNIT_CLAIM,
+	EXPORTS_LABEL,
 	GATE_CHECKS,
 	LINT_LABEL,
 	MEASURED_CORES,
@@ -448,10 +477,10 @@ const gate_plan = {
 	STATIC_CHECKS,
 	TYPE_CHECK_LABEL,
 	UNIT_LABEL,
+	UNIT_TARGET,
 	WARNING_CHECKER_LABELS,
 	check_memory,
 	check_weight,
-	direct_unit_memory,
 	direct_unit_weight,
 	format_gate_plan,
 	format_machine,

package/scripts/gate/gate-report.ts

@@ -2,6 +2,7 @@ import { GATE_COMMAND } from '#scripts/josh/josh-command-types'
 import { josh_verdict } from '#scripts/josh/josh-verdict'
 import { buffered_process, type BufferedProcessResult } from '#scripts/lib/buffered-process'
 import { status_icons } from '#scripts/lib/status-icons'
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { NOT_USED_MARKER, NOTHING_TO_CHECK_MARKER } from '#scripts/test/skip-marker'
 import { test_unit_guard } from '#scripts/test/test-unit-guard'
 import { gate_log } from './gate-log'
@@ -28,6 +29,21 @@ interface GateStepResult extends BufferedProcessResult {
 	command: string
 	// Set when the check started past the machine-wide budget at the wait cap.
 	budget_note?: string | undefined
+	// Set when the check was not started because its inputs match the record taken at this time
+	// (`check-reuse.ts`).
+	reused_at?: string | undefined
+	// The CPU milliseconds the check's process tree spent, where the gate could read it (`check-cpu.ts`).
+	cpu_ms?: number | undefined
+	// The check's place in the core budget, absent on a check that claimed none (`gate-run-steps.ts`).
+	claim?: CheckClaim | undefined
+}
+
+// The width a check asked the core budget for, the width it ran at and how long it waited for it, so
+// whether a unit claim's wait for room paid off is read per run (joshuafolkken/kit#4451).
+interface CheckClaim {
+	requested: number
+	granted: number
+	waited_ms: number
 }
 
 function is_gate_step_failed(result: GateStepResult): boolean {
@@ -98,6 +114,12 @@ function is_unverified_skip(result: GateStepResult): boolean {
 	)
 }
 
+// Whether a passing check said nothing a green record would hide — the condition every record the
+// gate writes is withheld on (`verification-gate.ts` → `record_green_gate`, `check-reuse.ts`).
+function has_nothing_to_say(result: GateStepResult): boolean {
+	return !is_unverified_skip(result) && !has_checker_warning(result)
+}
+
 // **A check the verdict counts as skipped said nothing but that it checked nothing.** `is_skip_notice`
 // asks whether a check carries a skip notice, which is the right question for printing its body; it is
 // the wrong one for a count, twice over. A check can skip half of
@@ -138,7 +160,6 @@ function should_print_body(result: GateStepResult, is_verbose: boolean): boolean
 // Seconds to one decimal, which is the resolution the answer is read at: the question a gate's
 // timing answers is "which of the four is the long pole", and no check is ever separated from
 // another by less than a tenth of a second.
-const MS_PER_SECOND = 1000
 const SECONDS_DECIMALS = 1
 
 function format_seconds(elapsed_ms: number): string {
@@ -154,8 +175,12 @@ function format_seconds(elapsed_ms: number): string {
 // and the log exists precisely to be read when the console's copy has been elided.
 function gate_step_header(result: GateStepResult): string {
 	const icon = is_gate_step_failed(result) ? FAIL_ICON : PASS_ICON
+	const timing =
+		result.reused_at === undefined
+			? format_seconds(result.elapsed_ms)
+			: `reused — inputs unchanged since it passed at ${result.reused_at}`
 
-	return `${icon} ${result.label} (pnpm ${result.command}) ${format_seconds(result.elapsed_ms)}`
+	return `${icon} ${result.label} (pnpm ${result.command}) ${timing}`
 }
 
 function print_gate_step(result: GateStepResult, is_verbose: boolean): void {
@@ -267,10 +292,10 @@ const gate_report = {
 	format_budget_notes,
 	format_failure_actions,
 	has_checker_warning,
+	has_nothing_to_say,
 	is_gate_step_failed,
-	is_unverified_skip,
 	report_gate_steps,
 }
 
-export type { GateReport, GateStep, GateStepResult }
+export type { CheckClaim, GateReport, GateStep, GateStepResult }
 export { gate_report }