@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/scripts/gate/check-related-order.ts

@@ -2,8 +2,8 @@ import type { CheckResult } from './check-related-section'
 
 // **`test:related` starts only once `lint:related` is green** (joshuafolkken/kit#5387): a lint failure,
 // a document over its budget found in seconds, still let a full-reach `test:related` run its minutes
-// out, and the fix paid that reach again. The other checks still start beside `lint:related`; a run
-// whose `lint:related` is reused starts `test:related` at once. A `test:related --touched` waits the same.
+// out, and the fix paid that reach again. All readers wait for lint's writers; a run
+// whose `lint:related` is reused starts them at once. A `test:related --touched` waits the same.
 
 const LINT_RELATED = 'lint:related'
 const TEST_RELATED = 'test:related'
@@ -36,9 +36,7 @@ async function is_lint_green(lint: Promise<CheckResult>): Promise<boolean> {
 // An executor that runs `lint:related` once, at whichever call asks first, and holds `test:related`
 // behind its verdict.
 function lint_first(execute: CheckExecutor, commands: ReadonlyArray<string>): CheckExecutor {
-	const has_test = commands.some((command) => is_test_related(command))
-
-	if (!has_test || !commands.includes(LINT_RELATED)) return execute
+	if (!commands.includes(LINT_RELATED)) return execute
 
 	const runs = new Map<string, Promise<CheckResult>>()
 
@@ -52,9 +50,10 @@ function lint_first(execute: CheckExecutor, commands: ReadonlyArray<string>): Ch
 
 	async function ordered(command: string): Promise<CheckResult> {
 		if (command === LINT_RELATED) return await lint_run()
-		if (!is_test_related(command)) return await execute(command)
+		const is_green = await is_lint_green(lint_run())
+		if (!is_green && is_test_related(command)) return skipped_result(command)
 
-		return (await is_lint_green(lint_run())) ? await execute(command) : skipped_result(command)
+		return await execute(command)
 	}
 
 	return ordered

package/scripts/gate/check-related.ts

@@ -251,16 +251,26 @@ function exit_code(results: ReadonlyArray<CheckResult>): number {
 async function results_not_reused(
 	tree: GateTree,
 	execute: CheckExecutor,
-): Promise<{ results: Array<CheckResult>; reused: ReadonlySet<string> }> {
-	const reused = await check_related_reuse.reusable(CHECKS, tree)
+): Promise<{ results: Array<CheckResult>; reused: ReadonlySet<string>; verified: GateTree }> {
+	const available = await check_related_reuse.reusable(CHECKS, tree)
+	const reused = available.has(LINT_RELATED) ? available : new Set<string>()
+	let verified = tree
+
+	async function read_after_lint(command: string): Promise<CheckResult> {
+		const result = await execute(command)
+		if (command === LINT_RELATED) verified = await check_related_reuse.read_tree()
+
+		return result
+	}
+
 	const results = await run_checks(
-		execute,
+		read_after_lint,
 		CHECKS.filter((command) => !reused.has(command)),
 	)
 
-	await check_related_reuse.record(results, tree)
+	await check_related_reuse.record(results, verified)
 
-	return { results, reused }
+	return { results, reused, verified }
 }
 
 async function run_fresh(
@@ -269,8 +279,8 @@ async function run_fresh(
 	execute: CheckExecutor,
 	is_full: boolean,
 ): Promise<number> {
+	const { results, reused, verified } = await results_not_reused(tree, execute)
 	const is_started = await review_record_pinned.restart_in_lane(root)
-	const { results, reused } = await results_not_reused(tree, execute)
 	const tail = report_results(results, {
 		is_full,
 		pinned_notice: await check_related_pinned.notice(root, is_started),
@@ -280,7 +290,7 @@ async function run_fresh(
 	const code = exit_code(results)
 
 	await tree_verdict.record(
-		{ before: tree, exit_code: code, tail },
+		{ before: verified, exit_code: code, tail },
 		check_related_reuse.read_tree,
 		VERDICT_RECORD,
 	)
@@ -295,7 +305,7 @@ async function run_all(
 	execute: CheckExecutor = execute_check,
 	is_full = false,
 ): Promise<number> {
-	const tree = await check_related_reuse.read_tree()
+	const tree = await metrics_totals.rerecorded_tree(check_related_reuse.read_tree, root)
 	const kept = is_full ? undefined : tree_verdict.read(tree, VERDICT_RECORD)
 
 	if (kept === undefined) return await run_fresh(tree, root, execute, is_full)

package/scripts/gate/core-admission.ts

@@ -1,6 +1,6 @@
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { core_budget_timing } from './core-budget-timing'
-import type { LedgerLoad, MachineBudget } from './machine-capacity'
+import type { LedgerLoad, MachineBudget, MachineReading } from './machine-capacity'
 
 // The ledger's admission arithmetic, kept apart from the markers `core-budget.ts` reads and writes so
 // that file stays under its line ceiling as the budget grew a memory side.
@@ -65,6 +65,7 @@ interface Admission {
 	overflow: Overflow | undefined
 	granted?: number | undefined
 	waited_ms?: number | undefined
+	decision?: { reason: string; budget: MachineBudget; reading: MachineReading } | undefined
 }
 
 function priority_rank(reservation: LedgerReservation): number {
@@ -177,34 +178,25 @@ function fits_in_order({ own, ahead, running }: Placement, budget: MachineBudget
 	return fits([...running, ...ahead, own], limit)
 }
 
-// **A host-wide swap stall holds the oldest claim too** (joshuafolkken/kit#4451). Running alone skipped
-// the memory test, so a lone gate started lint into a stall and prolonged it.
-// Only both together hold: traffic alone is this machine's daily norm (#4313), and a claim
-// heavier than free memory on a calm machine would wait for room that never comes.
-function is_swap_stalled({ own, running }: Placement, budget: MachineBudget): boolean {
-	const needed_mb = sum_load([...running, own]).memory_mb
-
-	return budget.memory_pressured === true && needed_mb > budget.memory_mb
-}
-
-// **The wait cap does not release a swap-stall hold, for any claim** (joshuafolkken/kit#4451): the cap
-// exists so a wedged sibling cannot stall the machine for good, but a stall ends when its traffic stops
-// or its memory is free, so the hold cannot outlive it. Released at the cap, lint started into
-// the stall it waited on and prolonged it — and holding only a lone claim let a gate's
-// later claims start into the stall at their own caps, after which the lint was no longer alone.
-function is_swap_held(
+// Non-unit memory cannot be narrowed or released by a CPU deadline. Unit launchers size their
+// workers from free memory after admission; retain that exemption unless swap pressure holds them.
+function is_memory_held(
 	key: string,
 	reservations: ReadonlyArray<LedgerEntry>,
 	budget: MachineBudget,
 ): boolean {
 	const placement = place(key, reservations)
 
-	return placement !== undefined && is_swap_stalled(placement, budget)
+	if (placement === undefined) return false
+	if (placement.own.reservation.is_unit === true && budget.memory_pressured !== true) return false
+
+	return !fits([...placement.running, placement.own], {
+		cores: Infinity,
+		memory_mb: budget.memory_mb,
+	})
 }
 
-// The oldest claim runs alone once nothing else does — unless the machine is overloaded, where it waits
-// like the first waiter (`first_waiter_limit`) until a poll reads the load back under the cap, or stalled
-// on swap (`is_swap_stalled`), where it waits until the traffic stops or its memory is free.
+// CPU-only exemption for the oldest claim; is_admitted checks memory before reaching it.
 function runs_alone(placement: Placement, budget: MachineBudget): boolean {
 	if (
 		!placement.is_oldest ||
@@ -214,16 +206,11 @@ function runs_alone(placement: Placement, budget: MachineBudget): boolean {
 		return false
 	}
 
-	return budget.is_overloaded !== true && !is_swap_stalled(placement, budget)
+	return budget.is_overloaded !== true
 }
 
 // **Admission: the oldest claim runs once nothing else does, then claim order, then a bounded pass.**
-// The oldest runs because a single check heavier than the whole machine must not wait for room that will
-// never come — except into a swap stall (`is_swap_stalled`), which passes. Claims that passed it are
-// still running beside it, and their room does come back, so it waits for them rather than starting on
-// top of their cores and memory. A later claim runs when every running claim, every claim waiting
-// ahead of it and its own load fit the budget — the first waiter against the ledger alone
-// (`first_waiter_limit`) — or when it may pass the waiters ahead (`may_pass`).
+// The CPU exemption never lifts a memory hold. Later claims fit in order or make a bounded pass.
 function is_admitted(
 	key: string,
 	reservations: ReadonlyArray<LedgerEntry>,
@@ -231,7 +218,7 @@ function is_admitted(
 ): boolean {
 	const placement = place(key, reservations)
 
-	if (placement === undefined) return false
+	if (placement === undefined || is_memory_held(key, reservations, budget)) return false
 	if (runs_alone(placement, budget)) return true
 
 	return fits_in_order(placement, budget) || may_pass(placement, budget)
@@ -384,7 +371,7 @@ const core_admission = {
 	compare_claim,
 	describe_overflow,
 	is_admitted,
-	is_swap_held,
+	is_memory_held,
 	is_too_narrow,
 	ledger_load,
 	narrowed_weight,

package/scripts/gate/core-budget-poll.ts

@@ -0,0 +1,183 @@
+import { busy_average } from './busy-average'
+import { core_admission, type Admission, type Overflow } from './core-admission'
+import type { LiveReservation, WaitContext } from './core-budget'
+import { core_reservation } from './core-reservation'
+import { core_wait, type WaitReason } from './core-wait'
+import { machine_capacity, type MachineBudget, type MachineReading } from './machine-capacity'
+
+function check_measurement(command: string, reading: MachineReading): void {
+	if (reading.memory_supported === true && !Number.isFinite(reading.available_mb)) {
+		throw new Error(`${command}: memory measurement failed; admission refused`)
+	}
+}
+
+function check_capacity(command: string, requested: number, total_mb: number | undefined): void {
+	if (total_mb === undefined) return
+
+	if (requested > total_mb) {
+		throw new Error(
+			`${command}: requested ${String(requested)} MB exceeds physical memory ${String(total_mb)} MB`,
+		)
+	}
+}
+
+function check_memory(context: WaitContext, reading: MachineReading): void {
+	const requested = context.fields.memory_mb ?? 0
+
+	if (requested === 0) return
+	const command = context.fields.command ?? 'a step'
+	const minimum =
+		context.fields.is_unit === true ? requested / Math.max(1, context.fields.weight) : requested
+
+	check_measurement(command, reading)
+	check_capacity(command, minimum, reading.total_mb)
+}
+
+async function current_reading(
+	context: WaitContext,
+	reservations: ReadonlyArray<LiveReservation>,
+): Promise<{ budget: MachineBudget; reading: MachineReading }> {
+	const reading = await context.read_machine()
+	const ledger = core_admission.ledger_load(reservations, context.now())
+
+	check_memory(context, reading)
+	context.busy_samples = busy_average.with_reading(
+		context.busy_samples,
+		reading,
+		ledger.cores,
+		context.now(),
+	)
+	const mean = busy_average.averaged(reading, context.busy_samples, ledger.cores)
+
+	context.ease = busy_average.with_ease(context.ease, mean.busy_cores, context.now())
+
+	return { budget: machine_capacity.machine_budget(context.budget, mean, ledger), reading }
+}
+
+interface Decision {
+	budget: MachineBudget
+	reading: MachineReading
+	granted: number | undefined
+	overflow?: Overflow | undefined
+	reason: string
+}
+
+function admit(context: WaitContext, decision: Decision): Admission {
+	const admitted_at = context.now()
+	const { granted, overflow, reason, budget, reading } = decision
+
+	core_reservation.write_reservation(context.target, { ...context.fields, admitted_at, granted })
+
+	return {
+		overflow,
+		granted,
+		waited_ms: admitted_at - context.fields.claimed_at,
+		decision: { reason, budget, reading },
+	}
+}
+
+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 }
+	core_reservation.write_reservation(context.target, context.fields)
+	if (previous === undefined) context.report(core_wait.wait_line(context.fields.command, reason))
+}
+
+function spent_reason(
+	context: WaitContext,
+	reservations: ReadonlyArray<LiveReservation>,
+	budget: MachineBudget,
+): string | undefined {
+	const now = context.now()
+
+	if (now >= context.deadline) return 'cpu-deadline'
+	const busy_cores = busy_average.mean_busy(context.busy_samples)
+	const room = { busy_cores, cores: context.budget, now }
+
+	return busy_average.is_unrelieved(context.ease, now, context.ease_window_ms) &&
+		core_wait.is_held_in_vain(context.key, reservations, budget, room)
+		? 'cpu-unrelieved'
+		: undefined
+}
+
+function overflow_reason(
+	context: WaitContext,
+	reservations: ReadonlyArray<LiveReservation>,
+	budget: MachineBudget,
+): string | undefined {
+	if (
+		context.fields.is_strict_admission === true ||
+		core_admission.is_memory_held(context.key, reservations, budget)
+	) {
+		return undefined
+	}
+
+	return spent_reason(context, reservations, budget)
+}
+
+function overflow_of(
+	context: WaitContext,
+	reservations: ReadonlyArray<LiveReservation>,
+	decision: Decision,
+): Admission {
+	const held = core_admission.with_grant(context.key, reservations, decision.granted)
+	const overflow = {
+		waited_ms: context.now() - context.fields.claimed_at,
+		ledger: core_admission.sum_load(held),
+		budget: decision.budget,
+	}
+
+	return admit(context, { ...decision, overflow })
+}
+
+function fit_reason(
+	context: WaitContext,
+	reservations: ReadonlyArray<LiveReservation>,
+	budget: MachineBudget,
+): string {
+	const requested = context.fields.memory_mb ?? 0
+
+	if (context.fields.is_unit === true && requested > budget.memory_mb) {
+		return 'unit-memory-narrowing'
+	}
+
+	const strict = { ...budget, busy_excess: 0, is_overloaded: true }
+
+	return core_admission.is_admitted(context.key, reservations, strict)
+		? 'budget-fit'
+		: 'cpu-first-waiter'
+}
+
+async function poll_admission(
+	context: WaitContext,
+	reservations: ReadonlyArray<LiveReservation>,
+): Promise<Admission | undefined> {
+	const { budget, reading } = await current_reading(context, reservations)
+	const granted = core_admission.narrowed_weight(context.key, reservations, budget.cores)
+	const reason = core_wait.hold_reason(context.key, reservations, budget, granted)
+
+	if (reason === undefined) {
+		return admit(context, {
+			budget,
+			reading,
+			granted,
+			reason: fit_reason(context, reservations, budget),
+		})
+	}
+
+	const overflow = overflow_reason(context, reservations, budget)
+
+	if (overflow !== undefined) {
+		return overflow_of(context, reservations, { budget, reading, granted, reason: overflow })
+	}
+
+	mark_waiting(context, reason)
+
+	return undefined
+}
+
+const core_budget_poll = { poll_admission }
+
+export { core_budget_poll }

package/scripts/gate/core-budget-timing.ts

@@ -4,7 +4,7 @@ const POLL_INTERVAL_MS = 50
 // The longest a reservation waits before it is admitted at minimum width regardless — a heavy step must
 // make progress even if the budget never clears, so a leaked or wedged sibling cannot stall the machine
 // for good. Two minutes is well past a unit suite's worst measured time under six-way load. A claim a
-// swap stall holds is the exception (`core_admission.is_swap_held`).
+// memory shortage holds is the exception (`core_admission.is_memory_held`).
 const WAIT_CAP_MS = 120_000
 // How long the load may go without easing before a held reservation is admitted at minimum width ahead
 // of the cap (`busy_average.is_unrelieved`): ten of the busy average's windows.

package/scripts/gate/core-budget.ts

@@ -7,15 +7,16 @@ import { process_identity } from '#scripts/josh/process-identity'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { poll } from '#scripts/lib/poll'
 import { unit_worker_share } from '#scripts/test/unit-worker-share'
-import { busy_average, type BusySample, type LoadEase } from './busy-average'
-import { core_admission, type Admission, type LedgerEntry, type Overflow } from './core-admission'
+import type { BusySample, LoadEase } from './busy-average'
+import { core_admission, type Admission, type LedgerEntry } from './core-admission'
+import { core_budget_poll } from './core-budget-poll'
 import { core_budget_timing, type TimingConfig } from './core-budget-timing'
 import { core_reservation, type Reservation, type ReservationFields } from './core-reservation'
-import { core_wait, type BudgetWait, type WaitReason } from './core-wait'
+import { core_wait, type BudgetWait } from './core-wait'
 import { core_wait_record, type WaitSink } from './core-wait-record'
 import { core_weights } from './core-weights'
 import { held_mark } from './held-mark'
-import { machine_capacity, type MachineBudget, type MachineReading } from './machine-capacity'
+import { machine_capacity, type MachineReading } from './machine-capacity'
 
 // A machine-wide weighted core budget with admission control.
 //
@@ -175,122 +176,28 @@ interface WaitContext extends TimingConfig {
 // wait's recent readings of load outside the ledger (`busy-average.ts`). That load holds every claim but
 // the first waiter, which it narrows instead (`core_admission.is_admitted`, joshuafolkken/kit#4313) unless
 // the run queue reads the machine overloaded (`machine_capacity.machine_budget`, joshuafolkken/kit#4361).
-async function current_budget(
-	context: WaitContext,
-	reservations: ReadonlyArray<LiveReservation>,
-): Promise<MachineBudget> {
-	const reading = await context.read_machine()
-	const ledger = core_admission.ledger_load(reservations, context.now())
-
-	context.busy_samples = busy_average.with_reading(
-		context.busy_samples,
-		reading,
-		ledger.cores,
-		context.now(),
-	)
-
-	const mean = busy_average.averaged(reading, context.busy_samples, ledger.cores)
-
-	context.ease = busy_average.with_ease(context.ease, mean.busy_cores, context.now())
-
-	return machine_capacity.machine_budget(context.budget, mean, ledger)
-}
-
-// The claim is admitted: its marker records when, which moves its load from "load outside the ledger"
-// to "load the ledger holds" for every later reader — its cores at once, its memory once its tool has
-// had time to ramp up.
-function admit(context: WaitContext, overflow?: Overflow, granted?: number): Admission {
-	const admitted_at = context.now()
-
-	write_reservation(context.target, { ...context.fields, admitted_at, granted })
-
-	return { overflow, granted, waited_ms: admitted_at - context.fields.claimed_at }
-}
-
-function overflow_of(
-	context: WaitContext,
-	reservations: ReadonlyArray<LiveReservation>,
-	budget: MachineBudget,
-): Overflow {
-	return {
-		waited_ms: context.now() - context.fields.claimed_at,
-		ledger: core_admission.sum_load(reservations),
-		budget,
-	}
-}
-
-// 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))
-}
-
-// Past the cap a held claim runs regardless, and so does one held in vain (`core_wait.is_held_in_vain`)
-// once the load has not eased for a window of the wait. A claim a swap stall holds is the exception to both.
-function is_wait_spent(
-	context: WaitContext,
-	reservations: ReadonlyArray<LiveReservation>,
-	budget: MachineBudget,
-): boolean {
-	if (
-		context.fields.is_strict_admission === true ||
-		core_admission.is_swap_held(context.key, reservations, budget)
-	) {
-		return false
-	}
-
-	const now = context.now()
-
-	if (now >= context.deadline) return true
-
-	const busy_cores = busy_average.mean_busy(context.busy_samples)
-	const room = { busy_cores, cores: context.budget, now }
-
-	return (
-		busy_average.is_unrelieved(context.ease, now, context.ease_window_ms) &&
-		core_wait.is_held_in_vain(context.key, reservations, budget, room)
-	)
-}
-
 async function poll_admission(context: WaitContext): Promise<Admission | undefined> {
-	const reservations = live_reservations(context.directory)
-	const budget = await current_budget(context, reservations)
-	// A unit claim is admitted at the room the budget leaves rather than at full width — the first
-	// waiter, which load outside the ledger does not hold, as well as one whose wait is spent.
-	const granted = core_admission.narrowed_weight(context.key, reservations, budget.cores)
-	const reason = core_wait.hold_reason(context.key, reservations, budget, granted)
-
-	if (reason === undefined) return admit(context, undefined, granted)
-
-	if (is_wait_spent(context, reservations, budget)) {
-		const held = core_admission.with_grant(context.key, reservations, granted)
-
-		return admit(context, overflow_of(context, held, budget), granted)
+	try {
+		return await core_budget_poll.poll_admission(context, live_reservations(context.directory))
+	} catch (error) {
+		sweep_marker(context.target)
+		throw error
 	}
-
-	mark_waiting(context, reason)
-
-	return undefined
 }
 
-// Poll the ledger until this reservation is admitted, or until the wait cap — or, for a claim held in
-// vain (`core_wait.is_held_in_vain`), the load not easing — admits it at minimum width.
-// A solo run is admitted on the first read — its own claim is the ledger's head — so the loop body never
-// runs and the wait costs nothing.
+// Poll until non-unit memory fits. Unit launchers retain their downstream worker sizing.
 async function await_admission(context: WaitContext): Promise<Admission> {
 	const admission = await poll.wait_for(async () => await poll_admission(context), {
 		interval_ms: context.poll_interval_ms,
 		sleeper: context.sleep,
 	})
 
-	await core_wait_record.record_admitted(context.fields, context.now(), context.record_wait)
+	await core_wait_record.record_admitted(
+		context.fields,
+		context.now(),
+		context.record_wait,
+		admission,
+	)
 
 	return admission
 }
@@ -343,7 +250,12 @@ async function poll_claim(context: WaitContext): Promise<Handle | undefined> {
 
 	if (admission === undefined) return undefined
 
-	await core_wait_record.record_admitted(context.fields, context.now(), context.record_wait)
+	await core_wait_record.record_admitted(
+		context.fields,
+		context.now(),
+		context.record_wait,
+		admission,
+	)
 
 	return { target: context.target, admission }
 }
@@ -440,7 +352,7 @@ const core_budget = {
 	with_held_mark: held_mark.with_held_mark,
 }
 
-export type { Handle, LiveReservation, ReserveOptions }
+export type { Handle, LiveReservation, ReserveOptions, WaitContext }
 export type { Reservation } from './core-reservation'
 export { core_budget }
 

package/scripts/gate/core-wait-record.ts

@@ -1,13 +1,13 @@
 import type { CoreWaitRecord } from '#scripts/lane/lane-ledger-schema'
 import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
+import type { Admission } from './core-admission'
 
 // How long a claim waited for the core budget, written to the lane ledger once it is admitted, so
 // `josh lane:stats` can split a lane's time into work and waiting (joshuafolkken/kit#4382). The
 // waiting line on stderr says a wait started; this says what it cost.
 //
-// **Only a claim that waited is recorded** — one admitted on its first read cost nothing, and a line per
-// command would bury the waits a lane's time is split by. The lane is the claim's own checkout's, the
-// one `run:board` names the waiting claim by.
+// Immediate admissions use a separate ledger kind so wait counts and medians keep their old meaning.
+// Both kinds retain the admission grounds; legacy waits without those fields still read.
 
 const UNNAMED_COMMAND = 'a step'
 
@@ -17,6 +17,8 @@ interface AdmittedClaim {
 	lane?: string | undefined
 	wait_reason?: string | undefined
 	claimed_at: number
+	weight?: number | undefined
+	memory_mb?: number | undefined
 }
 
 type WaitSink = (wait: CoreWaitRecord) => Promise<void>
@@ -25,10 +27,52 @@ async function to_ledger(wait: CoreWaitRecord): Promise<void> {
 	await lane_ledger_write.record_core_wait(wait)
 }
 
-function wait_of(claim: AdmittedClaim, now: number): CoreWaitRecord | undefined {
-	if (claim.wait_reason === undefined) return undefined
+function request_fields(claim: AdmittedClaim, admission?: Admission): Partial<CoreWaitRecord> {
+	return {
+		requested_cores: claim.weight,
+		granted_cores: admission?.granted ?? claim.weight,
+		memory_mb: claim.memory_mb ?? 0,
+		wait_reason: claim.wait_reason,
+		admission_waited_ms: admission?.waited_ms,
+	}
+}
+
+function admission_fields(claim: AdmittedClaim, admission?: Admission): Partial<CoreWaitRecord> {
+	const decision = admission?.decision
+
+	if (decision === undefined) return {}
+
+	return {
+		...request_fields(claim, admission),
+		admission_reason: decision.reason,
+		overflow: admission?.overflow !== undefined,
+		budget_cores: decision.budget.cores,
+		budget_memory_mb: Number.isFinite(decision.budget.memory_mb)
+			? decision.budget.memory_mb
+			: undefined,
+		available_mb: decision.reading.available_mb,
+		busy_cores: decision.reading.busy_cores,
+		memory_pressured: decision.reading.memory_pressured,
+	}
+}
+
+function should_record(claim: AdmittedClaim, admission?: Admission): boolean {
+	return claim.wait_reason !== undefined || admission?.decision !== undefined
+}
+
+function wait_of(
+	claim: AdmittedClaim,
+	now: number,
+	admission?: Admission,
+): CoreWaitRecord | undefined {
+	if (!should_record(claim, admission)) return undefined
 
-	const wait = { command: claim.command ?? UNNAMED_COMMAND, waited_ms: now - claim.claimed_at }
+	const waited_ms = claim.wait_reason === undefined ? 0 : now - claim.claimed_at
+	const wait = {
+		command: claim.command ?? UNNAMED_COMMAND,
+		waited_ms,
+		...admission_fields(claim, admission),
+	}
 
 	return claim.lane === undefined ? wait : { ...wait, issue: Number(claim.lane) }
 }
@@ -37,8 +81,9 @@ async function record_admitted(
 	claim: AdmittedClaim,
 	now: number,
 	sink: WaitSink = to_ledger,
+	admission?: Admission,
 ): Promise<void> {
-	const wait = wait_of(claim, now)
+	const wait = wait_of(claim, now, admission)
 
 	if (wait !== undefined) await sink(wait)
 }