@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/scripts/gate/core-budget.ts

@@ -10,6 +10,8 @@ import { json_value } from '#scripts/lib/json-value'
 import { unit_worker_share } from '#scripts/test/unit-worker-share'
 import { z } from 'zod'
 import { core_admission, type Admission, type LedgerEntry, type Overflow } from './core-admission'
+import { core_wait, type BudgetWait, type WaitReason } from './core-wait'
+import { held_mark } from './held-mark'
 import { machine_capacity, type MachineBudget, type MachineReading } from './machine-capacity'
 
 // A machine-wide weighted core budget with admission control.
@@ -55,11 +57,22 @@ const MIN_BUDGET = 1
 // and spell check numbers are `gate-plan.ts`'s measured table, floored. The whole-tree eslint scan
 // behind `josh lines` and `josh refactor:scan` runs in one process: measured cold on the 11-core
 // machine on 2026-10-06, 113s of CPU over 98s of wall, so it gets one core.
+//
+// The rest ran outside the ledger until joshuafolkken/kit#3944, measured with `/usr/bin/time -l` on the
+// same machine on 2026-10-17 under a load average of 16. Every one stays under one core, so each takes
+// one: `prettier --check` over 40 staged files 2.1s of CPU over 1.7s of wall (`format`), `josh
+// retrospective` 16.5s over 19.8s, and a fresh lane's `pnpm install --frozen-lockfile` 1.9s over 6.1s.
+// `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: 2,
 	type_check: 1,
 	spell_check: 1,
 	eslint_scan: 1,
+	format: 1,
+	retrospective: 1,
+	install: 1,
+	e2e: 2,
 } as const
 
 // **The memory each heavy tool holds, declared beside its cores**: peak
@@ -67,33 +80,37 @@ const CORE_WEIGHTS = {
 // 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.
 const MEMORY_MB = {
 	lint: 2400,
 	type_check: 1300,
 	spell_check: 350,
 	eslint_scan: 2400,
 	unit_worker: 350,
+	format: 300,
+	retrospective: 900,
+	install: 100,
 } as const
 
-// **The environment mark that says a parent already holds this process's cores**
-// `josh gate` reserves per check and then spawns `pnpm josh lint`. Without
-// the mark, that child's own dispatch would claim a second place for the cores its parent already
-// holds. Every holder sets it, and every child inherits it through the environment and claims nothing.
-const HELD_KEY = 'JOSH_CORE_RESERVED'
-const HELD_VALUE = '1'
-
 // `memory_mb` and `admitted_at` are optional so a marker an older `josh` wrote still reads: it holds no
 // declared memory, and it counts as load from outside the ledger until it is gone.
+// `command`, `checkout`, `lane`, `lanes_root` and `wait_reason` name a waiting claim on `run:board`
+// (`core-wait.ts`).
 const reservation_schema = process_owner_schema.extend({
 	weight: z.number(),
 	claimed_at: z.number(),
 	memory_mb: z.number().optional(),
 	admitted_at: z.number().optional(),
+	command: z.string().optional(),
+	checkout: z.string().optional(),
+	lane: z.string().optional(),
+	lanes_root: z.string().optional(),
+	wait_reason: z.enum(core_wait.WAIT_REASONS).optional(),
 })
 
 type Reservation = z.infer<typeof reservation_schema>
 
-type ReservationFields = Pick<Reservation, 'weight' | 'claimed_at' | 'memory_mb' | 'admitted_at'>
+type ReservationFields = Omit<Reservation, 'pid' | 'process_start'>
 
 interface LiveReservation extends LedgerEntry {
 	reservation: Reservation
@@ -102,6 +119,9 @@ interface LiveReservation extends LedgerEntry {
 interface ReserveOptions {
 	budget?: number
 	memory_mb?: number | undefined
+	// What the claim is for, named on the waiting line and on `run:board`.
+	command?: string | undefined
+	report?: (line: string) => void
 	read_machine?: () => Promise<MachineReading>
 	wait_cap_ms?: number
 	poll_interval_ms?: number
@@ -195,6 +215,10 @@ function write_reservation(target: string, fields: ReservationFields): void {
 	stamp_file.replace_stamp(target, { ...process_identity.own_fields(), ...fields })
 }
 
+function report_wait(line: string): void {
+	process.stderr.write(`${line}\n`)
+}
+
 // The clock and cadence a wait runs on, resolved apart from the ledger fields so `reserve` stays under
 // the complexity limit — each default is a branch.
 interface TimingConfig {
@@ -206,6 +230,7 @@ interface TimingConfig {
 
 interface WaitContext extends TimingConfig {
 	read_machine: () => Promise<MachineReading>
+	report: (line: string) => void
 	key: string
 	target: string
 	directory: string
@@ -259,6 +284,19 @@ function overflow_of(
 	}
 }
 
+// The marker records why the claim waits, rewritten only when the reason changes, and the command says
+// so once, when its wait starts.
+function mark_waiting(context: WaitContext, reason: WaitReason): void {
+	const previous = context.fields.wait_reason
+
+	if (previous === reason) return
+
+	context.fields = { ...context.fields, wait_reason: reason }
+	write_reservation(context.target, context.fields)
+
+	if (previous === undefined) context.report(core_wait.wait_line(context.fields.command, reason))
+}
+
 async function poll_admission(context: WaitContext): Promise<Admission | undefined> {
 	const reservations = live_reservations(context.directory)
 	const budget = await current_budget(context, reservations)
@@ -269,6 +307,8 @@ async function poll_admission(context: WaitContext): Promise<Admission | undefin
 		return admit(context, overflow_of(context, reservations, budget))
 	}
 
+	mark_waiting(context, core_wait.wait_reason(context.key, reservations, budget))
+
 	return undefined
 }
 
@@ -288,13 +328,33 @@ async function await_admission(context: WaitContext): Promise<Admission> {
 	return admission
 }
 
+// What a wait reads the machine through and reports its start to.
+function resolve_ports(options: ReserveOptions): Pick<WaitContext, 'read_machine' | 'report'> {
+	return {
+		read_machine: options.read_machine ?? machine_capacity.read_machine,
+		report: options.report ?? report_wait,
+	}
+}
+
+// The checkout the claim runs in, so `run:board` can say whose claim waits. The ledger is the
+// machine's, so the checkout may be another repository's (`core-wait.ts` → `where_of`).
+function claim_fields(
+	weight: number,
+	claimed_at: number,
+	options: ReserveOptions,
+): ReservationFields {
+	const { memory_mb, command } = options
+
+	return { weight, claimed_at, memory_mb, command, ...core_wait.where_of(process.cwd()) }
+}
+
 async function reserve(weight: number, options: ReserveOptions = {}): Promise<Handle> {
 	const timing = resolve_timing(options)
 	const directory = options.directory ?? PLATFORM_TEMP_ROOT
 	const claimed_at = timing.now()
 	const name = marker_name(randomUUID())
 	const target = path.join(directory, name)
-	const fields = { weight, claimed_at, memory_mb: options.memory_mb }
+	const fields = claim_fields(weight, claimed_at, options)
 
 	write_reservation(target, fields)
 	const admission = await await_admission({
@@ -305,58 +365,42 @@ async function reserve(weight: number, options: ReserveOptions = {}): Promise<Ha
 		budget: normalize_budget(options.budget ?? availableParallelism()),
 		deadline: claimed_at + timing.wait_cap_ms,
 		fields,
-		read_machine: options.read_machine ?? machine_capacity.read_machine,
+		...resolve_ports(options),
 	})
 
 	return { target, admission }
 }
 
+// The claims waiting in the ledger now, for a `run:board` running in `home`.
+function budget_waits(
+	directory: string = PLATFORM_TEMP_ROOT,
+	now: number = Date.now(),
+	home: string = process.cwd(),
+): Array<BudgetWait> {
+	return core_wait.waits_of(live_reservations(directory), now, home)
+}
+
 function release(handle: Handle): void {
 	sweep_marker(handle.target)
 }
 
 // The whole reservation lifetime around a step: claim a place, wait for admission, run, and free the
 // place on any exit. `finally`, so a step that threw still releases its cores. The step is told how it was
-// admitted, so the gate can report one that started past the budget.
+// admitted, so the gate can report one that started past the budget, and the claim's ledger key.
 async function with_core_reservation<T>(
 	weight: number,
-	run: (admission: Admission) => Promise<T>,
+	run: (admission: Admission, key: string) => Promise<T>,
 	options: ReserveOptions = {},
 ): Promise<T> {
 	const handle = await reserve(weight, options)
 
 	try {
-		return await run(handle.admission)
+		return await run(handle.admission, path.basename(handle.target))
 	} finally {
 		release(handle)
 	}
 }
 
-function is_held(): boolean {
-	return process.env[HELD_KEY] === HELD_VALUE
-}
-
-// A function of its own so the restoring write does not sit after an `await`, where
-// `require-atomic-updates` reads any write to `process` as a possible race — the reason `josh.ts`
-// gives `record_exit_code`.
-function set_held_mark(value: string): void {
-	process.env[HELD_KEY] = value
-}
-
-// Marks this process, and every child it spawns, as running inside a held reservation. The previous
-// value comes back afterwards, so a nested holder never clears the mark its outer holder set.
-async function with_held_mark<T>(run: () => Promise<T>): Promise<T> {
-	const previous = process.env[HELD_KEY] ?? ''
-
-	set_held_mark(HELD_VALUE)
-
-	try {
-		return await run()
-	} finally {
-		set_held_mark(previous)
-	}
-}
-
 // **A command's reservation: the gate's claim, unless a parent already holds the cores**
 // `josh-logic.ts` calls this around every command that declares a weight.
 // Each command then only declares its weight, and no command carries a copy of the claim, run and
@@ -368,27 +412,32 @@ async function with_command_reservation<T>(
 	run: () => Promise<T>,
 	options: ReserveOptions = {},
 ): Promise<T> {
-	if (is_held() || unit_worker_share.is_nested_run()) return await run()
+	if (held_mark.is_held() || unit_worker_share.is_nested_run()) return await run()
 
-	return await with_core_reservation(weight, async () => await with_held_mark(run), options)
+	return await with_core_reservation(
+		weight,
+		async (_admission, key) => await held_mark.with_held_mark(run, key),
+		options,
+	)
 }
 
 const core_budget = {
 	CORE_WEIGHTS,
-	HELD_KEY,
-	HELD_VALUE,
+	HELD_KEY: held_mark.HELD_KEY,
+	HELD_VALUE: held_mark.HELD_VALUE,
 	MEMORY_MB,
 	RESERVED_PREFIX,
 	admitted_keys: core_admission.admitted_keys,
 	admitted_load: core_admission.admitted_load,
+	budget_waits,
 	describe_overflow: core_admission.describe_overflow,
-	is_held,
+	is_held: held_mark.is_held,
 	live_reservations,
 	release,
 	reserve,
 	with_command_reservation,
 	with_core_reservation,
-	with_held_mark,
+	with_held_mark: held_mark.with_held_mark,
 }
 
 export type { LiveReservation, Reservation, ReserveOptions }

package/scripts/gate/core-wait.ts

@@ -0,0 +1,130 @@
+import path from 'node:path'
+import { lane_paths } from '#scripts/lane/lane-paths'
+import { core_admission, type LedgerEntry } from './core-admission'
+import type { MachineBudget } from './machine-capacity'
+
+// **Why a claim waits, and who is waiting** (joshuafolkken/kit#3943). A claim held back by the budget
+// used to wait in silence: the command printed nothing and no board showed it, so a lane stalled on
+// memory pressure read the same as one stuck. The waiting claim records its reason on its marker and
+// says it once on its own output; `run:board` draws every marker still waiting. Everything here is a
+// pure function of the ledger and the budget it is handed.
+
+const WAIT_REASONS = ['cores', 'memory', 'pressure'] as const
+
+type WaitReason = (typeof WAIT_REASONS)[number]
+
+// The one wording of each reason, shared by the waiting command's line and the board's.
+const REASON_TEXT: Record<WaitReason, string> = {
+	cores: 'not enough free cores',
+	memory: 'not enough free memory',
+	pressure: 'memory under pressure',
+}
+
+// What the board reads off a marker. Every field but the claim time is optional, so a marker an older
+// `josh` wrote still reads, and one that never waited is not drawn.
+interface WhereFields {
+	checkout?: string | undefined
+	lane?: string | undefined
+	lanes_root?: string | undefined
+}
+
+interface WaitMarker extends WhereFields {
+	claimed_at: number
+	admitted_at?: number | undefined
+	command?: string | undefined
+	wait_reason?: WaitReason | undefined
+}
+
+// Where a waiting claim runs: `lane` is the board's own repository's lane number, which the board
+// links; `elsewhere` names another repository's checkout, which it cannot link. Neither is the board's
+// own main checkout.
+interface BudgetPlace {
+	lane: string | undefined
+	elsewhere: string | undefined
+}
+
+interface BudgetWait extends BudgetPlace {
+	command: string | undefined
+	waited_ms: number
+	reason: WaitReason
+}
+
+// **The cores decide first**: a claim that would not fit even with unlimited memory waits for cores;
+// one that fits on cores waits for memory, named as pressure when the reading saw compression or swap.
+function wait_reason(
+	key: string,
+	reservations: ReadonlyArray<LedgerEntry>,
+	budget: MachineBudget,
+): WaitReason {
+	const cores_only = { cores: budget.cores, memory_mb: Infinity }
+
+	if (!core_admission.is_admitted(key, reservations, cores_only)) return 'cores'
+
+	return budget.memory_pressured === true ? 'pressure' : 'memory'
+}
+
+// The line a waiting command prints once, when its wait starts.
+function wait_line(command: string | undefined, reason: WaitReason): string {
+	return `⏳ ${command ?? 'a step'} waits for the core budget — ${REASON_TEXT[reason]}`
+}
+
+// The lanes root a checkout belongs to: a lane's parent, or the root beside a main checkout. Two
+// checkouts of one repository share it; the ledger is machine-wide, so another repository's do not.
+function lanes_root_of(checkout: string): string {
+	if (lane_paths.lane_issue_of(checkout) === undefined) return lane_paths.lane_root(checkout)
+
+	return path.dirname(path.resolve(checkout))
+}
+
+// Where a claim runs, read by the claimer under its own environment: `JOSH_LANE_ROOT` is a
+// per-project setting, so a board cannot derive another repository's lanes root from its own.
+function where_of(checkout: string): Required<WhereFields> {
+	return { checkout, lane: lane_paths.lane_issue_of(checkout), lanes_root: lanes_root_of(checkout) }
+}
+
+// Another repository's checkout is named by its lanes root and lane, or its directory, so its lane
+// number is never linked to the board's repository's issue of that number.
+function place_of(marker: WhereFields, home_root: string): BudgetPlace {
+	const { checkout, lane, lanes_root } = marker
+
+	if (checkout === undefined || lanes_root === undefined || lanes_root === home_root) {
+		return { lane, elsewhere: undefined }
+	}
+
+	const name = lane === undefined ? path.basename(checkout) : `${path.basename(lanes_root)}/${lane}`
+
+	return { lane: undefined, elsewhere: name }
+}
+
+function wait_of(marker: WaitMarker, now: number, home_root: string): Array<BudgetWait> {
+	const { command, wait_reason: reason } = marker
+
+	if (reason === undefined || marker.admitted_at !== undefined) return []
+
+	return [{ command, ...place_of(marker, home_root), waited_ms: now - marker.claimed_at, reason }]
+}
+
+// The claims still waiting, longest first, placed against the board's checkout `home`.
+function waits_of(
+	entries: ReadonlyArray<{ reservation: WaitMarker }>,
+	now: number,
+	home: string,
+): Array<BudgetWait> {
+	const home_root = lanes_root_of(home)
+
+	return entries
+		.flatMap((entry) => wait_of(entry.reservation, now, home_root))
+		.toSorted((left, right) => right.waited_ms - left.waited_ms)
+}
+
+const core_wait = {
+	REASON_TEXT,
+	WAIT_REASONS,
+	wait_line,
+	wait_reason,
+	waits_of,
+	where_of,
+}
+
+export type { BudgetWait, WaitReason }
+export { core_wait }

package/scripts/gate/free-cores.ts

@@ -0,0 +1,49 @@
+import { availableParallelism } from 'node:os'
+import { core_admission } from './core-admission'
+import { core_budget, type LiveReservation } from './core-budget'
+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-worker-share.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.
+async function read(options: FreeCoresOptions = {}): Promise<number | undefined> {
+	const reading = await (options.read_machine ?? machine_capacity.read_machine)()
+
+	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
+}
+
+const free_cores = { read }
+
+export type { FreeCoresOptions }
+export { free_cores }

package/scripts/gate/gate-ledger.ts

@@ -1,9 +1,9 @@
 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 { 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
@@ -88,6 +88,15 @@ async function start(ledger_path: string | undefined): Promise<GateLedgerStart>
 	return { ledger_path, readings, sampler: start_sampler(readings) }
 }
 
+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,
+	}))
+}
+
 // The caller measures the elapsed time before this, so the end's reading is never part of it.
 async function record(
 	begun: GateLedgerStart,
@@ -101,7 +110,12 @@ 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 = {

package/scripts/gate/gate-plan.ts

@@ -51,6 +51,7 @@ const TYPE_CHECK_LABEL = 'check'
 const UNIT_LABEL = 'test:unit'
 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
@@ -106,7 +107,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.
@@ -397,6 +398,25 @@ function resolve_gate_plan(
 	}
 }
 
+// The unit cap bounded by the cores free of load from outside the core budget's ledger
+// (`free-cores.ts`), so the run count's share is never wider than what is free. A plan with no unit
+// step carries no cap, and an unread machine leaves the cap as resolved (`unit_worker_share.cap_to_free`).
+function bound_by_free(
+	plan: GatePlan,
+	available_cores: number,
+	free_cores: number | undefined,
+): GatePlan {
+	if (!has_unit_check(plan.checks)) return plan
+
+	const unit_worker_cap = unit_worker_share.cap_to_free(
+		plan.unit_worker_cap,
+		free_cores,
+		available_cores,
+	)
+
+	return { ...plan, unit_worker_cap }
+}
+
 // Printed once per run, so a gate that was slow on someone else's machine can be read without
 // re-deriving the plan from their core count.
 //
@@ -440,6 +460,7 @@ function format_gate_plan(
 }
 
 const gate_plan = {
+	EXPORTS_LABEL,
 	GATE_CHECKS,
 	LINT_LABEL,
 	MEASURED_CORES,
@@ -449,6 +470,7 @@ const gate_plan = {
 	TYPE_CHECK_LABEL,
 	UNIT_LABEL,
 	WARNING_CHECKER_LABELS,
+	bound_by_free,
 	check_memory,
 	check_weight,
 	direct_unit_memory,

package/scripts/gate/gate-report.ts

@@ -28,6 +28,9 @@ 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
 }
 
 function is_gate_step_failed(result: GateStepResult): boolean {
@@ -98,6 +101,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
@@ -154,8 +163,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,8 +280,8 @@ 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,
 }