@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/scripts/josh/stamp-file.ts

@@ -1,12 +1,13 @@
-import { createHash, randomUUID } from 'node:crypto'
-import { lstatSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { lstatSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { PACKAGE_DIR } from '#scripts/init/init-paths'
-import { PLATFORM_TEMP_ROOT } from './platform-temporary'
+import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
+import { atomic_write } from '#scripts/lib/atomic-write'
 
 // A small record one josh command writes and another reads, kept per checkout in the temp directory.
 //
-// Extracted from `scripts/eval/eval-stamp.ts` when `josh latest:scope` needed the same handoff.
+// Extracted from `tools/eval/eval-stamp.ts` when `josh latest:scope` needed the same handoff.
 // The mechanics below are not boilerplate — the symlink defense on the
 // write, the ownership check on the read, and the deterministic per-checkout path are each load
 // bearing — so a second copy of them is the clone `CLAUDE.md` prohibits. What differs between the
@@ -121,8 +122,8 @@ function is_foreign_file(target: string): boolean {
 }
 
 // Mutable coordination state cannot disappear between an unlink and its replacement: a reader that
-// mistakes that gap for "no child" can start the same generation twice. The temporary file lives
-// beside the target, uses the same exclusive/symlink-safe create, and rename publishes it atomically.
+// mistakes that gap for "no child" can start the same generation twice. `atomic-write.ts` stages the
+// text beside the target with the same exclusive create and renames it over the target.
 // `rename` replaces the path itself rather than following a symlink planted there, so the write still
 // never lands somewhere else; a regular file another account owns is refused before it is replaced,
 // the same answer the unlink gives on a sticky temp directory.
@@ -131,16 +132,9 @@ function replace_text_stamp(target: string, text: string): string {
 		throw new Error(`refusing to replace another account's file: ${target}`)
 	}
 
-	const temporary = `${target}.${String(process.pid)}.${randomUUID()}`
+	atomic_write.replace_file(target, text, { mode: STAMP_FILE_MODE })
 
-	try {
-		writeFileSync(temporary, text, { flag: STAMP_CREATE_FLAG, mode: STAMP_FILE_MODE })
-		renameSync(temporary, target)
-
-		return target
-	} finally {
-		rmSync(temporary, { force: true })
-	}
+	return target
 }
 
 function replace_stamp(target: string, payload: unknown): string {

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
@@ -73,14 +58,26 @@ function seated_limit(limit: number): number {
 // Never negative: a repository holding more `in-progress` issues than the limit allows — the limit
 // was lowered, or a stale label outlived its run — has no free lane, and a negative count read as
 // "how many to offer" would be a slice nobody meant.
-function free_lanes(limit: number, occupied: 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_seats = lane_seed_policy.LAST_LANE_SEAT - seated
+
+	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

@@ -0,0 +1,97 @@
+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: 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`. **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 DECIMALS = 1
+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
+}
+
+function cell(milliseconds: number | undefined): string {
+	return milliseconds === undefined
+		? lane_stage_stats.NOT_MEASURED
+		: (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 && check.is_unmoved !== true)
+	const elapsed = timed.map((check) => check.elapsed_ms)
+
+	return lane_stats.to_row([
+		label,
+		cell(lane_stats.median(elapsed)),
+		cell(lane_stats.peak(elapsed)),
+		String(runs.length),
+		count(runs, (check) => check.is_reused === true),
+		count(runs, (check) => check.is_unmoved === true),
+		count(runs, (check) => check.fallback !== undefined),
+	])
+}
+
+// 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 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 [
+		[...header(COLUMNS), ...labels.map((label) => check_row(label, rows))].join('\n'),
+		fallback_table(checks),
+	].join('\n\n')
+}
+
+const lane_check_stats = { WHOLE_GATE_LABEL, table }
+
+export { lane_check_stats }

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

@@ -1,13 +1,17 @@
+import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { run_ship_next, type ShipResume } from '#scripts/run/ship/run-ship-next'
 import type { Stage } from '#scripts/run/ship/run-ship-stage'
+import { run_ship_stop_context, type StopContext } from '#scripts/run/ship/run-ship-stop-context'
 
 interface ShipStop extends ShipResume {
 	stage: Stage
+	context?: StopContext
 }
 
 const CHILD_INVOCATION = 'fullrun'
+const LINE_BREAK = '\n'
 // What a brokered reviewer's prompt ends with, so the one pattern below finds it too.
 const REVIEW_INVOCATION = 'the reviewer of lane'
 const RESUME_GUIDE = '.claude/skills/workflow-commands/pre-gate-cut.md'
@@ -43,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)
 
@@ -79,14 +90,41 @@ function outage_resume_invocation(issue: string): string {
 // **A known stage puts the next command in the prompt**, so the relaunched
 // session runs it rather than re-deriving it from `chain-rule.md`. An OpenAI lane's supervisor sees only
 // that the ship failed, not where, so without a stage the prompt points at `run:step` as before.
+//
+// **A stop that carries its context puts it in the prompt too** — the failed output's
+// 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).
+function known_stop_lines(
+	issue: string,
+	stop: ShipStop,
+	frame: ReadonlyArray<string>,
+): ReadonlyArray<string> {
+	const { context } = stop
+	const is_excerpted = run_ship_stop_context.has_excerpt(context)
+	const next = run_ship_next.next_step(issue, stop.stage, stop, is_excerpted)
+
+	if (context === undefined) return [next]
+
+	const fixed = [...frame, next].join(LINE_BREAK).length + LINE_BREAK.length
+	const budget = agent_role_profile.MAX_VALUE_LENGTH - fixed
+
+	return [next, run_ship_stop_context.describe(issue, context, budget)]
+}
+
 function ship_stop_invocation(issue: string, stop?: ShipStop): string {
 	const opening = `Resuming the lane child for issue ${issue_cite.plain(issue)} after its detached ship supervisor stopped at a failed stage — do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`
-	const next =
+	const closing = `Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`
+	const middle =
 		stop === undefined
-			? `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
-			: run_ship_next.next_step(issue, stop.stage, stop)
+			? [
+					`Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`,
+				]
+			: known_stop_lines(issue, stop, [opening, closing])
 
-	return `${opening} ${next} Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`
+	return [opening, ...middle, closing].join(LINE_BREAK)
 }
 
 const lane_child_invocation = {
@@ -95,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] : [])
 	}