@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/lane/lane-session-broker.ts

@@ -1,18 +1,19 @@
 import { randomUUID } from 'node:crypto'
 import { mkdirSync, readFileSync, rmSync, unlinkSync } from 'node:fs'
 import path from 'node:path'
-import { setTimeout as sleep } from 'node:timers/promises'
 import { git_common_directory } from '#scripts/git/git-common-directory'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { atomic_write } from '#scripts/lib/atomic-write'
 import { json_value } from '#scripts/lib/json-value'
+import { poll } from '#scripts/lib/poll'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { z } from 'zod'
 import { lane_broker_server, type BrokerServer } from './lane-broker-server'
 import type { LaneInfo } from './lane-registry'
 import { lane_session_action, type BrokerAction, type BrokerAnswer } from './lane-session-action'
+import { lane_session_reread } from './lane-session-reread'
 
 // The sessions a lane child's detached `josh ship` cannot start itself, started for it by a process
 // that can: the round-1 and round-2 reviewer, and the fresh child a stopped ship hands back to. An
@@ -38,9 +39,7 @@ const REQUEST_LIMIT_MINUTES: Readonly<Record<BrokerAction['kind'], number>> = {
 	review: 30,
 	relaunch: 2,
 }
-const request_schema = z
-	.object({ session: z.uuid(), nonce: z.uuid(), action: lane_session_action.action_schema })
-	.strict()
+const { request_schema } = lane_session_action
 // **A request this broker cannot read is still answered**: the supervisor reloads on new code only at
 // its next pass boundary (`run-wake-code.ts`), so until then a lane's ship can run a newer main than
 // the broker's, and a field the ship added made the request unreadable and
@@ -49,6 +48,15 @@ const request_schema = z
 // broker's schema had never learned even on one main (joshuafolkken/kit#4489).
 const envelope_schema = z.looseObject({ session: z.uuid(), nonce: z.uuid() })
 const UNREADABLE_REASON = 'the broker could not read the request'
+// **A refused request is read as a version difference, never dropped silently** (joshuafolkken/kit#4714):
+// the refusal marks the supervisor's code as suspect, so its next pass re-hashes the code even where the
+// commit did not move or the hash at its start could not be read, and reloads when it differs. Only the
+// `run:wake` supervisor takes the mark: an OpenAI lane's own supervisor never re-checks its code.
+// **Before it is refused, the code on disk reads it** (`lane-session-reread.ts`), so a schema main widened
+// since the supervisor started is answered now rather than after the reload (joshuafolkken/kit#4732).
+const VERSION_NOTE =
+	"the broker's code differs from the ship's; a run:wake supervisor re-checks its code at its next pass"
+const refusal = { is_pending: false }
 const response_schema = z
 	.object({
 		session: z.uuid(),
@@ -103,15 +111,31 @@ function refused_field(issue: z.core.$ZodIssue): ReadonlyArray<string> {
 function unreadable(error: z.ZodError): BrokerAnswer {
 	const fields = error.issues.flatMap((issue) => refused_field(issue))
 
-	return failure(`${UNREADABLE_REASON} — ${fields.join('; ')}`)
+	return failure(`${UNREADABLE_REASON} — ${VERSION_NOTE} — ${fields.join('; ')}`)
+}
+
+// The answer of a broker on code older than the request, which the ship can still fall back from.
+function is_unreadable(answer: BrokerAnswer): boolean {
+	return !answer.is_success && answer.reason.includes(UNREADABLE_REASON)
 }
 
 async function answer_request(lane: LaneInfo, received: BrokerEnvelope): Promise<BrokerAnswer> {
 	const parsed = request_schema.safeParse(received)
+	if (parsed.success) return await lane_session_action.answer(lane, parsed.data.action)
 
-	return parsed.success
-		? await lane_session_action.answer(lane, parsed.data.action)
-		: unreadable(parsed.error)
+	refusal.is_pending = true
+
+	return (await lane_session_reread.reread(lane.issue, received)) ?? unreadable(parsed.error)
+}
+
+// Whether a request was refused since the supervisor last asked, clearing the mark — the supervisor
+// re-checks its code on it (`run-wake-code.ts`).
+function take_refusal(): boolean {
+	const { is_pending } = refusal
+
+	refusal.is_pending = false
+
+	return is_pending
 }
 
 // The requests this process's servers are answering now — what the supervisor's reload waits out
@@ -152,21 +176,23 @@ async function serve(
 	response: string,
 	state: { is_running: boolean; current: BrokerResponse },
 ): Promise<void> {
-	let last_nonce = ''
+	const served = { nonce: '' }
 	const target = request_path(lane.directory, lane.issue)
 
-	while (state.is_running) {
+	// Requests are served one at a time, in arrival order: a pass ends only once its request is answered.
+	async function serve_pass(): Promise<true | undefined> {
+		if (!state.is_running) return true
 		const received = read_record(target, envelope_schema)
 
-		if (received?.session === session && received.nonce !== last_nonce) {
-			last_nonce = received.nonce
-			// eslint-disable-next-line no-await-in-loop -- requests are served one at a time, in arrival order
+		if (received?.session === session && received.nonce !== served.nonce) {
+			served.nonce = received.nonce
 			await process_request(lane, response, received, state)
 		}
 
-		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		await sleep(POLL_MS)
+		return undefined
 	}
+
+	await poll.wait_for(serve_pass, { interval_ms: POLL_MS })
 }
 
 // The server record is written before the response, so a ship that finds the response finds it too.
@@ -291,15 +317,15 @@ async function wait_response(
 	const limit_minutes = REQUEST_LIMIT_MINUTES[kind]
 	const deadline = Date.now() + limit_minutes * MINUTE_MS
 
-	while (Date.now() < deadline) {
-		const verdict = response_verdict(target, session, nonce)
-		if (verdict !== undefined) return verdict
+	function verdict_by_deadline(): BrokerAnswer | undefined {
+		if (Date.now() >= deadline) {
+			return failure(`the broker gave no answer within ${String(limit_minutes)} minutes`)
+		}
 
-		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		await sleep(POLL_MS)
+		return response_verdict(target, session, nonce)
 	}
 
-	return failure(`the broker gave no answer within ${String(limit_minutes)} minutes`)
+	return await poll.wait_for(verdict_by_deadline, { interval_ms: POLL_MS })
 }
 
 function live_response(target: string): BrokerResponse | undefined {
@@ -374,11 +400,13 @@ async function request(
 const lane_session_broker = {
 	is_answering,
 	is_serving,
+	is_unreadable,
 	request,
 	request_path,
 	response_path,
 	review_paths: lane_session_action.review_paths,
 	serving_session,
+	take_refusal,
 	with_server,
 }
 

package/scripts/lane/lane-session-reread-main.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { lane_session_reread } from './lane-session-reread'
+
+// The fresh process a lane broker starts for a request its own code refused (`lane-session-reread.ts`):
+// `<issue> <request JSON>` in, the answer's JSON out, exit 1 where it read nothing.
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+	const [issue = '', text = ''] = process.argv.slice(ARGV_OFFSET)
+	const answer = await lane_session_reread.answer_text(issue, text)
+
+	if (answer === undefined) process.exitCode = 1
+	else process.stdout.write(`${JSON.stringify(answer)}\n`)
+}

package/scripts/lane/lane-session-reread.ts

@@ -0,0 +1,51 @@
+import { fileURLToPath } from 'node:url'
+import { json_value } from '#scripts/lib/json-value'
+import { execa } from 'execa'
+import { z } from 'zod'
+import { lane_registry } from './lane-registry'
+import { lane_session_action, type BrokerAnswer } from './lane-session-action'
+
+// **A request the supervisor's loaded code refuses is read again by the code on disk**
+// (joshuafolkken/kit#4732): the `run:wake` supervisor reloads only at a pass boundary, so a schema main
+// widened after it started refused the request a stopped ship sent, and the lane it should have
+// relaunched was parked instead. A fresh process of this file's sibling entry reads the request with
+// the schema main has now and performs the action; it prints the answer only when it read the request,
+// so a disk as old as the supervisor leaves the refusal to the broker.
+
+const ENTRY = fileURLToPath(new URL('lane-session-reread-main.ts', import.meta.url))
+const answer_schema = z.discriminatedUnion('is_success', [
+	z.object({ is_success: z.literal(true) }).strict(),
+	z.object({ is_success: z.literal(false), reason: z.string() }).strict(),
+])
+
+// The fresh process's side: the answer to a request read with the schema on disk, or `undefined` where
+// the request is unreadable or no open lane carries the issue.
+async function answer_text(issue: string, text: string): Promise<BrokerAnswer | undefined> {
+	const request = json_value.parse_with(text, lane_session_action.request_schema)
+	if (request === undefined) return undefined
+
+	const lane = await lane_registry.find_open_lane(issue)
+	if (lane === undefined) return undefined
+
+	return await lane_session_action.answer(lane, request.action)
+}
+
+function last_line(text: string): string {
+	return text.trimEnd().split('\n').at(-1) ?? ''
+}
+
+// The supervisor's side: the fresh process's answer, or `undefined` where it read nothing.
+async function reread(issue: string, received: unknown): Promise<BrokerAnswer | undefined> {
+	const result = await execa(
+		process.execPath,
+		[...process.execArgv, ENTRY, issue, JSON.stringify(received)],
+		{ reject: false, stderr: 'inherit' },
+	)
+	if (result.exitCode !== 0) return undefined
+
+	return json_value.parse_with(last_line(result.stdout), answer_schema)
+}
+
+const lane_session_reread = { answer_text, reread }
+
+export { lane_session_reread }

package/scripts/lane/lane-ship-lap-stats.ts

@@ -0,0 +1,74 @@
+import { lane_check_stats } from './lane-check-stats'
+import { lane_ledger, type LedgerEntry, type ShipLapEntry } from './lane-ledger'
+import { lane_stage_stats } from './lane-stage-stats'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// What the ship stages spent their time on (joshuafolkken/kit#5294): one period's `ship-lap` entries
+// reduced to one row per stage and inner step — median, maximum and runs — printed by `josh lane:stats`
+// under the stage table. The rows follow the stages' running order, a stage's steps longest first.
+//
+// **A row's first cell names both, `<stage>: <step>`**: `lane:value cell` finds a row by its first
+// cell alone, and a stage records several steps while a step (`scoped pair`) runs in several stages.
+
+const COLUMNS = ['ship step', 'median (min)', 'max (min)', 'runs'] as const
+const STAGE_ORDER: ReadonlyArray<string> = lane_stage_stats.STAGES
+
+interface Group {
+	stage: string
+	step: string
+	elapsed: ReadonlyArray<number>
+}
+
+function is_ship_lap(entry: LedgerEntry): entry is ShipLapEntry {
+	return entry.kind === lane_ledger.KIND.SHIP_LAP
+}
+
+function groups_of(laps: ReadonlyArray<ShipLapEntry>): Array<Group> {
+	const keys = [...new Map(laps.map((lap) => [`${lap.stage}\n${lap.step}`, lap])).values()]
+
+	return keys.map(({ stage, step }) => ({
+		stage,
+		step,
+		elapsed: laps
+			.filter((lap) => lap.stage === stage && lap.step === step)
+			.map((lap) => lap.elapsed_ms),
+	}))
+}
+
+// A stage `STAGES` does not name sorts after every stage it does.
+function stage_rank(stage: string): number {
+	const index = STAGE_ORDER.indexOf(stage)
+
+	return index === -1 ? STAGE_ORDER.length : index
+}
+
+function compare(left: Group, right: Group): number {
+	const by_stage = stage_rank(left.stage) - stage_rank(right.stage)
+
+	if (by_stage !== 0) return by_stage
+
+	return (lane_stats.median(right.elapsed) ?? 0) - (lane_stats.median(left.elapsed) ?? 0)
+}
+
+function row_of(group: Group): string {
+	return lane_stats.to_row([
+		`${group.stage}: ${group.step}`,
+		lane_stage_stats.cell(lane_stats.median(group.elapsed)),
+		lane_stage_stats.cell(lane_stats.peak(group.elapsed)),
+		String(group.elapsed.length),
+	])
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const laps = lane_stats.in_window(entries, window).filter(is_ship_lap)
+	const rows = groups_of(laps)
+		.toSorted(compare)
+		.map((group) => row_of(group))
+
+	return [...lane_check_stats.header(COLUMNS), ...rows].join('\n')
+}
+
+const lane_ship_lap_stats = { table }
+
+export { lane_ship_lap_stats }

package/scripts/lane/lane-sleep.ts

@@ -0,0 +1,58 @@
+import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import type { LaneSpan } from './lane-net-time'
+
+// The host's sleep (joshuafolkken/kit#5032): a closed lid stops every lane, yet no park, outage or
+// usage-limit event says so, and its minutes read as work. The load sampler's timer does not fire while
+// the host sleeps, so a tick later than a few intervals is the sign: the wall clock past the tick that
+// was due is recorded as one `sleep` event, and every lane's net time takes it out (`lane-net-time.ts`).
+// A tick merely slowed by load runs well inside the threshold, so a busy host is not read as asleep.
+
+const { EVENT_KIND } = run_event_stream
+
+const GAP_INTERVALS = 3
+
+/** The sleep between two ticks `interval_ms` apart, or `undefined` when the later one was on time. */
+function gap_of(last_ms: number, now_ms: number, interval_ms: number): LaneSpan | undefined {
+	if (now_ms - last_ms <= interval_ms * GAP_INTERVALS) return undefined
+
+	return { from_ms: last_ms + interval_ms, to_ms: now_ms }
+}
+
+function event_of(span: LaneSpan): Omit<RunEvent, 'pos'> {
+	const elapsed_ms = span.to_ms - span.from_ms
+	const minutes = (elapsed_ms / MS_PER_MINUTE).toFixed(1)
+
+	// Stamped at the wake, when it is appended: a stream reader takes its newest line for the newest time.
+	return {
+		at: new Date(span.to_ms).toISOString(),
+		kind: EVENT_KIND.SLEEP,
+		text: `host slept ${minutes} min`,
+		elapsed_ms,
+	}
+}
+
+/** Append `span` as a `sleep` event to `events_path`, or to this checkout's run stream when absent. */
+async function record(span: LaneSpan, events_path?: string): Promise<void> {
+	const target = events_path ?? (await run_event_stream_emit.stream_target())
+
+	if (target === undefined) return
+
+	run_event_stream.append_event(target, event_of(span))
+}
+
+// Every sleep on `events`, oldest first.
+function spans(events: ReadonlyArray<RunEvent>): Array<LaneSpan> {
+	return events
+		.filter((event) => event.kind === EVENT_KIND.SLEEP)
+		.map((event) => {
+			const to_ms = Date.parse(event.at)
+
+			return { from_ms: to_ms - (event.elapsed_ms ?? 0), to_ms }
+		})
+}
+
+const lane_sleep = { gap_of, record, spans }
+
+export { lane_sleep }

package/scripts/lane/lane-spent.ts

@@ -203,7 +203,7 @@ function idle_lanes(
 	return issues_traced(traced_of(lanes, probes), PROCESS_NONE)
 }
 
-const lane_spent = { idle_lanes, kept_reason, lanes_in_use, sort_lanes }
+const lane_spent = { idle_lanes, kept_reason, lanes_in_use, read_unpushed_commits, sort_lanes }
 
 export type { KeptLane, LaneUse, SpentProbes, SpentSort }
 export { lane_spent }

package/scripts/lane/lane-split-stats.ts

@@ -0,0 +1,28 @@
+import { split_resolution } from '#scripts/split/split-resolution'
+import type { LedgerEntry } from './lane-ledger'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// Whether the split notice works: the lanes the notice reached in one period, and how many of them
+// filed a split child, printed by `josh lane:stats` so the notice's effect is read off the ledger
+// rather than searched for in lane transcripts (joshuafolkken/kit#4695). A split child counts
+// whenever it was filed, since a lane may carve the rest out before the notice reaches it.
+
+const COLUMNS = ['noticed lanes', 'split'] as const
+
+// The period's table: `entries` is the whole ledger; the notices are filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const in_period = split_resolution.notices(lane_stats.in_window(entries, window))
+	const noticed = new Set(in_period.map((entry) => entry.issue))
+	const split = split_resolution.split_issues(entries)
+	const split_count = [...noticed].filter((issue) => split.has(issue)).length
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		lane_stats.to_row([String(noticed.size), String(split_count)]),
+	].join('\n')
+}
+
+const lane_split_stats = { table }
+
+export { lane_split_stats }

package/scripts/lane/lane-stage-stats.ts

@@ -1,6 +1,12 @@
 import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
-import { lane_ledger, type DispatchEntry, type LedgerEntry, type StageEntry } from './lane-ledger'
+import {
+	lane_ledger,
+	type DispatchEntry,
+	type LedgerEntry,
+	type MergeEntry,
+	type StageEntry,
+} from './lane-ledger'
 import { lane_stats, type StatsWindow } from './lane-stats'
 
 // Where a lane's time goes: the ledger's `stage` and `dispatch` entries of one period reduced to one
@@ -37,6 +43,7 @@ const STAGES = [
 	lane_ledger.CI_WAIT_STAGE,
 	lane_ledger.CODERABBIT_WAIT_STAGE,
 	lane_ledger.CODERABBIT_RATE_LIMIT_STAGE,
+	lane_ledger.CODERABBIT_RETRIGGER_STAGE,
 	STAGE.REPORT,
 ] as const
 
@@ -53,6 +60,10 @@ function is_dispatch(entry: LedgerEntry): entry is DispatchEntry {
 	return entry.kind === lane_ledger.KIND.DISPATCH
 }
 
+function is_merge(entry: LedgerEntry): entry is MergeEntry {
+	return entry.kind === lane_ledger.KIND.MERGE
+}
+
 function is_number(value: number | undefined): value is number {
 	return value !== undefined
 }
@@ -154,6 +165,7 @@ const lane_stage_stats = {
 	STAGES,
 	cell,
 	is_dispatch,
+	is_merge,
 	is_number,
 	is_stage,
 	medians,

package/scripts/lane/lane-state.ts

@@ -2,6 +2,7 @@ import { readdirSync } from 'node:fs'
 import path from 'node:path'
 import { repository_lock } from '#scripts/git/repository-lock'
 import { session_cite } from '#scripts/issue/session-cite'
+import { durable_state } from '#scripts/josh/durable-state'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { figure_format } from '#scripts/lib/figure-format'
 import { json_value } from '#scripts/lib/json-value'
@@ -12,10 +13,10 @@ import { z } from 'zod'
 // the lane commands (joshuafolkken/kit#4268), so a reader asks the record rather than guessing from
 // the `.env` mtime, the event stream or the `ps` state.
 //
-// **It is a `stamp_path` keyed on the common git directory**, beside the carry record and the event
-// stream and outside every work tree, so it is the same file from the main checkout and from inside
-// the lane, it outlives `lane:close`'s removal of the lane, and `JOSH_TEMP_ROOT` moves it with every
-// other record the run keeps.
+// **It is a `durable_state` path keyed on the common git directory**, in
+// `<common git dir>/josh/run-state` beside the carry record and the event stream and outside every
+// work tree, so it is the same file from the main checkout and from inside the lane, it outlives
+// `lane:close`'s removal of the lane, and a reboot does not clear it.
 //
 // **The write is `stamp_file.replace_stamp`'s** — a temporary file beside the target, renamed over it —
 // so two commands writing the same lane at once leave one whole record, never a torn one. **The read,
@@ -26,7 +27,7 @@ import { z } from 'zod'
 // warned about and the command carries on, as it does when the record cannot be written at all — the
 // record never fails the command that keeps it.
 
-const STATE_PREFIX = 'josh-lane-state-'
+const STATE_PREFIX = durable_state.PREFIX.LANE_STATE
 const STATE_SUFFIX = '.json'
 const LOCK_SUFFIX = '.lock'
 // A change holds the lock for one read and one rename; a wait this long means a holder is stuck.
@@ -85,7 +86,7 @@ type RecordOutcome =
 	{ kind: 'written'; record: LaneStateRecord } | { kind: 'skipped'; reason: string }
 
 function state_path(directory: string, issue: string): string {
-	return stamp_file.stamp_path(STATE_PREFIX, directory, `-${issue}${STATE_SUFFIX}`)
+	return durable_state.path(STATE_PREFIX, directory, `-${issue}${STATE_SUFFIX}`)
 }
 
 function is_allowed(from: LaneState | undefined, to: LaneState): boolean {
@@ -180,9 +181,10 @@ async function outcome_of(change: LaneChange, options: StateOptions): Promise<Re
 	return apply(change, directory, options.now ?? new Date())
 }
 
-async function settled_outcome(change: LaneChange, options: StateOptions): Promise<RecordOutcome> {
+// A write that threw is a write skipped for that reason, never an error out of the lane command.
+async function settled(write: () => Promise<RecordOutcome>): Promise<RecordOutcome> {
 	try {
-		return await outcome_of(change, options)
+		return await write()
 	} catch (error: unknown) {
 		return { kind: 'skipped', reason: error instanceof Error ? error.message : String(error) }
 	}
@@ -192,7 +194,7 @@ async function record_change(
 	change: LaneChange,
 	options: StateOptions = {},
 ): Promise<RecordOutcome> {
-	const outcome = await settled_outcome(change, options)
+	const outcome = await settled(async () => await outcome_of(change, options))
 
 	if (outcome.kind === 'skipped') warn(change, outcome.reason)
 
@@ -255,6 +257,35 @@ async function record_stuck(
 	return locked(root, issue, () => stuck_held(issue, stuck, root))
 }
 
+function adopted_held(change: LaneChange, directory: string, now: Date): RecordOutcome {
+	if (read_record(directory, change.issue) !== undefined) {
+		return { kind: 'skipped', reason: 'a record exists' }
+	}
+
+	return apply_held(change, directory, now)
+}
+
+/**
+ * Write `change` for a lane that has no record, and only then: a record that appeared since the caller
+ * read none is the lane command's, and is never overwritten (`lane:adopt`).
+ */
+async function adopted_outcome(change: LaneChange, options: StateOptions): Promise<RecordOutcome> {
+	const directory = await resolve_directory(options.directory)
+
+	if (directory === undefined) return NO_DIRECTORY
+
+	const now = options.now ?? new Date()
+
+	return locked(directory, change.issue, () => adopted_held(change, directory, now))
+}
+
+async function record_adopted(
+	change: LaneChange,
+	options: StateOptions = {},
+): Promise<RecordOutcome> {
+	return await settled(async () => await adopted_outcome(change, options))
+}
+
 /** Each of `issues`' records, by issue; an issue with none is left out. */
 async function read_states(
 	issues: ReadonlyArray<string>,
@@ -293,6 +324,7 @@ const lane_state = {
 	read_records,
 	read_state,
 	read_states,
+	record_adopted,
 	record_change,
 	record_stuck,
 	state_path,

package/scripts/lane/lane-stats-tables.ts

@@ -0,0 +1,58 @@
+import type { RunEvent } from '#scripts/run/event/run-event-stream'
+import { lane_check_stats } from './lane-check-stats'
+import { lane_ci_path_stats } from './lane-ci-path-stats'
+import { lane_claim_stats } from './lane-claim-stats'
+import { lane_core_wait_stats } from './lane-core-wait-stats'
+import { lane_gap_stats } from './lane-gap-stats'
+import { lane_held_stats } from './lane-held-stats'
+import { lane_implement_stats } from './lane-implement-stats'
+import type { lane_ledger } from './lane-ledger'
+import { lane_paused_spans } from './lane-paused-spans'
+import { lane_process_stats } from './lane-process-stats'
+import { lane_round_one_stats } from './lane-round-one-stats'
+import { lane_round_two_stats } from './lane-round-two-stats'
+import { lane_ship_lap_stats } from './lane-ship-lap-stats'
+import { lane_split_stats } from './lane-split-stats'
+import { lane_stage_stats } from './lane-stage-stats'
+import type { StatsWindow } from './lane-stats'
+import { lane_stop_stats } from './lane-stop-stats'
+import { lane_test_related_stats } from './lane-test-related-stats'
+import type { ToolCall } from './lane-transcript-calls'
+import { lane_transcript_stats } from './lane-transcript-stats'
+
+// The tables `josh lane:stats` prints under the period's row — the single source `josh lane:value
+// cell` reads one cell of (joshuafolkken/kit#5144), so a measurement never copies an aggregation.
+
+interface PeriodRecords {
+	entries: ReturnType<typeof lane_ledger.read_entries>
+	events: ReadonlyArray<RunEvent>
+	calls: ReadonlyArray<ToolCall>
+}
+
+// The tables under the period's row, in the order `lane:stats` prints them.
+function tables_of({ entries, events, calls }: PeriodRecords, window: StatsWindow): Array<string> {
+	return [
+		lane_stage_stats.table(entries, window),
+		lane_ship_lap_stats.table(entries, window),
+		lane_ci_path_stats.table(entries, window),
+		lane_implement_stats.table(calls, window, lane_paused_spans.by_lane(entries)),
+		lane_stop_stats.table(entries, window, events),
+		lane_gap_stats.table(entries, window, events),
+		lane_round_one_stats.table(entries, window),
+		lane_round_two_stats.table(entries, window),
+		lane_split_stats.table(entries, window),
+		lane_held_stats.table(entries, window),
+		lane_core_wait_stats.table(entries, window),
+		lane_process_stats.table(entries, window),
+		lane_check_stats.table(entries, window),
+		lane_claim_stats.table(entries, window),
+		lane_test_related_stats.table(entries, window),
+		lane_test_related_stats.trigger_table(entries, window),
+		lane_transcript_stats.table(calls, window),
+	]
+}
+
+const lane_stats_tables = { tables_of }
+
+export type { PeriodRecords }
+export { lane_stats_tables }

package/scripts/lane/lane-stats.ts

@@ -2,6 +2,7 @@ import { machine_capacity } from '#scripts/gate/machine-capacity'
 import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 import type { DispatchEntry, GateEntry, LedgerEntry, LoadEntry, MergeEntry } from './lane-ledger'
 import { lane_sampler } from './lane-sampler'
+import { lane_tail_stats } from './lane-tail-stats'
 
 // The lane-limit measurement's one table row: the ledger entries of one period
 // reduced to throughput, gate duration and machine load, in the column order
@@ -41,6 +42,8 @@ const COLUMNS = [
 	'merges / hour',
 	'effective lanes',
 	'lane median (min)',
+	`lanes over ${String(lane_tail_stats.OVERRUN_LANE_MINUTES)} min`,
+	'lane p90 (min)',
 	'gate median (min)',
 	'gate max (min)',
 	'load peak',
@@ -236,17 +239,30 @@ function lane_minutes(
 
 // One merge's lane time runs from the latest dispatch of its issue — looked up in the whole ledger,
 // since a lane may start before the window — to the merge. A merge no dispatch preceded is skipped.
-function lane_cell(
+function merge_minutes(
 	entries: ReadonlyArray<LedgerEntry>,
 	period: ReadonlyArray<LedgerEntry>,
-): string {
+): Array<number> {
 	const dispatches = entries.filter(is_dispatch)
-	const minutes = period
+
+	return period
 		.filter((entry) => is_merge(entry))
 		.map((merge) => lane_minutes(dispatches, merge))
 		.filter(is_number)
+}
 
-	return cell(median(minutes))
+// The median lane, then its tail (`lane-tail-stats.ts`).
+function lane_cells(
+	entries: ReadonlyArray<LedgerEntry>,
+	period: ReadonlyArray<LedgerEntry>,
+): Array<string> {
+	const minutes = merge_minutes(entries, period)
+
+	return [
+		cell(median(minutes)),
+		String(lane_tail_stats.overrun_count(minutes)),
+		cell(lane_tail_stats.tail_minutes(minutes)),
+	]
 }
 
 // A reused gate ran no check, so its few milliseconds would pull the median toward a gate that never ran.
@@ -301,7 +317,7 @@ function row(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow, label: Ro
 		label.limit,
 		String(label.period_days),
 		...throughput_cells(period),
-		lane_cell(entries, period),
+		...lane_cells(entries, period),
 		...gate_cells(period),
 		...load_cells(period.filter(is_load)),
 	])