@joshuafolkken/kit 1.2116.0 → 1.3041.0

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

@@ -1,5 +1,5 @@
 // **Each check prints only its last lines; its whole output is in the log** (joshuafolkken/kit#5204).
-// A `test:related` over hundreds of files printed past 140 KB, past the tool result's size limit, and
+// A `test:related` over hundreds of files printed past the tool result's size limit, and
 // the run typed the same `check:related` again behind a `grep` only to read the verdict. The end of a
 // section is where a check's own verdict and its failures land, so a passed check keeps its last 5
 // lines and a failed one its last 40; `--full` prints the whole output as before.
@@ -8,13 +8,19 @@ const PASSED_TAIL_LINES = 5
 const FAILED_TAIL_LINES = 40
 const FULL_FLAG = '--full'
 
+const NOT_RUN = 'not run'
+
 interface CheckResult {
 	command: string
 	exit_code: number
 	output: string
+	// A check never started because one it waits on failed (`check-related-order.ts`).
+	is_skipped?: boolean
 }
 
 function result_status(result: CheckResult): string {
+	if (result.is_skipped === true) return NOT_RUN
+
 	return result.exit_code === 0 ? 'passed' : `failed (${String(result.exit_code)})`
 }
 
@@ -48,6 +54,7 @@ function is_full_requested(arguments_: ReadonlyArray<string>): boolean {
 
 const check_related_section = {
 	FAILED_TAIL_LINES,
+	NOT_RUN,
 	format_section,
 	is_full_requested,
 	result_status,

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

@@ -29,6 +29,16 @@ async function notice(): Promise<string | undefined> {
 	return found.text
 }
 
-const check_related_unplanned = { notice }
+// **The round prints the same notice** (joshuafolkken/kit#5388): a lane child runs no `check:related`
+// after round 1's fixes, so a file a fix added surfaced only at the ship's preflight. `josh run:review
+// --join` prints it after the review, and a lane child's `josh review:record` after the fixes.
+// Nothing unplanned prints nothing.
+async function show(): Promise<void> {
+	const text = await notice()
+
+	if (text !== undefined) console.info(text)
+}
+
+const check_related_unplanned = { notice, read_unplanned, show }
 
 export { check_related_unplanned }

package/scripts/gate/check-related.ts

@@ -4,15 +4,19 @@ import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { lint_related_scope } from '#scripts/lint/lint-related-scope'
 import { review_record_pinned } from '#scripts/review/review-record-pinned'
+import { test_related_touched } from '#scripts/test/test-related-touched'
 import { execa } from 'execa'
 import run_parallel from 'run-parallel'
+import { check_related_order } from './check-related-order'
 import { check_related_pinned } from './check-related-pinned'
 import { check_related_reuse } from './check-related-reuse'
 import { check_related_section, type CheckResult } from './check-related-section'
 import { check_related_unplanned } from './check-related-unplanned'
 import { gate_labels } from './gate-labels'
 import { gate_log } from './gate-log'
+import type { GateTree } from './gate-tree'
 import { metrics_totals } from './metrics-totals'
+import { tree_verdict } from './tree-verdict'
 import { verification_tail } from './verification-tail'
 
 const COMMAND = 'check:related'
@@ -22,18 +26,23 @@ const LOG_PATH = stamp_file.stamp_path(
 	PROJECT_ROOT,
 	gate_log.GATE_LOG_SUFFIX,
 )
-const LINT_RELATED = 'lint:related'
+const LINT_RELATED = gate_labels.LINT_TARGET
+const TEST_RELATED = 'test:related'
 // The verdict `lint:related` itself prints last, under its own label.
 const LINT_PASSED = verification_tail.format_verdict(lint_related_scope.COMMAND_LABEL, [])
 const CHECKS: ReadonlyArray<string> = [
 	LINT_RELATED,
-	'test:related',
+	TEST_RELATED,
 	gate_labels.TYPE_CHECK_TARGET,
 	'cspell:dot',
 ]
+const TOUCHED_CHECKS: ReadonlyArray<string> = CHECKS.map((command) =>
+	command === TEST_RELATED ? `${TEST_RELATED} ${test_related_touched.TOUCHED_FLAG}` : command,
+)
 const REUSED = 'reused'
+const VERDICT_RECORD = tree_verdict.record_path('check-related')
 const METRICS_STOP =
-	'`josh ship`\'s pre-detach stops on the metrics notice above unless the branch approval already names the total; settle it first (`pnpm josh metrics --accept --reason "<why>"`); the accept needs no `check:related` re-run, as the notice changed no exit code'
+	'`josh run:review`\'s open (and the ship\'s pre-detach behind it) stops on the metrics notice above unless the branch approval already names the total; settle it first (`pnpm josh metrics --accept --reason "<why>"`); the accept needs no `check:related` re-run, as the notice changed no exit code'
 
 type CheckExecutor = (command: string) => Promise<CheckResult>
 type ProcessRunner = (
@@ -63,7 +72,7 @@ async function execute_check(
 	run: ProcessRunner = run_execa,
 ): Promise<CheckResult> {
 	try {
-		const result = await run('pnpm', ['josh', command], { all: true, reject: false })
+		const result = await run('pnpm', ['josh', ...command.split(' ')], { all: true, reject: false })
 
 		return { command, exit_code: result.exitCode ?? 1, output: result.all ?? '' }
 	} catch (error) {
@@ -91,9 +100,10 @@ async function run_checks(
 	execute: CheckExecutor = execute_check,
 	commands: ReadonlyArray<string> = CHECKS,
 ): Promise<Array<CheckResult>> {
+	const ordered = check_related_order.lint_first(execute, commands)
 	const tasks = commands.map((command): run_parallel.Task<CheckResult> => {
 		return (complete): void => {
-			void start_check(command, execute, complete)
+			void start_check(command, ordered, complete)
 		}
 	})
 
@@ -104,8 +114,19 @@ async function run_checks(
 	})
 }
 
+// A check that was not run did not fail; the one it waited on is the failure to fix.
 function failed_commands(results: ReadonlyArray<CheckResult>): ReadonlyArray<string> {
-	return results.filter((result) => result.exit_code !== 0).map((result) => result.command)
+	return results
+		.filter((result) => result.exit_code !== 0 && result.is_skipped !== true)
+		.map((result) => result.command)
+}
+
+function not_run_suffix(results: ReadonlyArray<CheckResult>): string {
+	const skipped = results.filter((result) => result.is_skipped === true)
+
+	if (skipped.length === 0) return ''
+
+	return ` (${check_related_section.NOT_RUN}: ${skipped.map((result) => result.command).join(', ')})`
 }
 
 // The verdict is the last line, as every josh check prints it, so a reader of the tail sees every
@@ -141,20 +162,21 @@ function reused_suffix(reused: ReadonlySet<string>): string {
 }
 
 // A notice is never a failure, so a passing verdict line alone hid it from a reader of the last lines,
-// and the ship's pre-detach stopped on it (joshuafolkken/kit#4987).
+// and `josh run:review`'s open (the ship's pre-detach as the backstop) stops on it
+// (joshuafolkken/kit#4987, joshuafolkken/kit#6023).
 function verdict_line(
 	results: ReadonlyArray<CheckResult>,
 	has_metrics_notice: boolean,
 	reused: ReadonlySet<string>,
 ): string {
-	const line = `${checks_line(results)}${reused_suffix(reused)}`
+	const line = `${checks_line(results)}${not_run_suffix(results)}${reused_suffix(reused)}`
 
 	return has_metrics_notice ? `${line} — ${METRICS_STOP}` : line
 }
 
 // `josh lint:related` ends its section with the metrics growth notice, which the sections after it
-// bury; it is repeated above the verdict so the tail still carries what stops `josh ship`
-// (joshuafolkken/kit#4939).
+// bury; it is repeated above the verdict so the tail still carries what `josh run:review`'s open
+// stops on, the ship's pre-detach as the backstop (joshuafolkken/kit#4939, joshuafolkken/kit#6023).
 function metrics_notice(results: ReadonlyArray<CheckResult>): string | undefined {
 	const output = results.find((result) => result.command === LINT_RELATED)?.output ?? ''
 	const start = output.indexOf(metrics_totals.NOTICE_HEADING)
@@ -179,14 +201,23 @@ interface ReportOptions {
 	is_full?: boolean
 }
 
-function report_notices(notices: ReadonlyArray<string | undefined>): void {
-	for (const notice of notices) {
-		if (notice !== undefined) process.stdout.write(`\n${notice}\n`)
-	}
+function format_notices(notices: ReadonlyArray<string | undefined>): string {
+	return notices.map((notice) => (notice === undefined ? '' : `\n${notice}\n`)).join('')
+}
+
+function verdict_tail(
+	results: ReadonlyArray<CheckResult>,
+	log: { path: string | undefined },
+	verdict: string,
+): string {
+	return `\n${verification_tail.format_tail({ failures: failure_lines(results), log, verdict })}`
 }
 
-function report_results(results: ReadonlyArray<CheckResult>, options: ReportOptions = {}): void {
-	const { is_full, log_target = LOG_PATH, pinned_notice, reused = new Set<string>() } = options
+// Returns what `tree-verdict.ts` keeps for a re-run on the same tree: the metrics notice and the tail.
+// The `test:pinned` and unplanned notices, printed first, read state outside the tree key, so a replay
+// asks them again above the kept text.
+function report_results(results: ReadonlyArray<CheckResult>, options: ReportOptions = {}): string {
+	const { is_full, log_target = LOG_PATH, reused = new Set<string>() } = options
 
 	report_reused(reused)
 
@@ -195,15 +226,16 @@ function report_results(results: ReadonlyArray<CheckResult>, options: ReportOpti
 	}
 
 	const metrics = metrics_notice(results)
-
-	report_notices([metrics, pinned_notice, options.unplanned_notice])
-
 	const log = { path: write_log(results, log_target) }
-	const verdict = verdict_line(results, metrics !== undefined, reused)
+	const tail = verdict_tail(results, log, verdict_line(results, metrics !== undefined, reused))
+
+	const kept = `${format_notices([metrics])}${tail}`
 
 	process.stdout.write(
-		`\n${verification_tail.format_tail({ failures: failure_lines(results), log, verdict })}`,
+		`${format_notices([options.pinned_notice, options.unplanned_notice])}${kept}`,
 	)
+
+	return kept
 }
 
 function exit_code(results: ReadonlyArray<CheckResult>): number {
@@ -216,13 +248,10 @@ function exit_code(results: ReadonlyArray<CheckResult>): number {
 // not move, or a run outside a lane child, starts nothing. A verdict that check already reached on this
 // tree is printed above the verdict line, waited for when this run started it (`check-related-pinned.ts`).
 // A check whose green record still holds is not run (`check-related-reuse.ts`).
-async function run_all(
-	root?: string,
-	execute: CheckExecutor = execute_check,
-	is_full = false,
-): Promise<number> {
-	const is_started = await review_record_pinned.restart_in_lane(root)
-	const tree = await check_related_reuse.read_tree()
+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)
 	const results = await run_checks(
 		execute,
@@ -230,33 +259,92 @@ async function run_all(
 	)
 
 	await check_related_reuse.record(results, tree)
-	report_results(results, {
+
+	return { results, reused }
+}
+
+async function run_fresh(
+	tree: GateTree,
+	root: string | undefined,
+	execute: CheckExecutor,
+	is_full: boolean,
+): Promise<number> {
+	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),
 		unplanned_notice: await check_related_unplanned.notice(),
 		reused,
 	})
+	const code = exit_code(results)
+
+	await tree_verdict.record(
+		{ before: tree, exit_code: code, tail },
+		check_related_reuse.read_tree,
+		VERDICT_RECORD,
+	)
+
+	return code
+}
+
+// A tree this run already answered for, green or red, is answered again with no check run
+// (`tree-verdict.ts`) — unless `--full` asks for the whole output the kept tail does not hold.
+async function run_all(
+	root?: string,
+	execute: CheckExecutor = execute_check,
+	is_full = false,
+): Promise<number> {
+	const tree = await check_related_reuse.read_tree()
+	const kept = is_full ? undefined : tree_verdict.read(tree, VERDICT_RECORD)
+
+	if (kept === undefined) return await run_fresh(tree, root, execute, is_full)
+
+	return tree_verdict.replay(kept, VERDICT_RECORD, [
+		await check_related_pinned.notice(root, false),
+		await check_related_unplanned.notice(),
+	])
+}
+
+// **`--touched` is the mid-run check** (joshuafolkken/kit#5784): its unit stage is `test:related
+// --touched`, so like that run it keeps nothing a brief or the ship reuses — no per-check green, no kept
+// verdict, no `test:pinned` restart. The full-reach run before the brief stays the one that vouches.
+async function run_touched(
+	execute: CheckExecutor = execute_check,
+	is_full = false,
+): Promise<number> {
+	const results = await run_checks(execute, TOUCHED_CHECKS)
+
+	report_results(results, { is_full })
 
 	return exit_code(results)
 }
 
+async function run_cli(argv: ReadonlyArray<string>): Promise<number> {
+	const is_full = check_related_section.is_full_requested(argv)
+
+	if (argv.includes(test_related_touched.TOUCHED_FLAG)) {
+		return await run_touched(execute_check, is_full)
+	}
+
+	return await run_all(undefined, execute_check, is_full)
+}
+
 const check_related = {
 	CHECKS,
 	METRICS_STOP,
 	REUSED,
+	TOUCHED_CHECKS,
 	execute_check,
 	exit_code,
 	report_results,
 	run_all,
 	run_checks,
+	run_touched,
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	process.exitCode = await check_related.run_all(
-		undefined,
-		execute_check,
-		check_related_section.is_full_requested(process.argv),
-	)
+	process.exitCode = await run_cli(process.argv)
 }
 
 export type { CheckExecutor }

package/scripts/gate/check-reuse.ts

@@ -14,10 +14,11 @@ import { moved_paths } from './moved-paths'
 import { verification_inputs, type PrettierIgnored } from './verification-inputs'
 
 // One green record per declared check, so a gate re-run starts only the checks whose inputs moved
-// (`verification-inputs.ts` declares what each reads). The whole-gate record (`gate-skip.ts`) is refused
-// the moment the merge base moves; a main sync that brought in only `.claude/**/*.md` then re-ran lint
-// and the type check over sources neither had a reason to read again. What moved since a record is
-// `moved-paths.ts`.
+// (`verification-inputs.ts` declares what each of kit's checks reads; a project's own gate steps
+// declare theirs with `paths`, `project-step-reuse.ts`). The whole-gate record (`gate-skip.ts`) is
+// refused the moment the merge base moves; a main sync that brought in only `.claude/**/*.md` then
+// re-ran lint and the type check over sources neither had a reason to read again. What moved since a
+// record is `moved-paths.ts`.
 //
 // **A record is reuse of a result, not a check dropped**: no base, an empty changed-file map, an
 // unreadable base diff, no root or a fingerprint of the check's tools and environment that moved
@@ -27,10 +28,32 @@ import { verification_inputs, type PrettierIgnored } from './verification-inputs
 
 const CHECK_PREFIX = 'josh-gate-check-'
 
-function check_stamp(label: string): FileMapStampAccess {
-	return file_map_stamp.create(CHECK_PREFIX, PROJECT_ROOT, () =>
-		verification_inputs.fingerprint([label]),
-	)
+interface InputContext {
+	is_ignored: PrettierIgnored
+	root: string
+}
+
+// What one check reads: the fingerprint its record is taken under, and whether a moved path is one of
+// its inputs. A label with no inputs declared answers `undefined`, and is never reused or recorded.
+interface CheckInputs {
+	fingerprint: () => string
+	touches: (moved: ReadonlyArray<string>, context: InputContext) => Promise<boolean>
+}
+
+type InputsOf = (label: string) => CheckInputs | undefined
+
+function declared_inputs(label: string): CheckInputs | undefined {
+	if (!verification_inputs.is_declared(label)) return undefined
+
+	return {
+		fingerprint: () => verification_inputs.fingerprint([label]),
+		touches: async (moved, context) =>
+			await check_inputs.touches_inputs(label, moved, context.is_ignored, context.root),
+	}
+}
+
+function check_stamp(inputs: CheckInputs): FileMapStampAccess {
+	return file_map_stamp.create(CHECK_PREFIX, PROJECT_ROOT, inputs.fingerprint)
 }
 
 // Where each check's record lives — a parameter so a test plants records in a directory of its own.
@@ -40,34 +63,36 @@ function default_records(label: string): string {
 	return stamp_file.stamp_path(`${CHECK_PREFIX}${label}-`, PROJECT_ROOT)
 }
 
-interface ReuseContext {
+interface ReuseContext extends InputContext {
 	tree: GateTree
 	records: CheckRecords
-	is_ignored: PrettierIgnored
-	root: string
 }
 
 async function is_stamp_reusable(
-	label: string,
+	inputs: CheckInputs,
 	stamp: FileMapStamp,
 	context: ReuseContext,
 ): Promise<boolean> {
 	const moved = await moved_paths.moved_since(stamp, context.tree)
 
-	if (moved === undefined || !check_stamp(label).describes_inputs(stamp)) return false
+	if (moved === undefined || !check_stamp(inputs).describes_inputs(stamp)) return false
 
-	return !(await check_inputs.touches_inputs(label, moved, context.is_ignored, context.root))
+	return !(await inputs.touches(moved, context))
 }
 
 // The time the check's record was taken, or `undefined` when the check has to run.
-async function reused_at(label: string, context: ReuseContext): Promise<string | undefined> {
-	const stamp = verification_inputs.is_declared(label)
-		? check_stamp(label).read(context.records(label))
-		: undefined
+async function reused_at(
+	label: string,
+	inputs: CheckInputs | undefined,
+	context: ReuseContext,
+): Promise<string | undefined> {
+	if (inputs === undefined) return undefined
+
+	const stamp = check_stamp(inputs).read(context.records(label))
 
 	if (stamp === undefined) return undefined
 
-	return (await is_stamp_reusable(label, stamp, context)) ? stamp.taken_at : undefined
+	return (await is_stamp_reusable(inputs, stamp, context)) ? stamp.taken_at : undefined
 }
 
 async function read_root(): Promise<string | undefined> {
@@ -83,6 +108,7 @@ async function reusable_checks(
 	labels: ReadonlyArray<string>,
 	tree: GateTree,
 	records: CheckRecords = default_records,
+	inputs_of: InputsOf = declared_inputs,
 ): Promise<ReadonlyMap<string, string>> {
 	const root = await read_root()
 
@@ -90,29 +116,34 @@ async function reusable_checks(
 
 	const context = { tree, records, root, is_ignored: check_inputs.prettier_ignored(root) }
 	const answers = await Promise.all(
-		labels.map(async (label) => [label, await reused_at(label, context)] as const),
+		labels.map(
+			async (label) => [label, await reused_at(label, inputs_of(label), context)] as const,
+		),
 	)
 
 	return new Map(answers.flatMap(([label, at]) => (at === undefined ? [] : [[label, at] as const])))
 }
 
-function is_recordable(result: GateStepResult): boolean {
-	return (
-		verification_inputs.is_declared(result.label) &&
-		!gate_report.is_gate_step_failed(result) &&
-		gate_report.has_nothing_to_say(result)
-	)
+// The inputs a silently passed check is recorded under, or `undefined` when it is not recorded.
+function recordable_inputs(result: GateStepResult, inputs_of: InputsOf): CheckInputs | undefined {
+	const is_quiet_pass =
+		!gate_report.is_gate_step_failed(result) && gate_report.has_nothing_to_say(result)
+
+	return is_quiet_pass ? inputs_of(result.label) : undefined
 }
 
 function write_records(
 	results: ReadonlyArray<GateStepResult>,
 	tree: GateTree,
 	records: CheckRecords,
+	inputs_of: InputsOf,
 ): void {
-	const recordable = results.filter((result) => is_recordable(result))
+	for (const result of results) {
+		const inputs = recordable_inputs(result, inputs_of)
 
-	for (const { label } of recordable) {
-		check_stamp(label).write(tree.files, records(label), tree.base)
+		if (inputs !== undefined) {
+			check_stamp(inputs).write(tree.files, records(result.label), tree.base)
+		}
 	}
 }
 
@@ -123,13 +154,14 @@ async function record_green_checks(
 	results: ReadonlyArray<GateStepResult>,
 	tree: GateTree,
 	records: CheckRecords = default_records,
+	inputs_of: InputsOf = declared_inputs,
 ): Promise<void> {
 	try {
 		const after = await review_tree.read_changed_tree()
 
 		if (JSON.stringify(after) !== JSON.stringify(tree.files)) return
 
-		write_records(results, { files: after, base: tree.base }, records)
+		write_records(results, { files: after, base: tree.base }, records, inputs_of)
 	} catch {
 		/* no record is the safe answer */
 	}
@@ -137,5 +169,5 @@ async function record_green_checks(
 
 const check_reuse = { DEFAULT_RECORDS: default_records, record_green_checks, reusable_checks }
 
-export type { CheckRecords }
+export type { CheckInputs, CheckRecords, InputsOf }
 export { check_reuse }

package/scripts/gate/command-memory.ts

@@ -9,7 +9,7 @@ import { core_weights } from './core-weights'
 //
 // **`reserved-run` counted a wrapped command's cores and no memory**: a lane ran
 // `reserved-run 4 -- sh -c '… eslint . --concurrency 4 …'`, typed eslint held a TypeScript program per
-// worker, and the 12 GB process was admitted beside four other lanes until the machine swapped. The
+// worker, and the process was admitted beside other lanes until the machine swapped. The
 // estimate here is what the wrapper now reserves, and the same reading is what `lane-direct-tool`
 // refuses a multi-worker eslint on.
 //
@@ -20,8 +20,8 @@ import { core_weights } from './core-weights'
 // (`bash <<'EOF'`), when it is read as a line of its own, the `sh -c` escape spelled another way.
 //
 // **The estimate is the largest tool's, not the sum**: the commands of one line run one after another,
-// so only one of them is resident at a time. A line with no known tool is `undefined`, the 0 MB it
-// counted before — `reserved-run 1 -- pnpm josh audit` reserves its own, and is not counted twice.
+// so only one of them is resident at a time. A line with no known tool is `undefined`:
+// `reserved-run 2 -- pnpm install` reserves no memory beside its cores.
 
 interface ToolCall extends ProgramCall {
 	// Inside a `pnpm josh reserved-run … --`, the budgeted path.
@@ -186,7 +186,13 @@ function runs_multi_worker_eslint(
 	)
 }
 
-const command_memory = { estimated_memory_mb, runs_multi_worker_eslint, tool_calls_of, workers_of }
+const command_memory = {
+	estimated_memory_mb,
+	runs_multi_worker_eslint,
+	tool_calls_of,
+	workers_of,
+	wrapped_command_of,
+}
 
 export { command_memory }
 export type { ToolCall }

package/scripts/gate/core-admission.ts

@@ -38,6 +38,9 @@ interface LedgerReservation {
 	admitted_at?: number | undefined
 	granted?: number | undefined
 	is_unit?: boolean | undefined
+	is_strict_admission?: boolean | undefined
+	is_memory_pending?: boolean | undefined
+	is_priority?: boolean | undefined
 }
 
 interface LedgerEntry {
@@ -64,9 +67,19 @@ interface Admission {
 	waited_ms?: number | undefined
 }
 
+function priority_rank(reservation: LedgerReservation): number {
+	return reservation.is_priority === true ? 0 : 1
+}
+
 // Claim order, with the filename as the tiebreak so every reader agrees on the same ledger order
-// however the wall clock rounded two near-simultaneous claims.
+// however the wall clock rounded two near-simultaneous claims. **A priority claim
+// (`core-priority.ts`) is ordered before every claim without the mark**, so it waits only for the room
+// running claims hold and the priority claims before it (joshuafolkken/kit#5767).
 function compare_claim(left: LedgerEntry, right: LedgerEntry): number {
+	const by_priority = priority_rank(left.reservation) - priority_rank(right.reservation)
+
+	if (by_priority !== 0) return by_priority
+
 	const by_time = left.reservation.claimed_at - right.reservation.claimed_at
 
 	return by_time === 0 ? left.key.localeCompare(right.key) : by_time
@@ -136,10 +149,12 @@ function first_waiter_limit(budget: MachineBudget): LedgerLoad {
 
 // Whether `own` may pass one waiter ahead: any waiter claimed within the window before it, and a heavier
 // one within the longer window (joshuafolkken/kit#4595) — a two-core `lint:related` queued for most of the
-// cap behind a unit claim of five cores that the running claims had no room for.
+// cap behind a unit claim of five cores that the running claims had no room for. A claim never passes a
+// priority waiter ahead of it, which would take the room that waiter was put first for.
 function may_pass_waiter(own: LedgerReservation, waiter: LedgerReservation): boolean {
 	const since_ms = own.claimed_at - waiter.claimed_at
 
+	if (priority_rank(waiter) < priority_rank(own)) return false
 	if (since_ms < BYPASS_WINDOW_MS) return true
 
 	return waiter.weight > own.weight && since_ms < HEAVIER_BYPASS_WINDOW_MS
@@ -163,8 +178,8 @@ function fits_in_order({ own, ahead, running }: Placement, budget: MachineBudget
 }
 
 // **A host-wide swap stall holds the oldest claim too** (joshuafolkken/kit#4451). Running alone skipped
-// the memory test, so a lone gate started a 2.4 GB lint into a stall with 1.7 GB free and swapped it
-// for 830 s. Only both together hold: traffic alone is this machine's daily norm (#4313), and a claim
+// 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
@@ -174,8 +189,8 @@ function is_swap_stalled({ own, running }: Placement, budget: MachineBudget): bo
 
 // **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, a 2.4 GB lint started into
-// the stall it waited on and swapped for the same 830 s — and holding only a lone claim let a gate's
+// 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(
 	key: string,
@@ -191,7 +206,13 @@ function is_swap_held(
 // 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.
 function runs_alone(placement: Placement, budget: MachineBudget): boolean {
-	if (!placement.is_oldest || placement.running.length > 0) return false
+	if (
+		!placement.is_oldest ||
+		placement.running.length > 0 ||
+		placement.own.reservation.is_strict_admission === true
+	) {
+		return false
+	}
 
 	return budget.is_overloaded !== true && !is_swap_stalled(placement, budget)
 }
@@ -252,7 +273,11 @@ function admitted_keys(
 function is_ramped(reservation: LedgerReservation, now: number): boolean {
 	const { admitted_at } = reservation
 
-	return admitted_at !== undefined && now - admitted_at >= RAMP_UP_MS
+	return (
+		reservation.is_memory_pending !== true &&
+		admitted_at !== undefined &&
+		now - admitted_at >= RAMP_UP_MS
+	)
 }
 
 // **The load the ledger already accounts for.** CPU use shows in the reading the moment a tool starts,
@@ -356,6 +381,7 @@ const core_admission = {
 	RAMP_UP_MS,
 	admitted_keys,
 	admitted_load,
+	compare_claim,
 	describe_overflow,
 	is_admitted,
 	is_swap_held,