@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/scripts/lane/lane-await.ts

@@ -2,7 +2,7 @@ import { spawnSync } from 'node:child_process'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { parseArgs } from 'node:util'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
-import { PROBE_TIMEOUT_MS } from '#scripts/lib/timeouts'
+import { MS_PER_SECOND, PROBE_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import {
 	PROCESS_ALIVE,
 	PROCESS_NONE,
@@ -28,7 +28,6 @@ import { process_tools } from './process-tools'
 const RECONFIRM_MS = 15_000
 const DEFAULT_POLL_MS = 5000
 const NEVER_APPEARED_TIMEOUT_MS = 600_000
-const MS_PER_SECOND = 1000
 const PROCESS_FOUND = 0
 const PROCESS_NOT_FOUND = 1
 const PGREP_COMMAND = 'pgrep'
@@ -36,8 +35,14 @@ const PGREP_COMMAND = 'pgrep'
 // `is_settled` is read once, when the wait starts: a child that ended between two `lane:await` calls
 // never appears in the second one, and only its settled issue tells it apart from one not yet
 // launched.
+//
+// `alive_since` is when this run of the child was first seen alive: a ship it launched is no older, so
+// a ship record launched earlier is a past dispatch's (joshuafolkken/kit#4395). A child already alive
+// when the watch began gets the first poll's time, so a ship it launched before that is not read as
+// its own and its disappearance waits out the re-confirm window.
 interface AwaitState {
 	appeared: boolean
+	alive_since?: number | undefined
 	disappeared_at: number | undefined
 	first_polled_at: number | undefined
 	is_settled?: boolean
@@ -56,6 +61,7 @@ interface RawAwaitArguments {
 // Injectable for testing -- the CLI never overrides these.
 interface AwaitOptions {
 	is_running?: (issue: string) => boolean
+	is_shipped?: (issue: string, since_ms: number) => boolean
 	is_settled?: (issue: string) => Promise<boolean>
 	poll_ms?: number
 	reconfirm_ms?: number
@@ -64,8 +70,11 @@ interface AwaitOptions {
 	sleep?: (ms: number) => Promise<void>
 }
 
+// `is_shipped` is the one disappearance the re-confirm window never has to cover: a ship that ended in
+// success merged the child's work, so no cut hand-off can follow it (joshuafolkken/kit#4395).
 interface CheckConfig {
 	is_running: (issue: string) => boolean
+	is_shipped?: (issue: string, since_ms: number) => boolean
 	reconfirm_ms: number
 	never_appeared_timeout_ms: number
 }
@@ -100,6 +109,10 @@ function is_process_running_default(issue: string): boolean {
 	return process_trace_default(issue) === PROCESS_ALIVE
 }
 
+function is_shipped_default(issue: string, since_ms: number): boolean {
+	return lane_handoff.is_ship_succeeded(issue, process.cwd(), since_ms)
+}
+
 // The same positive evidence `run:liveness` answers `settled` on: the issue closed, or it was parked.
 async function is_settled_default(issue: string): Promise<boolean> {
 	return (await run_liveness.read_child_settled(issue)) === true
@@ -164,9 +177,16 @@ function resolve_timing(
 	}
 }
 
-function resolve_options(options: AwaitOptions): RunConfig {
+function resolve_probes(options: AwaitOptions): Pick<RunConfig, 'is_running' | 'is_shipped'> {
 	return {
 		is_running: options.is_running ?? is_process_running_default,
+		is_shipped: options.is_shipped ?? is_shipped_default,
+	}
+}
+
+function resolve_options(options: AwaitOptions): RunConfig {
+	return {
+		...resolve_probes(options),
 		is_settled: options.is_settled ?? is_settled_default,
 		now: options.now ?? Date.now,
 		sleep: options.sleep ?? sleep,
@@ -174,9 +194,11 @@ function resolve_options(options: AwaitOptions): RunConfig {
 	}
 }
 
-function update_liveness(state: AwaitState, is_live: boolean): void {
+function update_liveness(state: AwaitState, is_live: boolean, now_ms: number): void {
 	if (!is_live) return
 
+	if (!state.appeared || state.disappeared_at !== undefined) state.alive_since = now_ms
+
 	state.appeared = true
 	state.disappeared_at = undefined
 }
@@ -203,6 +225,28 @@ function check_not_appeared(
 	return undefined
 }
 
+// The ship this run of the child launched succeeded.
+function is_own_ship_done(issue: string, state: AwaitState, config: CheckConfig): boolean {
+	const { alive_since } = state
+
+	return alive_since !== undefined && config.is_shipped?.(issue, alive_since) === true
+}
+
+// A child that appeared and is gone: done at once when its ship succeeded, else once it stayed gone
+// past the re-confirm window.
+function check_gone(
+	issue: string,
+	state: AwaitState,
+	now_ms: number,
+	config: CheckConfig,
+): string | undefined {
+	if (is_own_ship_done(issue, state, config)) return issue
+
+	state.disappeared_at ??= now_ms
+
+	return now_ms - state.disappeared_at >= config.reconfirm_ms ? issue : undefined
+}
+
 // Returns the issue that has confirmed-completed this tick, `undefined` if none yet.
 // The `appeared` guard prevents a process that never showed up from being declared done, unless its
 // issue had already settled when the wait started.
@@ -214,7 +258,7 @@ function check_issue(
 ): string | undefined {
 	const is_live = config.is_running(issue)
 
-	update_liveness(state, is_live)
+	update_liveness(state, is_live, now_ms)
 
 	if (is_live) return undefined
 
@@ -222,13 +266,7 @@ function check_issue(
 		return check_not_appeared(issue, state, now_ms, config.never_appeared_timeout_ms)
 	}
 
-	if (state.disappeared_at === undefined) {
-		state.disappeared_at = now_ms
-
-		return undefined
-	}
-
-	return now_ms - state.disappeared_at >= config.reconfirm_ms ? issue : undefined
+	return check_gone(issue, state, now_ms, config)
 }
 
 function check_any(
@@ -267,6 +305,7 @@ const lane_await = {
 	RECONFIRM_MS,
 	check_issue,
 	is_process_running_default,
+	is_shipped_default,
 	parse_arguments,
 	process_trace_default,
 	wait_for_any,

package/scripts/lane/lane-cache.ts

@@ -1,13 +1,4 @@
-import { randomUUID } from 'node:crypto'
-import {
-	cpSync,
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	renameSync,
-	rmSync,
-	writeFileSync,
-} from 'node:fs'
+import { cpSync, existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { hook_launch } from '#scripts/init/hook-launch'
 import {
@@ -15,6 +6,7 @@ import {
 	SHARED_CACHE_SPECS,
 	type GateCacheSpec,
 } from '#scripts/josh/josh-command-types'
+import { atomic_write } from '#scripts/lib/atomic-write'
 
 // Warming a fresh lane's verification caches from the main checkout.
 //
@@ -75,30 +67,13 @@ function portable_content(
 // runs in parallel with the tool whose cache is being copied, and a temporary name in the checkout
 // root is listed by its tree walk and gone by the time it is read (#3763). `node_modules` is skipped
 // by every tree scan and sits on the checkout's own filesystem, so the rename stays atomic.
-function stage_path(destination_root: string, cache_file: string): string {
-	const staging_directory = path.join(destination_root, ...STAGING_SEGMENTS)
-
-	mkdirSync(staging_directory, { recursive: true })
-
-	return path.join(staging_directory, `${cache_file}.${String(process.pid)}.${randomUUID()}.tmp`)
-}
-
-function publish_staged(temporary_path: string, destination_path: string, content: string): void {
-	try {
-		writeFileSync(temporary_path, content, { flag: 'wx' })
-		renameSync(temporary_path, destination_path)
-	} finally {
-		rmSync(temporary_path, { force: true })
-	}
-}
-
 function write_atomically(destination_root: string, cache_file: string, content: string): void {
 	if (!existsSync(destination_root)) return
 
 	try {
-		const temporary_path = stage_path(destination_root, cache_file)
-
-		publish_staged(temporary_path, path.join(destination_root, cache_file), content)
+		atomic_write.replace_file(path.join(destination_root, cache_file), content, {
+			staging_directory: path.join(destination_root, ...STAGING_SEGMENTS),
+		})
 	} catch {
 		// Best-effort: a cache that could not be published simply leaves the destination unchanged.
 	}

package/scripts/lane/lane-capacity.ts

@@ -1,3 +1,4 @@
+import { cli_flags, type PositiveSetting } from '#scripts/lib/cli-flags'
 import { lane_limit_override } from './lane-limit-override'
 import type { LaneEnvironment } from './lane-paths'
 import { lane_seed_policy } from './lane-seed'
@@ -21,32 +22,16 @@ import { lane_seed_policy } from './lane-seed'
 // the swap peak, the slowest gates and most of the gate and commit failures.
 const DEFAULT_LANE_LIMIT = 4
 const LANE_LIMIT_KEY = 'JOSH_LANE_LIMIT'
-const POSITIVE_INTEGER = /^[1-9]\d*$/u
 const NO_LANES = 0
 
-// The limit, or why it could not be read. A problem rather than a throw, for the reason
-// `eval-runner.ts` records for `JOSH_EVAL_CONCURRENCY`: the caller decides whether a bad setting
-// ends the command or is reported and worked around, and only it knows which.
-type LimitChoice = { kind: 'limit'; limit: number } | { kind: 'problem'; problem: string }
+// The limit, or why it could not be read.
+type LimitChoice = PositiveSetting
 
 // **An invalid value is a hard error, never a silent fall back to the default** — the rule
-// `PORT_SEED` already holds to. A typo that quietly becomes 4 is a limit nobody set, and the whole
-// point of the setting is that the number is the one a person chose.
-//
-// Blank is unset, not invalid: an `.env` line left as `JOSH_LANE_LIMIT=` is a variable nobody
-// configured, exactly as `lane_paths.lane_root` reads a blank root.
-//
-// `name` is what the problem names: `josh lane:limit` reads its argument by the same rule.
+// `PORT_SEED` already holds to. `name` is what the problem names: `josh lane:limit` reads its argument
+// by the same rule.
 function read_limit(raw: string | undefined, name: string): LimitChoice {
-	const trimmed = raw?.trim() ?? ''
-
-	if (trimmed === '') return { kind: 'limit', limit: DEFAULT_LANE_LIMIT }
-
-	if (!POSITIVE_INTEGER.test(trimmed)) {
-		return { kind: 'problem', problem: `${name} must be a positive integer, not "${trimmed}"` }
-	}
-
-	return { kind: 'limit', limit: Number(trimmed) }
+	return cli_flags.read_positive_setting(raw, name, DEFAULT_LANE_LIMIT)
 }
 
 // **A live run's `lane:limit` override outranks the environment**: a running
@@ -76,17 +61,23 @@ function seated_limit(limit: number): number {
 //
 // **A lane that holds no place under the limit still holds its port seat** (joshuafolkken/kit#3967):
 // `seated` counts every open lane, so the free count never offers more launches than seats are left.
+// The places left under the limit, port seats aside: what resuming a lane that keeps its seat is
+// weighed against (joshuafolkken/kit#4107).
+function limit_room(limit: number, occupied: number): number {
+	return Math.max(NO_LANES, seated_limit(limit) - occupied)
+}
+
 function free_lanes(limit: number, occupied: number, seated = occupied): number {
-	const by_limit = seated_limit(limit) - occupied
 	const by_seats = lane_seed_policy.LAST_LANE_SEAT - seated
 
-	return Math.max(NO_LANES, Math.min(by_limit, by_seats))
+	return Math.max(NO_LANES, Math.min(limit_room(limit, occupied), by_seats))
 }
 
 const lane_capacity = {
 	LANE_LIMIT_KEY,
 	free_lanes,
 	lane_limit,
+	limit_room,
 	read_limit,
 	seated_limit,
 }

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

@@ -1,17 +1,26 @@
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { lane_ledger, type GateCheckRecord, type GateEntry, type LedgerEntry } from './lane-ledger'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats, type StatsWindow } from './lane-stats'
 
-// Which check a gate waited on: the ledger's per-check rows of one period reduced to one row per check
-// — median, maximum, how many runs and how many were reused — printed last by `josh lane:stats`. The
-// rows are in the order the checks first appear.
+// Which check a gate waited on: one period's per-check rows reduced to one row per check — median,
+// maximum, runs, reuses, no-ops and whole-suite fallbacks — printed last by `josh lane:stats`.
+//
+// The whole gate is the first row, since its reuse started no check (joshuafolkken/kit#4397); the
+// checks follow in the order they first appear.
 //
 // **A reused check is counted, never timed.** It started no process, so its zero would pull the median
-// toward a check that never ran; a check with only reused rows prints `not measured`.
+// toward a check that never ran; a check with only reused rows prints `not measured`. **The unit leg's
+// since-green no-op is counted the same way** (joshuafolkken/kit#4457): it ran no test, so its second
+// would stand for a run that tested nothing.
+//
+// **The fallbacks are broken down by why** in a second table, one row per reason kind, so a slow unit
+// leg can be read as the full suite it ran and the reason it had to.
 
-const MS_PER_SECOND = 1000
 const DECIMALS = 1
-const COLUMNS = ['check', 'median (s)', 'max (s)', 'runs', 'reused'] as const
+const WHOLE_GATE_LABEL = 'gate (whole)'
+const COLUMNS = ['check', 'median (s)', 'max (s)', 'runs', 'reused', 'no-op', 'fallback'] as const
+const FALLBACK_COLUMNS = ['fallback reason', 'runs'] as const
 
 function is_gate(entry: LedgerEntry): entry is GateEntry {
 	return entry.kind === lane_ledger.KIND.GATE
@@ -23,34 +32,66 @@ function cell(milliseconds: number | undefined): string {
 		: (milliseconds / MS_PER_SECOND).toFixed(DECIMALS)
 }
 
+function header(columns: ReadonlyArray<string>): Array<string> {
+	return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => '---'))]
+}
+
+function count(
+	runs: ReadonlyArray<GateCheckRecord>,
+	is_counted: (check: GateCheckRecord) => boolean,
+): string {
+	return String(runs.filter((check) => is_counted(check)).length)
+}
+
 function check_row(label: string, checks: ReadonlyArray<GateCheckRecord>): string {
 	const runs = checks.filter((check) => check.label === label)
-	const timed = runs.filter((check) => check.is_reused !== true).map((check) => check.elapsed_ms)
+	const timed = runs.filter((check) => check.is_reused !== true && check.is_unmoved !== true)
+	const elapsed = timed.map((check) => check.elapsed_ms)
 
 	return lane_stats.to_row([
 		label,
-		cell(lane_stats.median(timed)),
-		cell(lane_stats.peak(timed)),
+		cell(lane_stats.median(elapsed)),
+		cell(lane_stats.peak(elapsed)),
 		String(runs.length),
-		String(runs.length - timed.length),
+		count(runs, (check) => check.is_reused === true),
+		count(runs, (check) => check.is_unmoved === true),
+		count(runs, (check) => check.fallback !== undefined),
 	])
 }
 
-// The period's table: `entries` is the whole ledger, filtered here to `window`.
+// The whole gate read as one more check, so its reuse is counted the way a check's is.
+function whole_gate(gate: GateEntry): GateCheckRecord {
+	return {
+		label: WHOLE_GATE_LABEL,
+		elapsed_ms: gate.elapsed_ms,
+		is_passed: gate.is_passed,
+		is_reused: gate.is_reused,
+	}
+}
+
+function fallback_table(checks: ReadonlyArray<GateCheckRecord>): string {
+	const reasons = checks.map((check) => check.fallback).filter((reason) => reason !== undefined)
+	const kinds = [...new Set(reasons)]
+	const rows = kinds.map((kind) =>
+		lane_stats.to_row([kind, String(reasons.filter((reason) => reason === kind).length)]),
+	)
+
+	return [...header(FALLBACK_COLUMNS), ...rows].join('\n')
+}
+
+// The period's tables: `entries` is the whole ledger, filtered here to `window`.
 function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
-	const checks = lane_stats
-		.in_window(entries, window)
-		.filter(is_gate)
-		.flatMap((gate) => gate.checks ?? [])
-	const labels = [...new Set(checks.map((check) => check.label))]
+	const gates = lane_stats.in_window(entries, window).filter(is_gate)
+	const checks = gates.flatMap((gate) => gate.checks ?? [])
+	const rows = [...gates.map((gate) => whole_gate(gate)), ...checks]
+	const labels = [...new Set(rows.map((row) => row.label))]
 
 	return [
-		lane_stats.to_row(COLUMNS),
-		lane_stats.to_row(COLUMNS.map(() => '---')),
-		...labels.map((label) => check_row(label, checks)),
-	].join('\n')
+		[...header(COLUMNS), ...labels.map((label) => check_row(label, rows))].join('\n'),
+		fallback_table(checks),
+	].join('\n\n')
 }
 
-const lane_check_stats = { table }
+const lane_check_stats = { WHOLE_GATE_LABEL, table }
 
 export { lane_check_stats }

package/scripts/lane/lane-child-invocation.ts

@@ -47,6 +47,13 @@ function process_pattern(issue: string): string {
 	return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`
 }
 
+// The `pgrep -f` pattern that finds the detached ship supervisor of `issue` alone.
+function ship_pattern(issue: string): string {
+	issue_number_shape.require_issue_number(issue)
+
+	return `${SHIP_PROCESS} .* ${issue_cite.plain(issue)}$`
+}
+
 function review_invocation(issue: string): string {
 	issue_number_shape.require_issue_number(issue)
 
@@ -126,6 +133,7 @@ const lane_child_invocation = {
 	process_pattern,
 	resume_invocation,
 	review_invocation,
+	ship_pattern,
 	ship_stop_invocation,
 }
 

package/scripts/lane/lane-cli.ts

@@ -17,6 +17,7 @@ import { lane_open, type OpenOutcome } from './lane-open'
 import { lane_output, type ReadOutcome, type RecordOutcome } from './lane-output'
 import { lane_registry, type LaneInfo } from './lane-registry'
 import { lane_report } from './lane-report'
+import { lane_residents } from './lane-residents'
 import { lane_seed_policy } from './lane-seed'
 import type { KeptLane } from './lane-spent'
 import { lane_stray } from './lane-stray'
@@ -111,16 +112,25 @@ function report_issues(issues: ReadonlyArray<string>): number {
 	return SUCCESS_EXIT_CODE
 }
 
-// A close that left something behind exits non-zero and names it. Reported as a success, it would
-// send the caller to the next `lane:open`, which then fails on git's own message about a branch that
-// still exists.
-function report_close(outcome: CloseOutcome): number {
+// What the close terminated: the lane child that had not ended, and what else ran from the checkout.
+function report_terminated(outcome: CloseOutcome): void {
+	const cited = session_cite.issue(outcome.issue)
+
 	if (outcome.reaped.length > 0) {
 		console.error(
-			`Terminated the lane child for ${session_cite.issue(outcome.issue)} that had not ended by itself: process ${outcome.reaped.join(', ')}.`,
+			`Terminated the lane child for ${cited} that had not ended by itself: process ${outcome.reaped.join(', ')}.`,
 		)
 	}
 
+	lane_residents.report(outcome.residents, cited)
+}
+
+// A close that left something behind exits non-zero and names it. Reported as a success, it would
+// send the caller to the next `lane:open`, which then fails on git's own message about a branch that
+// still exists.
+function report_close(outcome: CloseOutcome): number {
+	report_terminated(outcome)
+
 	if (outcome.kind !== 'incomplete') {
 		return report_issues(outcome.kind === 'closed' ? [outcome.issue] : [])
 	}

package/scripts/lane/lane-close.ts

@@ -4,8 +4,11 @@ import { git_worktree } from '#scripts/git/git-worktree'
 import { error_text } from '#scripts/lib/error-message'
 import { lane_paths } from './lane-paths'
 import { lane_reap } from './lane-reap'
+import { lane_reap_settle } from './lane-reap-settle'
 import { lane_registry, type LaneInfo } from './lane-registry'
+import { lane_residents } from './lane-residents'
 import { lane_spent, type KeptLane } from './lane-spent'
+import { lane_state } from './lane-state'
 
 // Closing a lane: no work tree, no branch, no directory.
 //
@@ -13,7 +16,8 @@ import { lane_spent, type KeptLane } from './lane-spent'
 // every step here is written to run over a subject that is already gone or that still holds
 // uncommitted work. A close that refused either would leave exactly the debris it exists to remove,
 // and the next lane for that issue would then fail on a directory nobody could account for. There
-// is no ledger entry to remove: the lane's seat lived in the `.env` that goes with the work tree.
+// is no ledger entry to remove: the lane's seat lived in the `.env` that goes with the work tree. The
+// lane's state record outlives it, marked `ended`, so its last state stays readable.
 
 interface LaneTargets {
 	directory: string
@@ -36,6 +40,9 @@ interface CloseOutcome {
 	left_behind: Array<string>
 	// The lane child's processes this close terminated — empty for a child that ended by itself.
 	reaped: Array<number>
+	// What else still ran from the lane's checkout or carried its mark and this close terminated
+	// (`lane-residents.ts`); `undefined` where the processes could not be read.
+	residents: Array<number> | undefined
 }
 
 interface SweepOutcome {
@@ -112,39 +119,72 @@ function close_kind(did_exist: boolean, left_behind: ReadonlyArray<string>): Clo
 	return did_exist ? 'closed' : 'none'
 }
 
-// The main work tree's root, not this one's — the same reading `list_lanes` uses, so the fallback
-// directory an unregistered lane is closed by is the one `lane:open` would have created.
-// Derived here from the current work tree, a close run inside a lane
-// reports `none` over a directory that is still on disk.
-async function lane_root_directory(): Promise<string> {
-	return lane_paths.lane_root(await lane_registry.main_repository_root())
-}
-
+// The lane root is the main work tree's (`lane_root_directory`), so the fallback directory an
+// unregistered lane is closed by is the one `lane:open` would have created.
 /**
  * Close the lane for `issue`. `none` means there was nothing there, which is not a failure: a caller
  * cleaning up after an interruption cannot know whether the lane was ever opened. `incomplete` means
  * something survived the removal, and `left_behind` names it.
  */
 async function resolve_lane(issue: string): Promise<ResolvedLane> {
-	const root = await lane_root_directory()
+	const root = await lane_registry.lane_root_directory()
 	const existing = lane_registry.find_lane(await lane_registry.list_lanes(), issue)
 
 	return { existing, targets: lane_targets(root, issue, existing) }
 }
 
+// A lane closed before is `none` on a retry, and ends there once its record says it is not over —
+// an issue never opened is not given a record.
+async function is_ending(issue: string, kind: CloseKind): Promise<boolean> {
+	if (kind !== 'none') return kind === 'closed'
+
+	const record = await lane_state.read_state(issue)
+
+	return record !== undefined && record.state !== 'ended'
+}
+
+// The lane's processes, settled after the removal so the processes have had the work tree's deletion
+// to exit in too; what outlived the SIGKILL replaces what the lane's record noted for `run:board`.
+async function survivors_of(issue: string, directory: string): Promise<Array<string>> {
+	const survivors = await lane_reap_settle.settle({ issue, directory })
+
+	if (survivors !== undefined) await lane_state.record_stuck(issue, survivors)
+
+	return lane_reap_settle.survivor_texts(survivors)
+}
+
+// Whatever the removal left: the checkout's residue, then the processes that outlived it.
+async function left_behind_of(issue: string, targets: LaneTargets): Promise<Array<string>> {
+	const survivors = await survivors_of(issue, targets.directory)
+
+	return [...(await residue(targets)), ...survivors]
+}
+
 async function close_lane(issue: string): Promise<CloseOutcome> {
 	const { existing, targets } = await resolve_lane(issue)
 	const did_exist = existing !== undefined || existsSync(targets.directory)
 	// Before the removal, not after: a child still running in the tree would keep writing into a
 	// directory being deleted, and a process outliving its lane is a half-discarded state — the work
-	// tree gone, the child still answering `alive`.
-	const reaped = lane_reap.reap_child(issue)
+	// tree gone, the child still answering `alive`. What else still runs from the checkout goes too.
+	const reaped = lane_reap.reap_child({ issue, directory: targets.directory })
+	const residents = lane_residents.end_residents({ issue, directory: targets.directory }, reaped)
 
 	await remove_lane(targets)
 
-	const left_behind = await residue(targets)
+	const left_behind = await left_behind_of(issue, targets)
+	const kind = close_kind(did_exist, left_behind)
+
+	if (await is_ending(issue, kind)) {
+		await lane_state.record_change({ issue, state: 'ended', command: 'lane:close' })
+	}
+
+	return { issue, kind, left_behind, reaped, residents }
+}
+
+type DuePredicate = (issue: string) => Promise<boolean>
 
-	return { issue, kind: close_kind(did_exist, left_behind), left_behind, reaped }
+async function always_due(): Promise<boolean> {
+	return true
 }
 
 // A lane that could not be closed is recorded rather than thrown: a sweep has to attempt every lane,
@@ -163,14 +203,24 @@ async function try_close(issue: string): Promise<boolean> {
 
 // Sequential on purpose: two `git worktree` writes at once contend for the same registration
 // directory, and the whole point of the command is that nothing is left half-removed.
-async function close_each(issues: ReadonlyArray<string>): Promise<SweepOutcome> {
+async function close_into(sweep: SweepOutcome, issue: string, is_due: DuePredicate): Promise<void> {
+	if (!(await is_due(issue))) return
+	const bucket = (await try_close(issue)) ? sweep.closed : sweep.failed
+
+	bucket.push(issue)
+}
+
+// `is_due` is asked right before each close, not for every issue up front: a close can wait out the
+// grace window, and a lane opened again meanwhile is no longer one to close.
+async function close_each(
+	issues: ReadonlyArray<string>,
+	is_due: DuePredicate = always_due,
+): Promise<SweepOutcome> {
 	const sweep: SweepOutcome = { closed: [], failed: [] }
 
 	for (const issue of issues) {
 		// eslint-disable-next-line no-await-in-loop -- worktree writes contend for the same registration directory
-		const bucket = (await try_close(issue)) ? sweep.closed : sweep.failed
-
-		bucket.push(issue)
+		await close_into(sweep, issue, is_due)
 	}
 
 	return sweep
@@ -196,11 +246,29 @@ async function close_all_lanes(): Promise<SweepOutcome> {
 	return await close_each(lanes.map((lane) => lane.issue))
 }
 
+async function is_unfinished(issue: string): Promise<boolean> {
+	const { targets } = await resolve_lane(issue)
+
+	return !existsSync(targets.directory)
+}
+
+/**
+ * Close again every lane whose work tree is gone but whose record is not `ended` — a close a process
+ * outlived. The supervisor runs it each pass, so a lane ends once its last process does.
+ */
+async function retry_closes(): Promise<SweepOutcome> {
+	const records = await lane_state.read_records()
+	const issues = records.filter((record) => record.state !== 'ended').map(({ issue }) => issue)
+
+	return await close_each(issues, is_unfinished)
+}
+
 const lane_close = {
 	close_all_lanes,
 	close_lane,
 	prune_lanes,
 	resolve_lane,
+	retry_closes,
 }
 
 export type { CloseKind, CloseOutcome, PruneOutcome, ResolvedLane, SweepOutcome }