@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/scripts/lane/lane-ledger.ts

@@ -36,9 +36,16 @@ const KIND = {
 	DISPATCH: 'dispatch',
 	STAGE: 'stage',
 	STOP: 'stop',
+	OVERLAP: 'overlap',
 } as const
 
 const merge_schema = z.object({ kind: z.literal(KIND.MERGE), at: z.string(), issue: z.number() })
+const check_schema = z.object({
+	label: z.string(),
+	elapsed_ms: z.number(),
+	is_passed: z.boolean(),
+	is_reused: z.boolean().optional(),
+})
 const gate_schema = z.object({
 	kind: z.literal(KIND.GATE),
 	at: z.string(),
@@ -50,12 +57,21 @@ const gate_schema = z.object({
 	// The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
 	// whichever was higher. Absent when the machine could not be read.
 	external_cores: z.number().optional(),
+	// Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
+	// on. A reused check started no process: its row says so, and its zero is no timing.
+	checks: z.array(check_schema).optional(),
 })
 // `available_mb`, `swapped_mb` and `lanes` are optional because each read can fail on its own — a
 // platform with no memory reading, a `git worktree` call that did not answer — and a sample is still
 // worth its load. `swapped_mb` is `machine_capacity`'s counter, every page swapped since boot.
 // Both memory fields were renamed with their meaning (joshuafolkken/kit#3593): an older row's
 // `free_mb` / `swap_mb` are stripped on read, so the two measurements never share a column.
+const process_kind_schema = z.object({
+	kind: z.string(),
+	cpu_percent: z.number(),
+	rss_mb: z.number(),
+	count: z.number(),
+})
 const load_schema = z.object({
 	kind: z.literal(KIND.LOAD),
 	at: z.string(),
@@ -63,6 +79,9 @@ const load_schema = z.object({
 	available_mb: z.number().optional(),
 	swapped_mb: z.number().optional(),
 	lanes: z.number().optional(),
+	// The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
+	// core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
+	processes: z.array(process_kind_schema).optional(),
 })
 // A lane child started on `issue` — the instant its implementation is timed from.
 const dispatch_schema = z.object({
@@ -89,6 +108,18 @@ const stop_schema = z.object({
 	issue: z.number(),
 	reason: z.string(),
 })
+// A `josh ship` on `issue` whose actual change overlapped the open pull requests of `lanes` on `paths`
+// before its sync: it waited `waited_ms` for their ships to end, and `is_cleared` is false where the
+// wait ran out first (joshuafolkken/kit#3901).
+const overlap_schema = z.object({
+	kind: z.literal(KIND.OVERLAP),
+	at: z.string(),
+	issue: z.number(),
+	lanes: z.array(z.number()),
+	paths: z.array(z.string()),
+	waited_ms: z.number(),
+	is_cleared: z.boolean(),
+})
 const entry_schema = z.discriminatedUnion('kind', [
 	merge_schema,
 	gate_schema,
@@ -96,6 +127,7 @@ const entry_schema = z.discriminatedUnion('kind', [
 	dispatch_schema,
 	stage_schema,
 	stop_schema,
+	overlap_schema,
 ])
 
 type LedgerEntry = z.infer<typeof entry_schema>
@@ -105,10 +137,13 @@ type LoadEntry = z.infer<typeof load_schema>
 type DispatchEntry = z.infer<typeof dispatch_schema>
 type StageEntry = z.infer<typeof stage_schema>
 type StopEntry = z.infer<typeof stop_schema>
+type OverlapEntry = z.infer<typeof overlap_schema>
 // What a finished gate reports; the ledger stamps the kind and the time.
 type GateRecord = Omit<GateEntry, 'kind' | 'at'>
+type GateCheckRecord = z.infer<typeof check_schema>
 type StageRecord = Omit<StageEntry, 'kind' | 'at'>
 type StopRecord = Omit<StopEntry, 'kind' | 'at'>
+type OverlapRecord = Omit<OverlapEntry, 'kind' | 'at'>
 
 function target_of(repository: string): string {
 	return stamp_file.stamp_path(LEDGER_PREFIX, repository, LEDGER_SUFFIX)
@@ -185,6 +220,10 @@ async function record_stop(stop: StopRecord, path?: string): Promise<void> {
 	await record({ kind: KIND.STOP, at: now_iso(), ...stop }, path)
 }
 
+async function record_overlap(overlap: OverlapRecord, path?: string): Promise<void> {
+	await record({ kind: KIND.OVERLAP, at: now_iso(), ...overlap }, path)
+}
+
 function parse_line(line: string): LedgerEntry | undefined {
 	return entry_schema.safeParse(json_value.parse_or_undefined(line)).data
 }
@@ -215,11 +254,23 @@ const lane_ledger = {
 	record_dispatch,
 	record_gate,
 	record_merge,
+	record_overlap,
 	record_stage,
 	record_stop,
 	target,
 	target_of,
 }
 
-export type { DispatchEntry, GateEntry, LedgerEntry, LoadEntry, MergeEntry, StageEntry, StopEntry }
+export type {
+	DispatchEntry,
+	GateCheckRecord,
+	GateEntry,
+	LedgerEntry,
+	LoadEntry,
+	MergeEntry,
+	OverlapEntry,
+	OverlapRecord,
+	StageEntry,
+	StopEntry,
+}
 export { lane_ledger }

package/scripts/lane/lane-limit-cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { backlog_ready } from '#scripts/backlog/backlog-ready'
+import { backlog_ready, type LaneUse } from '#scripts/backlog/backlog-ready'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { lane_capacity, type LimitChoice } from './lane-capacity'
 import { lane_limit_override } from './lane-limit-override'
@@ -37,13 +37,13 @@ interface LimitPorts {
 	read_override: () => Promise<number | undefined>
 	write_override: (limit: number | undefined) => Promise<boolean>
 	emit_raise: (text: string) => Promise<void>
-	live_lane_count: () => Promise<number>
+	lane_use: () => Promise<LaneUse>
 }
 
 interface LimitStatus {
 	limit: number
 	override: number | undefined
-	in_use: number
+	use: LaneUse
 }
 
 const SHOW: LimitRequest = { kind: 'show' }
@@ -55,7 +55,7 @@ const DEFAULT_PORTS: LimitPorts = {
 	read_override: lane_limit_override.read_override,
 	write_override: lane_limit_override.write_override,
 	emit_raise: lane_limit_override.emit_raise,
-	live_lane_count: backlog_ready.live_lane_count,
+	lane_use: backlog_ready.lane_use,
 }
 
 function refuse(message: string): number {
@@ -98,9 +98,10 @@ function limit_text(limit: number): string {
 
 function status_line(status: LimitStatus): string {
 	const source = status.override === undefined ? lane_capacity.LANE_LIMIT_KEY : OVERRIDE_SOURCE
-	const free = lane_capacity.free_lanes(status.limit, status.in_use)
+	const { occupied, seated } = status.use
+	const free = lane_capacity.free_lanes(status.limit, occupied, seated)
 
-	return `lane limit ${limit_text(status.limit)} (${source}) · in use ${String(status.in_use)} · free ${String(free)}`
+	return `lane limit ${limit_text(status.limit)} (${source}) · in use ${String(occupied)} · free ${String(free)}`
 }
 
 async function show(ports: LimitPorts): Promise<number> {
@@ -110,9 +111,7 @@ async function show(ports: LimitPorts): Promise<number> {
 
 	const override = await ports.read_override()
 
-	console.info(
-		status_line({ limit: choice.limit, override, in_use: await ports.live_lane_count() }),
-	)
+	console.info(status_line({ limit: choice.limit, override, use: await ports.lane_use() }))
 
 	return SUCCESS_EXIT_CODE
 }

package/scripts/lane/lane-load.ts

@@ -2,10 +2,12 @@ import { loadavg } from 'node:os'
 import { machine_capacity } from '#scripts/gate/machine-capacity'
 import { lane_await } from './lane-await'
 import type { LoadEntry } from './lane-ledger'
+import { lane_process_load } from './lane-process-load'
 import { lane_registry, type LaneInfo } from './lane-registry'
 
 // One machine-load sample for the lane-limit measurement: the one-minute load
-// average, available memory, the swap counter and how many lanes have a child working, read at one
+// average, available memory, the swap counter, how many lanes have a child working and the heaviest
+// process kinds (`lane-process-load.ts`), read at one
 // instant so `josh lane:stats` can set the load beside the lane count that produced it.
 //
 // **The memory is `machine_capacity`'s reading, the one the gate admits against.** `os.freemem()` reads
@@ -38,7 +40,11 @@ function rounded(megabytes: number | undefined): number | undefined {
 }
 
 async function sample(at: string): Promise<LoadEntry> {
-	const [memory, lanes] = await Promise.all([machine_capacity.read_memory(), read_lanes()])
+	const [memory, lanes, processes] = await Promise.all([
+		machine_capacity.read_memory(),
+		read_lanes(),
+		lane_process_load.read(),
+	])
 	const [load = 0] = loadavg()
 
 	return {
@@ -48,6 +54,7 @@ async function sample(at: string): Promise<LoadEntry> {
 		available_mb: rounded(memory.available_mb),
 		swapped_mb: rounded(memory.swapped_mb),
 		lanes,
+		processes,
 	}
 }
 

package/scripts/lane/lane-measure-cli.ts

@@ -3,7 +3,9 @@ import { setInterval as every } from 'node:timers/promises'
 import { fileURLToPath } from 'node:url'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { lane_capacity } from './lane-capacity'
+import { lane_check_stats } from './lane-check-stats'
 import { lane_ledger } from './lane-ledger'
+import { lane_process_stats } from './lane-process-stats'
 import { lane_sampler, type MeasureContext } from './lane-sampler'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats } from './lane-stats'
@@ -119,6 +121,8 @@ async function stats_command(
 			`${lane_stats.header()}\n${row}`,
 			lane_stage_stats.table(entries, window),
 			lane_stop_stats.table(entries, window),
+			lane_process_stats.table(entries, window),
+			lane_check_stats.table(entries, window),
 		].join('\n\n'),
 	)
 

package/scripts/lane/lane-parked.ts

@@ -0,0 +1,18 @@
+import { has_label_name, NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
+import { issue_state_cli } from '#scripts/issue/issue-state-cli'
+
+// Whether an issue is parked for a person — the `needs-decision` label — read live, so a session a
+// lane's broker would start for it is refused once the run has parked it (joshuafolkken/kit#3878).
+//
+// **An issue whose state cannot be read is not parked**: the read gates every brokered review, so
+// reading an outage as a park would fail every review in flight for as long as GitHub is away.
+
+async function is_parked(issue: string): Promise<boolean> {
+	const read = await issue_state_cli.read_issue(issue)
+
+	return read.kind === 'state' && has_label_name(read.state.labels, NEEDS_DECISION_LABEL)
+}
+
+const lane_parked = { is_parked }
+
+export { lane_parked }

package/scripts/lane/lane-preserve.ts

@@ -1,5 +1,6 @@
 import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
 import { git_stash } from '#scripts/git/stash/git-stash'
+import { error_text } from '#scripts/lib/error-message'
 
 // Keeping a lane's uncommitted work before something discards or restarts it — `run:merge` closing a
 // lane, `lane:restart` handing it to a fresh session. The stash stack outlives the tree, so the push is
@@ -30,6 +31,32 @@ async function announce(issue: string, message: string, cause: string): Promise<
 	await git_gh_issue_write.issue_try_comment(issue, preserved_comment(message, cause))
 }
 
+// The tree's work kept before a stopped child's lane is reused or closed: `saved` with the stash, or
+// none for a clean tree, and `unsaved` with the reason when the tree could not be read or pushed — the
+// caller then leaves the tree as it is rather than handing it on or deleting it.
+type KeptWork =
+	| { kind: 'saved'; stash: string | undefined }
+	| { kind: 'unsaved'; directory: string; reason: string }
+
+async function stash_of(
+	issue: string,
+	directory: string,
+	occasion: string,
+): Promise<string | undefined> {
+	if (!(await git_stash.has_changes(directory))) return undefined
+
+	return await push_work(issue, directory, occasion)
+}
+
+/** Stash the tree's uncommitted work, if any, answering `unsaved` rather than throwing. */
+async function keep_work(issue: string, directory: string, occasion: string): Promise<KeptWork> {
+	try {
+		return { kind: 'saved', stash: await stash_of(issue, directory, occasion) }
+	} catch (error) {
+		return { kind: 'unsaved', directory, reason: error_text.message_of(error) }
+	}
+}
+
 /** `push_work`, then `announce` — for a caller with no reason to separate the two. */
 async function stash_work(
 	issue: string,
@@ -44,6 +71,7 @@ async function stash_work(
 	return message
 }
 
-const lane_preserve = { announce, push_work, stash_work }
+const lane_preserve = { announce, keep_work, stash_work }
 
+export type { KeptWork }
 export { lane_preserve }

package/scripts/lane/lane-process-load.ts

@@ -0,0 +1,125 @@
+import { PROBE_TIMEOUT_MS } from '#scripts/lib/timeouts'
+import { execa } from 'execa'
+
+// What the machine's load is made of at one instant: every process grouped by the kind of tool it
+// runs, the heaviest kinds kept with their CPU and resident size, for a `load` sample to carry.
+//
+// **Why a load sample needs it.** The gate's static checks and unit suite are on the core budget's
+// ledger, so the load the ledger does not explain comes from somewhere else — review subagents, the
+// sessions themselves, a hook's unit run, an IDE — and a load average alone cannot say which.
+// joshuafolkken/kit#3874 measured load 93 with 1.6 lanes working and nothing on record to explain it.
+//
+// **The kind is read from the command line, not the executable name.** Every tool here is a `node`
+// process, so the name says nothing; the first pattern a command line matches names its kind, in the
+// order below, so `pnpm exec vitest` is `vitest` rather than `josh`. The IDE comes first: its language
+// servers run out of a `typescript` or `eslint` directory, and read as `tsc` or `eslint` they would
+// pass the IDE's load off as the gate's own checks — and a server the IDE starts on a plain `node`
+// runtime is known only by its `.vscode/extensions/` path. `claude` is the executable or its package,
+// never a `.claude/` path a session's Bash-tool shell or hook script runs through. `pnpm` is the
+// command, never the `.pnpm/` store a resolved binary's path runs through.
+//
+// **`%cpu` is the share of one core**, so 300 is three cores busy; it is `ps`'s decaying average,
+// which is what a one-minute sample beside the one-minute load average wants.
+
+const PS_ARGUMENTS = ['-A', '-o', 'rss=,%cpu=,args=']
+// `ps` prints `%cpu` with the locale's decimal separator, and a `0,7` would parse as NaN.
+const PS_ENVIRONMENT = { LC_ALL: 'C' }
+const FIELD_SEPARATOR = /\s+/u
+const KB_PER_MB = 1024
+// Enough to name what dominates and the runner-up behind it, short enough for one ledger line a minute.
+const TOP_KINDS = 5
+const OTHER_KIND = 'other'
+
+const KIND_PATTERNS: ReadonlyArray<readonly [string, RegExp]> = [
+	['vscode', /Visual Studio Code|Code Helper|\.vscode\/extensions\//u],
+	['vitest', /vitest/u],
+	['eslint', /eslint/u],
+	['tsc', /\btsc\b|svelte-check|typescript/u],
+	['cspell', /cspell/u],
+	['prettier', /prettier/u],
+	['playwright', /playwright/u],
+	['chrome', /Google Chrome/u],
+	['chromium', /chromium|headless_shell/iu],
+	['claude', /(?:^|\/)claude(?:\s|$)|@anthropic-ai\/claude-code\//u],
+	['josh', /josh\.ts|\btsx\b|(?<!\.)\bpnpm\b/u],
+	['node', /\bnode\b/u],
+]
+
+interface ProcessKind {
+	kind: string
+	cpu_percent: number
+	rss_mb: number
+	count: number
+}
+
+function kind_of(command_line: string): string {
+	return KIND_PATTERNS.find(([, pattern]) => pattern.test(command_line))?.[0] ?? OTHER_KIND
+}
+
+// One line of `ps`'s listing as its kind and readings; a header or a cut-short line reads as nothing.
+function process_of(line: string): Omit<ProcessKind, 'count'> | undefined {
+	const [rss, cpu, ...command] = line.trim().split(FIELD_SEPARATOR)
+	const reading = { cpu_percent: Number(cpu), rss_mb: Number(rss) / KB_PER_MB }
+
+	if (command.length === 0 || Number.isNaN(reading.cpu_percent + reading.rss_mb)) return undefined
+
+	return { kind: kind_of(command.join(' ')), ...reading }
+}
+
+function add_line(totals: Map<string, ProcessKind>, line: string): void {
+	const reading = process_of(line)
+
+	if (reading === undefined) return
+
+	const { kind } = reading
+	const total = totals.get(kind) ?? { kind, cpu_percent: 0, rss_mb: 0, count: 0 }
+
+	total.cpu_percent += reading.cpu_percent
+	total.rss_mb += reading.rss_mb
+	total.count += 1
+	totals.set(kind, total)
+}
+
+function rounded(total: ProcessKind): ProcessKind {
+	return { ...total, cpu_percent: Math.round(total.cpu_percent), rss_mb: Math.round(total.rss_mb) }
+}
+
+// The heaviest kinds first: by CPU, the load average's own measure, then by memory for idle kinds.
+function by_weight(left: ProcessKind, right: ProcessKind): number {
+	return right.cpu_percent - left.cpu_percent || right.rss_mb - left.rss_mb
+}
+
+function summarize(listing: string): Array<ProcessKind> {
+	const totals = new Map<string, ProcessKind>()
+
+	for (const line of listing.split('\n')) add_line(totals, line)
+
+	return [...totals.values()]
+		.map((total) => rounded(total))
+		.toSorted(by_weight)
+		.slice(0, TOP_KINDS)
+}
+
+// `undefined` where `ps` did not answer, so the sample records no breakdown rather than an empty one.
+async function read(): Promise<Array<ProcessKind> | undefined> {
+	try {
+		const { stdout } = await execa('ps', PS_ARGUMENTS, {
+			env: PS_ENVIRONMENT,
+			timeout: PROBE_TIMEOUT_MS,
+		})
+
+		return summarize(stdout)
+	} catch {
+		return undefined
+	}
+}
+
+const lane_process_load = {
+	TOP_KINDS,
+	kind_of,
+	read,
+	summarize,
+}
+
+export type { ProcessKind }
+export { lane_process_load }

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

@@ -0,0 +1,93 @@
+import type { LedgerEntry, LoadEntry } from './lane-ledger'
+import type { ProcessKind } from './lane-process-load'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// What the period's machine load was made of: the process kinds the load samples carried
+// (`lane-process-load.ts`), one row per kind, printed by `josh lane:stats` under the stop table so the
+// load the core budget's ledger does not explain is read back by what made it (joshuafolkken/kit#3874).
+//
+// **A kind is averaged over the samples it appears in**, never over every sample. A sample keeps only
+// its heaviest kinds, so a kind absent from one was below them rather than idle, and a zero there would
+// understate it; `samples` says how often it was among the heaviest, which is the weight to read it by.
+//
+// **CPU is in cores** — `ps`'s share of one core over a hundred — so the column reads against the load
+// average and the machine's core count without a conversion.
+
+const COLUMNS = [
+	'process',
+	'cpu mean (cores)',
+	'cpu peak (cores)',
+	'rss peak (GB)',
+	'samples',
+] as const
+const PERCENT_PER_CORE = 100
+const MB_PER_GB = 1024
+const DECIMALS = 1
+
+interface KindRow {
+	kind: string
+	readings: Array<ProcessKind>
+}
+
+function is_load(entry: LedgerEntry): entry is LoadEntry {
+	return entry.kind === 'load'
+}
+
+function group(samples: ReadonlyArray<LoadEntry>): Array<KindRow> {
+	const rows = new Map<string, KindRow>()
+	const readings = samples.flatMap((sample) => sample.processes ?? [])
+
+	for (const reading of readings) {
+		const row = rows.get(reading.kind) ?? { kind: reading.kind, readings: [] }
+
+		row.readings.push(reading)
+		rows.set(reading.kind, row)
+	}
+
+	return [...rows.values()]
+}
+
+function cores(readings: ReadonlyArray<ProcessKind>): Array<number> {
+	return readings.map((reading) => reading.cpu_percent / PERCENT_PER_CORE)
+}
+
+// A row has one reading at least, so its mean always exists.
+function mean_cores(row: KindRow): number {
+	return lane_stats.mean(cores(row.readings)) ?? 0
+}
+
+function cell(value: number | undefined): string {
+	return value === undefined ? lane_stats.MISSING : value.toFixed(DECIMALS)
+}
+
+function kind_cells(row: KindRow): Array<string> {
+	const rss_peak = lane_stats.peak(row.readings.map((reading) => reading.rss_mb))
+
+	return [
+		row.kind,
+		cell(mean_cores(row)),
+		cell(lane_stats.peak(cores(row.readings))),
+		cell(rss_peak === undefined ? undefined : rss_peak / MB_PER_GB),
+		String(row.readings.length),
+	]
+}
+
+function by_mean_cpu(left: KindRow, right: KindRow): number {
+	return mean_cores(right) - mean_cores(left)
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`. A period whose samples
+// carried no breakdown prints the header alone.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const rows = group(lane_stats.in_window(entries, window).filter(is_load)).toSorted(by_mean_cpu)
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		...rows.map((row) => lane_stats.to_row(kind_cells(row))),
+	].join('\n')
+}
+
+const lane_process_stats = { table }
+
+export { lane_process_stats }

package/scripts/lane/lane-registry.ts

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs'
+import { existsSync, statSync } from 'node:fs'
 import path from 'node:path'
 import { ENV_FILE_NAME } from '#ports'
 import type { AgentProfile } from '#scripts/agent/agent-role-profile'
@@ -38,6 +38,9 @@ interface LaneInfo {
 	// instead of waiting for the pool to drain before it can be cut.
 	output: string | undefined
 	profile?: AgentProfile | undefined
+	// When the lane last took a child: `lane:open` writes its `.env`, and every dispatch records its
+	// unit there (`lane-output.ts`). `undefined` where the `.env` cannot be read.
+	dispatched_ms?: number | undefined
 	is_stranded: boolean
 }
 
@@ -106,6 +109,10 @@ function read_environment(directory: string): string | undefined {
 	return file_reader.read_if_readable(path.join(directory, ENV_FILE_NAME))
 }
 
+function dispatched_at(directory: string): number | undefined {
+	return statSync(path.join(directory, ENV_FILE_NAME), { throwIfNoEntry: false })?.mtimeMs
+}
+
 // A lane is identified by its branch rather than by where it sits, so nothing here compares two
 // spellings of one path — git prints the resolved one, and a lane root reached through a symlink
 // would otherwise read as no lane at all.
@@ -151,6 +158,7 @@ function build_lane(
 		preview_port: held.preview_port,
 		output,
 		profile,
+		dispatched_ms: is_stranded ? undefined : dispatched_at(directory),
 		is_stranded,
 	}
 }
@@ -175,9 +183,14 @@ function parse_block(block: string, root: string): LaneInfo | undefined {
 	const branch = line_value(lines, BRANCH_PREFIX)
 	const issue = branch_issue(branch)
 
-	if (directory === undefined || branch === undefined || issue === undefined) return undefined
-
-	if (!is_lane_directory(root, issue, directory)) return undefined
+	if (
+		directory === undefined ||
+		branch === undefined ||
+		issue === undefined ||
+		!is_lane_directory(root, issue, directory)
+	) {
+		return undefined
+	}
 
 	return build_lane(issue, branch, directory, is_gone(directory))
 }
@@ -236,11 +249,6 @@ async function has_lanes_in_flight(): Promise<boolean> {
 	return lanes.some((lane) => !lane.is_stranded)
 }
 
-/** The lanes in use: the open work trees an interruption has not stranded. */
-function live_count(lanes: ReadonlyArray<LaneInfo>): number {
-	return lanes.filter((lane) => !lane.is_stranded).length
-}
-
 /** The seats live lanes hold — what a new lane's seat has to avoid. */
 function used_seats(lanes: ReadonlyArray<LaneInfo>): Array<number> {
 	return lanes.map((lane) => lane.seat).filter((seat): seat is number => seat !== undefined)
@@ -272,7 +280,6 @@ const lane_registry = {
 	find_open_lane,
 	has_lanes_in_flight,
 	list_lanes,
-	live_count,
 	main_repository_root,
 	parse_block,
 	read_environment,

package/scripts/lane/lane-restart.ts

@@ -1,14 +1,12 @@
-import { git_stash } from '#scripts/git/stash/git-stash'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { session_cite } from '#scripts/issue/session-cite'
-import { error_text } from '#scripts/lib/error-message'
 import { run_cut } from '#scripts/run/cut/run-cut'
 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 { lane_dispatch, type DispatchOutcome } from './lane-dispatch'
-import { lane_preserve } from './lane-preserve'
+import { lane_preserve, type KeptWork } from './lane-preserve'
 import { lane_reap } from './lane-reap'
 import { lane_registry, type LaneInfo } from './lane-registry'
 
@@ -38,11 +36,7 @@ const NO_LANE_KIND = 'no-lane'
 const NOT_RUNNING_KIND = 'not-running'
 const UNCLAIMED_KIND = 'unclaimed'
 
-interface Unsaved {
-	kind: 'unsaved'
-	directory: string
-	reason: string
-}
+type Unsaved = Extract<KeptWork, { kind: 'unsaved' }>
 
 interface Restarted {
 	kind: 'restarted'
@@ -55,7 +49,6 @@ type Refused =
 	| { kind: typeof NOT_RUNNING_KIND }
 	| { kind: typeof UNCLAIMED_KIND; reason: string }
 type RestartOutcome = Restarted | Unsaved | Refused
-type Saved = Unsaved | { kind: 'saved'; stash: string | undefined }
 
 // A cut the stopped child carried would hand its successor the old session's hand-off at
 // `run:cut --resume`; the fresh session has to start from the Issue instead.
@@ -65,22 +58,6 @@ function end_carried_cut(lane: LaneInfo): void {
 	if (carried !== undefined) run_cut.end_cut(carried.target)
 }
 
-async function stash_of(lane: LaneInfo): Promise<string | undefined> {
-	if (!(await git_stash.has_changes(lane.directory))) return undefined
-
-	return await lane_preserve.push_work(lane.issue, lane.directory, RESTART_OCCASION)
-}
-
-// A tree that could not be read or pushed is left as it is: re-dispatching into it would hand the fresh
-// session the stopped one's half-done work as though it were its own.
-async function save_work(lane: LaneInfo): Promise<Saved> {
-	try {
-		return { kind: 'saved', stash: await stash_of(lane) }
-	} catch (error) {
-		return { kind: 'unsaved', directory: lane.directory, reason: error_text.message_of(error) }
-	}
-}
-
 async function record_restart(issue: string): Promise<void> {
 	await run_event_stream_emit.emit(
 		run_event_stream.EVENT_KIND.RESTART,
@@ -88,9 +65,11 @@ async function record_restart(issue: string): Promise<void> {
 	)
 }
 
+// A tree that could not be read or pushed is left as it is: re-dispatching into it would hand the fresh
+// session the stopped one's half-done work as though it were its own.
 async function relaunch(lane: LaneInfo): Promise<RestartOutcome> {
 	end_carried_cut(lane)
-	const saved = await save_work(lane)
+	const saved = await lane_preserve.keep_work(lane.issue, lane.directory, RESTART_OCCASION)
 
 	if (saved.kind === 'unsaved') return saved
 	const dispatch = await lane_dispatch.dispatch_child(lane.issue, 'restart')