@joshuafolkken/kit 1.1784.0 → 1.2116.0

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

@@ -1,4 +1,5 @@
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_ship_planned } from '#scripts/run/ship/run-ship-planned'
 import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
 import { lane_ledger, type LedgerEntry, type StopEntry } from './lane-ledger'
 import type { IssueAt } from './lane-spans'
@@ -44,6 +45,7 @@ const EVENT_ISSUE = /#([1-9]\d*)\b/u
 // A stop recorded before it carried a cause (joshuafolkken/kit#3998) is counted under this one.
 const UNRECORDED_CAUSE = 'unrecorded'
 const NO_CAUSES = '-'
+const NOTICED = ' (noticed)'
 
 // `causes` is a preflight stop's unmet preconditions or a review stop's blocking finding kinds, every
 // one of them, else the stop's one cause.
@@ -57,20 +59,28 @@ function is_stop(entry: LedgerEntry): entry is StopEntry {
 	return entry.kind === lane_ledger.KIND.STOP
 }
 
+// The issue a run event's text names first, `NaN` where it names none.
+function issue_of(event: RunEvent): number {
+	return Number(EVENT_ISSUE.exec(event.text)?.[1])
+}
+
 // Every run event of `kind`, with the issue its text names first.
 function events_of(events: ReadonlyArray<RunEvent>, kind: string): Array<IssueAt> {
 	return events
 		.filter((event) => event.kind === kind)
-		.map((event) => ({
-			issue: Number(EVENT_ISSUE.exec(event.text)?.[1]),
-			at_ms: Date.parse(event.at),
-		}))
+		.map((event) => ({ issue: issue_of(event), at_ms: Date.parse(event.at) }))
 }
 
 function parks_of(events: ReadonlyArray<RunEvent>): Array<IssueAt> {
 	return events_of(events, run_event_stream.EVENT_KIND.PARK)
 }
 
+function dispatches_of(entries: ReadonlyArray<LedgerEntry>): Array<IssueAt> {
+	return entries
+		.filter((entry) => is_dispatch(entry))
+		.map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }))
+}
+
 function ends_of(
 	entries: ReadonlyArray<LedgerEntry>,
 	parks: ReadonlyArray<IssueAt>,
@@ -78,41 +88,63 @@ function ends_of(
 	const resumes = entries
 		.filter((entry) => is_stage(entry))
 		.map((stage) => ({ issue: stage.issue, at_ms: lane_stage_stats.started_ms(stage) }))
-	const dispatches = entries
-		.filter((entry) => is_dispatch(entry))
-		.map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }))
 
-	return [...resumes, ...dispatches, ...parks]
+	return [...resumes, ...dispatches_of(entries), ...parks]
 }
 
 // A stage's start counts from the stop's own instant, so a ship relaunched within the same
-// millisecond still ends the wait; the stage that stopped started before it.
-function wait_ms(stop: StopEntry, ends: ReadonlyArray<IssueAt>): number | undefined {
-	const from_ms = Date.parse(stop.at)
+// millisecond still ends the wait; the stage that stopped started before it. `josh lane:net` derives
+// a park's and an outage's wait the same way (`lane-net-time.ts`).
+function wait_ms(stop: IssueAt, ends: ReadonlyArray<IssueAt>): number | undefined {
 	const later = ends
-		.filter((end) => end.issue === stop.issue && end.at_ms >= from_ms)
-		.map((end) => end.at_ms - from_ms)
+		.filter((end) => end.issue === stop.issue && end.at_ms >= stop.at_ms)
+		.map((end) => end.at_ms - stop.at_ms)
 
 	return later.length === 0 ? undefined : Math.min(...later)
 }
 
+function instant_of(stop: StopEntry): IssueAt {
+	return { issue: stop.issue, at_ms: Date.parse(stop.at) }
+}
+
+// The `josh check:related` notices of the ship's `unplanned` answer (joshuafolkken/kit#5203).
+function notices_of(entries: ReadonlyArray<LedgerEntry>): Array<IssueAt> {
+	return entries
+		.filter((entry) => entry.kind === lane_ledger.KIND.UNPLANNED_NOTICE)
+		.map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }))
+}
+
+// An `unplanned` stop the same issue's `check:related` already printed counts as `unplanned (noticed)`,
+// so the stops the earlier notice did not prevent are a number of their own.
+function noticed(cause: string, stop: IssueAt, notices: ReadonlyArray<IssueAt>): string {
+	if (cause !== run_ship_planned.PRECONDITION) return cause
+	const is_noticed = notices.some(
+		(notice) => notice.issue === stop.issue && notice.at_ms <= stop.at_ms,
+	)
+
+	return is_noticed ? `${cause}${NOTICED}` : cause
+}
+
 // A stop recorded before it named its preconditions (joshuafolkken/kit#4166) or its finding kinds
 // (joshuafolkken/kit#4426) counts under its cause.
-function causes_of(stop: StopEntry): ReadonlyArray<string> {
+function causes_of(stop: StopEntry, notices: ReadonlyArray<IssueAt>): ReadonlyArray<string> {
 	const { preconditions = [], findings = [] } = stop
 	const kinds = [...preconditions, ...findings]
 
-	return kinds.length > 0 ? kinds : [stop.cause ?? UNRECORDED_CAUSE]
+	if (kinds.length === 0) return [stop.cause ?? UNRECORDED_CAUSE]
+
+	return kinds.map((kind) => noticed(kind, instant_of(stop), notices))
 }
 
 function waits_of(
 	entries: ReadonlyArray<LedgerEntry>,
 	ends: ReadonlyArray<IssueAt>,
+	notices: ReadonlyArray<IssueAt>,
 ): Array<StopWait> {
 	return entries.filter(is_stop).map((stop) => ({
 		reason: stop.reason,
-		causes: causes_of(stop),
-		wait_ms: wait_ms(stop, ends),
+		causes: causes_of(stop, notices),
+		wait_ms: wait_ms(instant_of(stop), ends),
 	}))
 }
 
@@ -158,7 +190,7 @@ function table(
 	events: ReadonlyArray<RunEvent> = [],
 ): string {
 	const ends = ends_of(entries, parks_of(events))
-	const waits = waits_of(lane_stats.in_window(entries, window), ends)
+	const waits = waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries))
 
 	return [
 		lane_stats.to_row(COLUMNS),
@@ -167,6 +199,6 @@ function table(
 	].join('\n')
 }
 
-const lane_stop_stats = { REASONS, events_of, table }
+const lane_stop_stats = { REASONS, dispatches_of, ends_of, events_of, issue_of, table, wait_ms }
 
 export { lane_stop_stats }

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

@@ -0,0 +1,32 @@
+// The tail of the period's lane times beside `lane:stats`'s median (joshuafolkken/kit#4910): a lane's
+// target is a ceiling, so the lanes over the overrun threshold and the 90th percentile say what a median
+// hides. The threshold is the one the overrun investigation launches past (`lane-overrun.ts`), which
+// judges a lane's net time; `lane:stats` counts on its dispatch-to-merge time.
+
+// The net minutes a lane may take before its causes are investigated.
+const OVERRUN_LANE_MINUTES = 40
+const TAIL_PERCENTILE = 90
+const WHOLE_PERCENT = 100
+
+function is_overrun(minutes: number): boolean {
+	return minutes > OVERRUN_LANE_MINUTES
+}
+
+// The lanes over the threshold; one exactly at it is not over.
+function overrun_count(minutes: ReadonlyArray<number>): number {
+	return minutes.filter((value) => is_overrun(value)).length
+}
+
+// The nearest-rank 90th percentile, else `undefined` with no lane.
+function tail_minutes(minutes: ReadonlyArray<number>): number | undefined {
+	if (minutes.length === 0) return undefined
+
+	const sorted = minutes.toSorted((left, right) => left - right)
+	const rank = Math.ceil((TAIL_PERCENTILE / WHOLE_PERCENT) * sorted.length)
+
+	return sorted[rank - 1]
+}
+
+const lane_tail_stats = { is_overrun, OVERRUN_LANE_MINUTES, overrun_count, tail_minutes }
+
+export { lane_tail_stats }

package/scripts/lane/lane-transcript-calls.ts

@@ -8,20 +8,39 @@ import { z } from 'zod'
 // **A backgrounded call is kept but not timed.** Its result line is the immediate "running in the
 // background" notice, so the gap measures nothing the run waited on; `duration_ms` is `undefined` for
 // it, as for a call whose result never arrived (an interrupted turn).
+//
+// **The tool's name is kept** (`Bash`, `Edit`, …), so `josh lane:value edit` can time the edits apart
+// from the shell calls, **and so is its lane** — the transcript directory every session of one lane
+// (its child, its ship reviewer) writes under — so a per-lane value divides by lanes, not sessions
+// (joshuafolkken/kit#4630).
+//
+// **A subagent call keeps its agent type and model** — `subagent_type`, the harness's
+// `general-purpose` when absent, and `model` when named — so the implement's subagent time splits by
+// the agent dispatched (joshuafolkken/kit#5297).
+
+interface Subagent {
+	type: string
+	model: string | undefined
+}
 
 interface ToolCall {
 	session_id: string
+	lane: string
 	started_ms: number
 	duration_ms: number | undefined
+	tool: string | undefined
 	background: boolean
 	command: string | undefined
+	subagent: Subagent | undefined
 	output: string
 }
 
 interface ToolUse {
 	started_ms: number
+	tool: string | undefined
 	background: boolean
 	command: string | undefined
+	subagent: Subagent | undefined
 }
 
 interface ToolResult {
@@ -40,19 +59,37 @@ function join_parts(parts: ReadonlyArray<TextPart>): string {
 interface RawInput {
 	command?: unknown
 	run_in_background?: unknown
+	subagent_type?: unknown
+	model?: unknown
 }
 
 interface CallInput {
 	background: boolean
 	command: string | undefined
+	subagent: Subagent
 }
 
-function to_input(input: RawInput | null | undefined): CallInput {
-	const command = input?.command
+const SUBAGENT_TOOLS: ReadonlySet<string> = new Set(['Agent', 'Task'])
+const GENERAL_PURPOSE = 'general-purpose'
+
+function string_or_undefined(value: unknown): string | undefined {
+	return typeof value === 'string' ? value : undefined
+}
+
+// A named string, `undefined` for an empty or non-string one.
+function named(value: unknown): string | undefined {
+	return value === '' ? undefined : string_or_undefined(value)
+}
+
+function subagent_of(input: RawInput | null | undefined): Subagent {
+	return { type: named(input?.subagent_type) ?? GENERAL_PURPOSE, model: named(input?.model) }
+}
 
+function to_input(input: RawInput | null | undefined): CallInput {
 	return {
 		background: input?.run_in_background === true,
-		command: typeof command === 'string' ? command : undefined,
+		command: string_or_undefined(input?.command),
+		subagent: subagent_of(input),
 	}
 }
 
@@ -61,11 +98,19 @@ const TEXT_PARTS_SCHEMA = z.array(z.object({ text: z.string().nullish() }))
 const RESULT_CONTENT_SCHEMA = z
 	.union([z.string(), TEXT_PARTS_SCHEMA.transform(join_parts)])
 	.catch('')
-const INPUT_SCHEMA = z.object({ command: z.unknown(), run_in_background: z.unknown() }).partial()
+const INPUT_SCHEMA = z
+	.object({
+		command: z.unknown(),
+		run_in_background: z.unknown(),
+		subagent_type: z.unknown(),
+		model: z.unknown(),
+	})
+	.partial()
 
 const BLOCK_SCHEMA = z.object({
 	type: z.string(),
 	id: z.string().nullish(),
+	name: z.string().nullish(),
 	input: INPUT_SCHEMA.nullish().transform(to_input),
 	tool_use_id: z.string().nullish(),
 	content: RESULT_CONTENT_SCHEMA.optional(),
@@ -91,10 +136,17 @@ interface Pairs {
 	results: Map<string, ToolResult>
 }
 
+// The agent a subagent call dispatched; any other tool's input names none.
+function subagent_in(tool: string | undefined, block: Block): Subagent | undefined {
+	return SUBAGENT_TOOLS.has(tool ?? '') ? block.input.subagent : undefined
+}
+
 function record_use(pairs: Pairs, block: Block, started_ms: number): void {
 	if (block.type !== 'tool_use' || !block.id) return
 
-	pairs.uses.set(block.id, { started_ms, ...block.input })
+	const tool = block.name ?? undefined
+
+	pairs.uses.set(block.id, { started_ms, tool, ...block.input, subagent: subagent_in(tool, block) })
 }
 
 function record_result(pairs: Pairs, block: Block, ended_ms: number): void {
@@ -116,30 +168,35 @@ function record_line(pairs: Pairs, line: string): void {
 	}
 }
 
-function to_call(session_id: string, use: ToolUse, result: ToolResult | undefined): ToolCall {
+// The transcript a call was read from: its session, and the lane that session belongs to.
+type CallSource = Pick<ToolCall, 'session_id' | 'lane'>
+
+function to_call(source: CallSource, use: ToolUse, result: ToolResult | undefined): ToolCall {
 	const is_timed = result !== undefined && !use.background
 
 	return {
-		session_id,
+		...source,
 		started_ms: use.started_ms,
 		duration_ms: is_timed ? result.ended_ms - use.started_ms : undefined,
+		tool: use.tool,
 		background: use.background,
 		command: use.command,
+		subagent: use.subagent,
 		output: result?.output ?? '',
 	}
 }
 
 // Every tool call `raw` — one transcript's text — records, in the order the calls were made.
-function parse(session_id: string, raw: string): Array<ToolCall> {
+function parse(source: CallSource, raw: string): Array<ToolCall> {
 	const pairs: Pairs = { uses: new Map(), results: new Map() }
 	const lines = raw.split('\n')
 
 	for (const line of lines) record_line(pairs, line)
 
-	return [...pairs.uses].map(([id, use]) => to_call(session_id, use, pairs.results.get(id)))
+	return [...pairs.uses].map(([id, use]) => to_call(source, use, pairs.results.get(id)))
 }
 
 const lane_transcript_calls = { parse }
 
-export type { ToolCall }
+export type { Subagent, ToolCall }
 export { lane_transcript_calls }

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

@@ -1,3 +1,4 @@
+import path from 'node:path'
 import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { time_shell } from '#scripts/time-runtime/time-shell'
@@ -65,11 +66,16 @@ function segment_command(segment: string): string {
 	return named.slice(time_shell.JOSH_PREFIX.length)
 }
 
-function verification_commands(command = ''): Array<string> {
+// Every josh command a shell `command` runs, in order.
+function josh_commands(command = ''): Array<string> {
 	const spoken = time_shell.unquoted(command)
 	const named = spoken.split(SEPARATOR_PATTERN).map((segment) => segment_command(segment))
 
-	return named.filter((name) => VERIFICATION_COMMANDS.has(name))
+	return named.filter((name) => name !== '')
+}
+
+function verification_commands(command = ''): Array<string> {
+	return josh_commands(command).filter((name) => VERIFICATION_COMMANDS.has(name))
 }
 
 function seconds_cell(ms: number | undefined): string {
@@ -84,11 +90,14 @@ function durations(calls: ReadonlyArray<ToolCall>): Array<number> {
 	return calls.map((call) => call.duration_ms).filter((ms) => is_timed(ms))
 }
 
+// The lane sessions that made a call among `calls`, each once.
+function sessions_of(calls: ReadonlyArray<ToolCall>): Array<string> {
+	return [...new Set(calls.map((call) => call.session_id))]
+}
+
 // Each session's summed foreground tool time, for the sessions that made a call in the period.
 function session_times(calls: ReadonlyArray<ToolCall>): Array<number> {
-	const sessions = [...new Set(calls.map((call) => call.session_id))]
-
-	return sessions.map((session) =>
+	return sessions_of(calls).map((session) =>
 		durations(calls.filter((call) => call.session_id === session)).reduce(
 			(sum, value) => sum + value,
 			0,
@@ -102,12 +111,17 @@ function share_cell(part: number, whole: number): string {
 	return `${String(part)} of ${String(whole)} (${((part / whole) * PERCENT).toFixed(1)}%)`
 }
 
-function solo_median_row(verifying: ReadonlyArray<ToolCall>, name: string): Array<string> {
-	const solo = verifying.filter((call) => {
+// The calls that ran the verification command `name` and no other, so each one's time is its own.
+function solo_calls(calls: ReadonlyArray<ToolCall>, name: string): Array<ToolCall> {
+	return calls.filter((call) => {
 		const named = verification_commands(call.command)
 
 		return named.length === 1 && named[0] === name
 	})
+}
+
+function solo_median_row(verifying: ReadonlyArray<ToolCall>, name: string): Array<string> {
+	const solo = solo_calls(verifying, name)
 
 	return [`${name} median, solo (s)`, seconds_cell(lane_stats.median(durations(solo)))]
 }
@@ -140,11 +154,15 @@ function rows_of(calls: ReadonlyArray<ToolCall>): Array<Array<string>> {
 	]
 }
 
-// The period's table: `calls` is every lane session's calls, filtered here to `window`.
-function table(calls: ReadonlyArray<ToolCall>, window: StatsWindow): string {
-	const period = calls.filter(
+function in_period(calls: ReadonlyArray<ToolCall>, window: StatsWindow): Array<ToolCall> {
+	return calls.filter(
 		(call) => call.started_ms >= window.since_ms && call.started_ms <= window.until_ms,
 	)
+}
+
+// The period's table: `calls` is every lane session's calls, filtered here to `window`.
+function table(calls: ReadonlyArray<ToolCall>, window: StatsWindow): string {
+	const period = in_period(calls, window)
 
 	return [
 		lane_stats.to_row(COLUMNS),
@@ -156,13 +174,27 @@ function table(calls: ReadonlyArray<ToolCall>, window: StatsWindow): string {
 // The tool calls of every lane session under `directories` that was still written to in `window` — a
 // transcript last modified before the period holds no call in it, so it is never read. A delegated
 // unit's transcript is not a lane session, and its time is already inside the parent's wait for it.
+// A session's own transcript sits directly in its lane's directory, so that directory is its lane.
 function read_calls(directories: ReadonlyArray<string>, window: StatsWindow): Array<ToolCall> {
 	return cost_transcript
 		.list_sessions_across(directories)
 		.filter((file) => !file.is_delegated && file.modified_ms >= window.since_ms)
-		.flatMap((file) => lane_transcript_calls.parse(file.session_id, cost_transcript.read_raw(file)))
+		.flatMap((file) =>
+			lane_transcript_calls.parse(
+				{ session_id: file.session_id, lane: path.dirname(file.path) },
+				cost_transcript.read_raw(file),
+			),
+		)
 }
 
-const lane_transcript_stats = { read_calls, table, verification_commands }
+const lane_transcript_stats = {
+	durations,
+	in_period,
+	josh_commands,
+	read_calls,
+	solo_calls,
+	table,
+	verification_commands,
+}
 
 export { lane_transcript_stats }

package/scripts/lane/lane-value-cell.ts

@@ -0,0 +1,72 @@
+// `josh lane:value cell --table <title> --row <label> --column <header>` — one cell of a table
+// `josh lane:stats` prints, as one number (joshuafolkken/kit#5144). The tables are read as printed, so
+// every new `lane:stats` table is declarable without a new metric and no aggregation is copied.
+//
+// A table is named by its first header cell and a row by its first cell. **The address must name one
+// cell** — two tables share the `check` title, so an address that matches more than one numeric cell
+// answers `undefined`, as a missing or non-numeric one does, never a guess.
+
+const ROW_OPEN = '| '
+const ROW_CLOSE = ' |'
+const CELL_SEPARATOR = ' | '
+const BLOCK_SEPARATOR = /\n\s*\n/u
+const NUMBER_PATTERN = /^-?\d+(?:\.\d+)?$/u
+const HEADER_ROWS = 2
+
+interface CellAddress {
+	table: string
+	row: string
+	column: string
+}
+
+type Cells = ReadonlyArray<string>
+
+function cells_of(line: string): Cells | undefined {
+	const text = line.trim()
+
+	if (!text.startsWith(ROW_OPEN) || !text.endsWith(ROW_CLOSE)) return undefined
+
+	return text.slice(ROW_OPEN.length, -ROW_CLOSE.length).split(CELL_SEPARATOR)
+}
+
+function rows_of(block: string): ReadonlyArray<Cells> {
+	return block
+		.split('\n')
+		.map((line) => cells_of(line))
+		.filter((row) => row !== undefined)
+}
+
+// Every printed table as its rows of cells, the header first; a block with no row is dropped.
+function blocks_of(tables: ReadonlyArray<string>): ReadonlyArray<ReadonlyArray<Cells>> {
+	return tables
+		.flatMap((table) => table.split(BLOCK_SEPARATOR))
+		.map((block) => rows_of(block))
+		.filter((rows) => rows.length > 0)
+}
+
+// The cell texts at the address in one table — none when its title or column differs.
+function texts_in(rows: ReadonlyArray<Cells>, address: CellAddress): ReadonlyArray<string> {
+	const [header = []] = rows
+	const column = header.indexOf(address.column)
+
+	if (header[0] !== address.table || column < 1) return []
+
+	return rows
+		.slice(HEADER_ROWS)
+		.filter((cells) => cells[0] === address.row)
+		.map((cells) => cells[column] ?? '')
+}
+
+// The one numeric cell at `address` across `tables`, or `undefined` for none, many or a non-number.
+function value(tables: ReadonlyArray<string>, address: CellAddress): number | undefined {
+	const numbers = blocks_of(tables)
+		.flatMap((rows) => texts_in(rows, address))
+		.filter((text) => NUMBER_PATTERN.test(text))
+
+	return numbers.length === 1 ? Number(numbers[0]) : undefined
+}
+
+const lane_value_cell = { value }
+
+export type { CellAddress }
+export { lane_value_cell }

package/scripts/lane/lane-value.ts

@@ -0,0 +1,118 @@
+import { metrics_totals } from '#scripts/gate/metrics-totals'
+import { since_green } from '#scripts/gate/since-green'
+import { MS_PER_MINUTE, MS_PER_SECOND } from '#scripts/lib/timeouts'
+import { run_ship_pre_detach } from '#scripts/run/ship/run-ship-pre-detach'
+import { lane_ledger, type CoreWaitEntry, type LedgerEntry } from './lane-ledger'
+import { lane_stats, type StatsWindow } from './lane-stats'
+import type { ToolCall } from './lane-transcript-calls'
+import { lane_transcript_stats } from './lane-transcript-stats'
+
+// `josh lane:value <metric> --since <instant>` — one lane measurement as one number, so a follow-up
+// measurement Issue can declare it (its measurement declaration line) and `backlog:drive` closes it without a lane
+// (joshuafolkken/kit#4630). Each metric is one an Issue measured by hand from the lane transcripts or
+// the ledger; `lane:stats` prints the tables they were read from.
+//
+// **Per lane is per lane, not per session** — every lane runs at least a child and a ship-reviewer
+// session, so the divisor is the lanes whose sessions made a tool call in the period. A metric with no
+// sample answers `undefined`, never a zero that would pass.
+
+const LINT_RELATED = 'lint:related'
+const SHIP = 'ship'
+const EDIT_TOOL = 'Edit'
+// Both pre-detach forms: a `--since` window from before joshuafolkken/kit#4716 holds the bare form's.
+const METRICS_STOPS: ReadonlyArray<string> = [
+	metrics_totals.METRICS_RERECORD_COMMAND,
+	metrics_totals.METRICS_TOTALS_COMMAND,
+].map((list) => run_ship_pre_detach.failure_prefix(list))
+
+interface LaneRecords {
+	entries: ReadonlyArray<LedgerEntry>
+	calls: ReadonlyArray<ToolCall>
+}
+
+type Metric = (records: LaneRecords) => number | undefined
+
+function seconds_of(ms: number | undefined): number | undefined {
+	return ms === undefined ? undefined : ms / MS_PER_SECOND
+}
+
+// `count` spread over the period's lanes, or `undefined` when no lane ran.
+function per_lane(count: number, calls: ReadonlyArray<ToolCall>): number | undefined {
+	const lanes = new Set(calls.map((call) => call.lane)).size
+
+	return lanes === 0 ? undefined : count / lanes
+}
+
+// #4599: the median time of a `lint:related` that found nothing moved since its last green run.
+function lint_unmoved({ calls }: LaneRecords): number | undefined {
+	const unmoved = lane_transcript_stats
+		.solo_calls(calls, LINT_RELATED)
+		.filter((call) => call.output.includes(since_green.UNMOVED_REASON))
+
+	return seconds_of(lane_stats.median(lane_transcript_stats.durations(unmoved)))
+}
+
+// #4600: the `ship` calls whose pre-detach check the metrics totals stopped, per lane.
+function metrics_stops({ calls }: LaneRecords): number | undefined {
+	const stops = calls.filter(
+		(call) =>
+			lane_transcript_stats.verification_commands(call.command).includes(SHIP) &&
+			METRICS_STOPS.some((stop) => call.output.includes(stop)),
+	)
+
+	return per_lane(stops.length, calls)
+}
+
+// A lane's `lint:related` wait — one outside a lane (the main checkout's) has no `issue` and no lane
+// session to be divided among.
+function is_lint_wait(entry: LedgerEntry): entry is CoreWaitEntry {
+	return (
+		entry.kind === lane_ledger.KIND.CORE_WAIT &&
+		entry.command === LINT_RELATED &&
+		entry.issue !== undefined
+	)
+}
+
+// #4601: the minutes `lint:related` waited for the core budget, per lane.
+function lint_core_wait({ entries, calls }: LaneRecords): number | undefined {
+	const waited = entries.filter((entry) => is_lint_wait(entry))
+	const total_ms = waited.reduce((sum, wait) => sum + wait.waited_ms, 0)
+
+	return per_lane(total_ms / MS_PER_MINUTE, calls)
+}
+
+// #4602: the median time of one `Edit` call, hooks included.
+function edit({ calls }: LaneRecords): number | undefined {
+	const edits = calls.filter((call) => call.tool === EDIT_TOOL)
+
+	return seconds_of(lane_stats.median(lane_transcript_stats.durations(edits)))
+}
+
+const METRICS: Readonly<Record<string, Metric>> = {
+	'lint-unmoved': lint_unmoved,
+	'metrics-stops': metrics_stops,
+	'lint-core-wait': lint_core_wait,
+	edit,
+}
+
+const NAMES: ReadonlyArray<string> = Object.keys(METRICS)
+
+function is_metric(name: string): boolean {
+	return Object.hasOwn(METRICS, name)
+}
+
+// The value of `name` over `window`; `records` are the whole ledger and every lane call, cut here.
+function value(name: string, records: LaneRecords, window: StatsWindow): number | undefined {
+	const metric = is_metric(name) ? METRICS[name] : undefined
+	const period = {
+		entries: lane_stats.in_window(records.entries, window),
+		calls: lane_transcript_stats.in_period(records.calls, window),
+	}
+
+	return metric === undefined ? undefined : metric(period)
+}
+
+const lane_value = { NAMES, is_metric, value }
+
+export type { LaneRecords }
+export { lane_value }