@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -1,17 +1,33 @@
-import { lane_ledger, type GateCheckRecord, type GateEntry, type LedgerEntry } from './lane-ledger'
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
+import {
+	lane_ledger,
+	type GateCheckRecord,
+	type GateEntry,
+	type LedgerEntry,
+	type PushMissEntry,
+} 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 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. A pre-push hook that ran a suite
+// over a record it could not reuse joins it, prefixed `pre-push <scope>:`.
 
-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 +39,80 @@ 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 is_push_miss(entry: LedgerEntry): entry is PushMissEntry {
+	return entry.kind === lane_ledger.KIND.PUSH_MISS
+}
+
+// A pre-push hook's miss, told apart from the gate's own fallbacks by its scope (joshuafolkken/kit#5234).
+function push_reason(miss: PushMissEntry): string {
+	return `pre-push ${miss.scope}: ${miss.reason}`
+}
+
+function fallback_table(
+	checks: ReadonlyArray<GateCheckRecord>,
+	misses: ReadonlyArray<PushMissEntry>,
+): string {
+	const fallbacks = checks.map((check) => check.fallback).filter((reason) => reason !== undefined)
+	const reasons = [...fallbacks, ...misses.map((miss) => push_reason(miss))]
+	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 windowed = lane_stats.in_window(entries, window)
+	const gates = windowed.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, windowed.filter(is_push_miss)),
+	].join('\n\n')
 }
 
-const lane_check_stats = { table }
+const lane_check_stats = { WHOLE_GATE_LABEL, cell, header, 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)
 
@@ -88,8 +95,8 @@ function outage_resume_invocation(issue: string): string {
 // tail and the changed files (`run-ship-stop-context.ts`), so the session starts at the fix rather than
 // at `josh ship --log` and `git diff` (joshuafolkken/kit#3923).
 //
-// The context gets what the rest of the prompt leaves of the one argv element's cap, so the whole
-// prompt still launches (joshuafolkken/kit#3964).
+// The context gets what the rest of the prompt leaves of `MAX_VALUE_LENGTH`, so the whole prompt
+// stays within it and launches (joshuafolkken/kit#3964).
 function known_stop_lines(
 	issue: string,
 	stop: ShipStop,
@@ -120,13 +127,21 @@ function ship_stop_invocation(issue: string, stop?: ShipStop): string {
 	return [opening, ...middle, closing].join(LINE_BREAK)
 }
 
+// The same stop for the session that launched the ship and still waits on it (`run-ship-waiter.ts`):
+// the next command and the context alone, since that session has the run in front of it already.
+function ship_stop_note(issue: string, stop: ShipStop): string {
+	return known_stop_lines(issue, stop, []).join(LINE_BREAK)
+}
+
 const lane_child_invocation = {
 	child_invocation,
 	outage_resume_invocation,
 	process_pattern,
 	resume_invocation,
 	review_invocation,
+	ship_pattern,
 	ship_stop_invocation,
+	ship_stop_note,
 }
 
 export type { ShipStop }

package/scripts/lane/lane-child-mark-keys.ts

@@ -0,0 +1,12 @@
+// The environment keys a launcher marks a lane child with, in a module of their own so the unit
+// suite's vitest config reads them without widening its import graph (`whole-suite-files.ts`).
+// `lane-child-marker.ts` documents each mark; a mark added there is added here, and the unit suite
+// then blanks it with no list of its own (joshuafolkken/kit#5029).
+
+const KEY = 'JOSH_LANE_CHILD'
+const OVERRUN_KEY = 'JOSH_LANE_OVERRUN'
+const MARK_KEYS: ReadonlyArray<string> = [KEY, OVERRUN_KEY]
+
+const lane_child_mark_keys = { KEY, MARK_KEYS, OVERRUN_KEY }
+
+export { lane_child_mark_keys }

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

@@ -1,4 +1,5 @@
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { lane_child_mark_keys } from './lane-child-mark-keys'
 import { lane_paths } from './lane-paths'
 
 // The mark a dispatched lane child carries, so the pre-gate cut and a resume are decided from the
@@ -17,7 +18,7 @@ import { lane_paths } from './lane-paths'
 // equals the lane's own issue, so a leaked mark for another issue is read as absent. The name, the
 // meaning and the lifetime are documented once in
 // `.claude/skills/workflow-commands/pre-gate-cut.md`.
-const KEY = 'JOSH_LANE_CHILD'
+const { KEY, OVERRUN_KEY } = lane_child_mark_keys
 
 // **A dispatched child also asks for the five-minute prompt-cache TTL**. A
 // headless `claude -p` session on a subscription defaults to the one-hour TTL, whose writes bill at 2x
@@ -28,6 +29,11 @@ const KEY = 'JOSH_LANE_CHILD'
 const CACHE_TTL_KEY = 'CLAUDE_CODE_PROMPT_CACHE_TTL'
 const CACHE_TTL = '5m'
 
+// **An overrun investigation also carries its own mark** (joshuafolkken/kit#4880): it runs as the
+// lane's child, so `issue:file` reads this one to record its filings as the investigation's rather than
+// the child's. The launcher sets it, so the record never rests on the model passing an argument.
+const OVERRUN_VALUE = '1'
+
 type MarkerSource = Readonly<Record<string, string | undefined>>
 
 // The environment fragment that marks a child dispatched for `#<issue>`. Composed from a digits-only
@@ -50,6 +56,16 @@ function marked_issue(source: MarkerSource = process.env): string | undefined {
 	return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
 }
 
+// The environment of the overrun investigation of `#<issue>`'s lane: the child's, plus its own mark.
+function overrun_environment_for(issue: string): Record<string, string> {
+	return { ...environment_for(issue), [OVERRUN_KEY]: OVERRUN_VALUE }
+}
+
+// Read only beside a valid child mark, so a mark leaked without one is read as absent.
+function is_overrun(source: MarkerSource = process.env): boolean {
+	return source[OVERRUN_KEY] === OVERRUN_VALUE && marked_issue(source) !== undefined
+}
+
 // True when this session is a dispatched lane child for the checkout it is running in: the mark is
 // present and names this lane's own issue, read from the checkout path. A numeric mark naming a
 // *different* issue leaked in from a parent session into a checkout it does not belong to, so it is
@@ -63,8 +79,11 @@ function is_child_of(directory: string, source: MarkerSource = process.env): boo
 
 const lane_child_marker = {
 	KEY,
+	OVERRUN_KEY,
 	env_for: environment_for,
+	overrun_env_for: overrun_environment_for,
 	is_child_of,
+	is_overrun,
 	marked_issue,
 }
 

package/scripts/lane/lane-ci-path-stats.ts

@@ -0,0 +1,73 @@
+import { lane_check_stats } from './lane-check-stats'
+import { lane_ledger, type LedgerEntry, type StageEntry } from './lane-ledger'
+import { lane_ledger_write } from './lane-ledger-write'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// The followup's critical path (joshuafolkken/kit#5295): over the period's `ci-wait` rows, which check
+// settled last — how often, and the median and maximum of when it settled into the wait — printed by
+// `josh lane:stats`. A row from before the field, or a wait no check was seen to settle in, names none
+// and is left out.
+
+const COLUMNS = ['followup critical path', 'runs', 'median (s)', 'max (s)'] as const
+
+interface LastCheck {
+	name: string
+	elapsed_ms: number
+}
+
+function settled({ last_check, check_ms }: StageEntry): LastCheck | undefined {
+	if (last_check === undefined) return undefined
+
+	const elapsed_ms = check_ms?.[last_check]
+
+	return elapsed_ms === undefined ? undefined : { name: last_check, elapsed_ms }
+}
+
+function last_check_of(entry: LedgerEntry): LastCheck | undefined {
+	if (entry.kind !== lane_ledger.KIND.STAGE || entry.stage !== lane_ledger_write.CI_WAIT_STAGE) {
+		return undefined
+	}
+
+	return settled(entry)
+}
+
+function name_row(name: string, lasts: ReadonlyArray<LastCheck>): string {
+	const elapsed = lasts.filter((last) => last.name === name).map((last) => last.elapsed_ms)
+
+	return lane_stats.to_row([
+		name,
+		String(elapsed.length),
+		lane_check_stats.cell(lane_stats.median(elapsed)),
+		lane_check_stats.cell(lane_stats.peak(elapsed)),
+	])
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const lasts = lane_stats
+		.in_window(entries, window)
+		.map((entry) => last_check_of(entry))
+		.filter((last) => last !== undefined)
+	const names = [...new Set(lasts.map((last) => last.name))]
+
+	return [...lane_check_stats.header(COLUMNS), ...names.map((name) => name_row(name, lasts))].join(
+		'\n',
+	)
+}
+
+// `issue`'s followup line detail for `lane:breakdown`: the last check its latest `ci-wait` row names,
+// `''` where none does.
+function last_check_text(entries: ReadonlyArray<LedgerEntry>, issue: number): string {
+	const last = entries
+		.filter((entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue)
+		.map((entry) => last_check_of(entry))
+		.findLast((found) => found !== undefined)
+
+	return last === undefined
+		? ''
+		: ` (last check: ${last.name} ${lane_check_stats.cell(last.elapsed_ms)}s)`
+}
+
+const lane_ci_path_stats = { last_check_text, table }
+
+export { lane_ci_path_stats }

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

@@ -0,0 +1,84 @@
+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'
+import { lane_tail_stats } from './lane-tail-stats'
+
+// What each gate check claimed from the core budget against what it used (joshuafolkken/kit#5138): one
+// period's per-check rows reduced to one row per check — the median cores requested, then the cores it
+// kept busy (`cpu_ms ÷ elapsed_ms`) as a median, a 90th percentile and a maximum, and the seconds its
+// claims waited. The weights in `scripts/gate/core-weights.ts` are changed from this table, never by it.
+//
+// **Only a measured run is counted**: a reused check started no process, and a check with no `cpu_ms`
+// was recorded before the field existed, so neither says how many cores the check used.
+
+const DECIMALS = 1
+const COLUMNS = [
+	'check',
+	'claim',
+	'runs',
+	'cores median',
+	'cores p90',
+	'cores max',
+	'wait (s)',
+] as const
+const { NOT_MEASURED } = lane_stage_stats
+
+interface MeasuredCheck {
+	label: string
+	elapsed_ms: number
+	cpu_ms: number
+	claim?: GateCheckRecord['claim']
+}
+
+function is_gate(entry: LedgerEntry): entry is GateEntry {
+	return entry.kind === lane_ledger.KIND.GATE
+}
+
+function is_measured(check: GateCheckRecord): check is GateCheckRecord & MeasuredCheck {
+	return check.is_reused !== true && check.cpu_ms !== undefined && check.elapsed_ms > 0
+}
+
+function number_cell(value: number | undefined): string {
+	return value === undefined ? NOT_MEASURED : value.toFixed(DECIMALS)
+}
+
+function seconds_cell(milliseconds: number | undefined): string {
+	return number_cell(milliseconds === undefined ? undefined : milliseconds / MS_PER_SECOND)
+}
+
+function total(values: ReadonlyArray<number>): number {
+	return values.reduce((sum, value) => sum + value, 0)
+}
+
+function check_row(label: string, checks: ReadonlyArray<MeasuredCheck>): string {
+	const runs = checks.filter((check) => check.label === label)
+	const cores = runs.map((check) => check.cpu_ms / check.elapsed_ms)
+	const claims = runs.map((check) => check.claim).filter((claim) => claim !== undefined)
+	const requested = claims.map((claim) => claim.requested)
+	const waited_ms = claims.length === 0 ? undefined : total(claims.map((claim) => claim.waited_ms))
+
+	return lane_stats.to_row([
+		label,
+		number_cell(lane_stats.median(requested)),
+		String(runs.length),
+		number_cell(lane_stats.median(cores)),
+		number_cell(lane_tail_stats.tail_minutes(cores)),
+		number_cell(lane_stats.peak(cores)),
+		seconds_cell(waited_ms),
+	])
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const gates = lane_stats.in_window(entries, window).filter(is_gate)
+	const checks = gates.flatMap((gate) => gate.checks ?? []).filter(is_measured)
+	const labels = [...new Set(checks.map((check) => check.label))]
+	const header = [lane_stats.to_row(COLUMNS), lane_stats.to_row(COLUMNS.map(() => '---'))]
+
+	return [...header, ...labels.map((label) => check_row(label, checks))].join('\n')
+}
+
+const lane_claim_stats = { table }
+
+export { lane_claim_stats }

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

@@ -3,9 +3,13 @@ import { git_command } from '#scripts/git/git-command'
 import { git_worktree } from '#scripts/git/git-worktree'
 import { error_text } from '#scripts/lib/error-message'
 import { lane_paths } from './lane-paths'
+import { lane_plan } from './lane-plan'
 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 +17,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 +41,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 +120,76 @@ 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]
+}
+
+// An ended lane's cleared plan goes with it; a plan its lane yielded on stays (`lane_plan.release`).
+async function record_end(issue: string): Promise<void> {
+	await lane_state.record_change({ issue, state: 'ended', command: 'lane:close' })
+	lane_plan.release(Number(issue), process.cwd())
+}
+
 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 record_end(issue)
 
-	return { issue, kind: close_kind(did_exist, left_behind), left_behind, reaped }
+	return { issue, kind, left_behind, reaped, residents }
+}
+
+type DuePredicate = (issue: string) => Promise<boolean>
+
+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 +208,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 +251,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 }