@joshuafolkken/kit 1.1229.0 → 1.1370.0

package/scripts/lane/lane-await.ts

@@ -1,15 +1,21 @@
 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 { run_liveness } from '#scripts/run/run-liveness'
+import {
+	PROCESS_ALIVE,
+	PROCESS_NONE,
+	PROCESS_UNKNOWN,
+	run_liveness,
+	type ProcessTrace,
+} from '#scripts/run/run-liveness'
 import { lane_child_invocation } from './lane-child-invocation'
 import { lane_handoff } from './lane-handoff'
 
 // Detached lane children are not harness-tracked processes, so their completion fires no
 // re-invocation event in the parent's session. Without a blocking wait the parent notices only
-// on the next heartbeat interval -- up to 15 minutes after the fact in the measured case
-// (joshuafolkken/kit#2113).
+// on the next heartbeat interval -- up to 15 minutes after the fact.
 //
 // **The re-confirm delay is the one value the caller must not be left to choose.** A process that
 // disappears briefly and reappears (the pre-gate boundary cut, where one process exits and a
@@ -22,12 +28,12 @@ const RECONFIRM_MS = 15_000
 const DEFAULT_POLL_MS = 5000
 const NEVER_APPEARED_TIMEOUT_MS = 600_000
 const MS_PER_SECOND = 1000
-const ISSUE_PATTERN = /^[1-9]\d*$/u
 const PROCESS_FOUND = 0
+const PROCESS_NOT_FOUND = 1
 
 // `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 (joshuafolkken/kit#3133).
+// launched.
 interface AwaitState {
 	appeared: boolean
 	disappeared_at: number | undefined
@@ -52,6 +58,8 @@ interface AwaitOptions {
 	poll_ms?: number
 	reconfirm_ms?: number
 	never_appeared_timeout_ms?: number
+	now?: () => number
+	sleep?: (ms: number) => Promise<void>
 }
 
 interface CheckConfig {
@@ -63,18 +71,28 @@ interface CheckConfig {
 interface RunConfig extends CheckConfig {
 	is_settled: (issue: string) => Promise<boolean>
 	poll_ms: number
+	now: () => number
+	sleep: (ms: number) => Promise<void>
 }
 
-function is_process_running_default(issue: string): boolean {
+// Three answers, not two: only pgrep's own "no match" exit is `none`. A pgrep that failed or hit its
+// timeout never looked, and `run:liveness` answers `undetermined` for it rather than booking a live
+// child as stopped.
+function process_trace_default(issue: string): ProcessTrace {
 	const pattern = lane_child_invocation.process_pattern(issue)
 	const result = spawnSync('pgrep', ['-f', pattern], {
 		encoding: 'utf8',
 		timeout: PROBE_TIMEOUT_MS,
 	})
 
-	if (result.status === PROCESS_FOUND) return true
+	if (result.status === PROCESS_FOUND) return PROCESS_ALIVE
+	if (lane_handoff.is_ship_running(issue, process.cwd())) return PROCESS_ALIVE
+
+	return result.status === PROCESS_NOT_FOUND ? PROCESS_NONE : PROCESS_UNKNOWN
+}
 
-	return lane_handoff.is_ship_running(issue, process.cwd())
+function is_process_running_default(issue: string): boolean {
+	return process_trace_default(issue) === PROCESS_ALIVE
 }
 
 // The same positive evidence `run:liveness` answers `settled` on: the issue closed, or it was parked.
@@ -101,7 +119,10 @@ function is_valid(raw: RawAwaitArguments): boolean {
 	const { owner } = raw.values
 	const numbers = owner === undefined ? raw.positionals : [...raw.positionals, owner]
 
-	return raw.positionals.length > 0 && numbers.every((value) => ISSUE_PATTERN.test(value))
+	return (
+		raw.positionals.length > 0 &&
+		numbers.every((value) => issue_number_shape.is_issue_number(value))
+	)
 }
 
 // The issues to wait on and the waiting session's pid, or `undefined` for anything else.
@@ -142,6 +163,8 @@ function resolve_options(options: AwaitOptions): RunConfig {
 	return {
 		is_running: options.is_running ?? is_process_running_default,
 		is_settled: options.is_settled ?? is_settled_default,
+		now: options.now ?? Date.now,
+		sleep: options.sleep ?? sleep,
 		...resolve_timing(options),
 	}
 }
@@ -225,12 +248,12 @@ async function wait_for_any(
 	const states = await make_states(issues, config.is_settled)
 
 	for (;;) {
-		const completed = check_any(states, Date.now(), config)
+		const completed = check_any(states, config.now(), config)
 
 		if (completed !== undefined) return completed
 
 		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		await sleep(config.poll_ms)
+		await config.sleep(config.poll_ms)
 	}
 }
 
@@ -240,6 +263,7 @@ const lane_await = {
 	check_issue,
 	is_process_running_default,
 	parse_arguments,
+	process_trace_default,
 	wait_for_any,
 }
 

package/scripts/lane/lane-cache.ts

@@ -8,15 +8,15 @@ import {
 	type GateCacheSpec,
 } from '#scripts/josh/josh-command-types'
 
-// Warming a fresh lane's verification caches from the main checkout (joshuafolkken/kit#1849).
+// Warming a fresh lane's verification caches from the main checkout.
 //
 // `git worktree add` writes a checkout and nothing beside it, and the three caches the gate reads —
 // `.eslintcache`, `.tsbuildinfo`, `.cspellcache` — are all git-ignored, so a new lane has none of
-// them and only its *first* `josh gate` runs fully cold (measured at 353.9 s against 27.5 s warm,
-// joshuafolkken/kit#1839). The initial seed warms that run; the per-tool sync below keeps the
-// portable ESLint and CSpell caches current afterwards (#2060).
+// them and only its *first* `josh gate` runs fully cold (several minutes against well under a minute
+// warm). The initial seed warms that run; the per-tool sync below keeps the portable ESLint and
+// CSpell caches current afterwards.
 //
-// Content hashes make stale entries safe, but do not by themselves make a cache portable (#2060).
+// Content hashes make stale entries safe, but do not by themselves make a cache portable.
 // ESLint keys entries by absolute file path, so its JSON is rebased while cspell's relative keys and
 // TypeScript's build info move raw. The spec in `josh-command-types.ts` is the one declaration of
 // which treatment and which continuous sharing each gate cache receives.
@@ -103,7 +103,7 @@ function seed_caches(source_root: string, destination: string): void {
 /**
  * Copy the pre-built hook bundles (`dist/hooks/`) from `source_root` into `destination`, so a fresh
  * lane's child runs each Claude Code hook off `node dist/hooks/<name>.js` rather than the slower
- * `pnpm josh …` fallback (joshuafolkken/kit#2160). The bundles are git-ignored, so a lane's work tree
+ * `pnpm josh …` fallback. The bundles are git-ignored, so a lane's work tree
  * never carries them and every hook falls back without this seed.
  *
  * Best-effort, exactly like `seed_caches`: a source with no bundles (a checkout that never ran

package/scripts/lane/lane-capacity.ts

@@ -1,14 +1,14 @@
+import { lane_limit_override } from './lane-limit-override'
 import type { LaneEnvironment } from './lane-paths'
 import { lane_seed_policy } from './lane-seed'
 
-// How many lanes one repository may run at once, and how many of them are free
-// (joshuafolkken/kit#1491).
+// How many lanes one repository may run at once, and how many of them are free.
 //
 // **Nothing here knows what a lane holds.** The limit is a number, the occupancy is a number, and
 // the answer is a number — so the same pool serves an epic's children, several epics' children at
 // once, or anything else a scheduler decides to put in a lane. Threading an epic through this module
-// is what would have to be undone the first time two epics run together, and the whole reason
-// joshuafolkken/kit#1491 built the scheduler epic-free from the start.
+// is what would have to be undone the first time two epics run together, which is why the scheduler
+// is epic-free.
 //
 // **It is a ceiling, not a prediction.** Six lanes does not say six children will run at once; it
 // says a seventh will not start. What actually runs is bounded by what is runnable, by the port
@@ -33,40 +33,55 @@ type LimitChoice = { kind: 'limit'; limit: number } | { kind: 'problem'; problem
 //
 // 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.
-function read_limit(raw: string | undefined): LimitChoice {
+//
+// `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: `${LANE_LIMIT_KEY} must be a positive integer, not "${trimmed}"`,
-		}
+		return { kind: 'problem', problem: `${name} must be a positive integer, not "${trimmed}"` }
 	}
 
 	return { kind: 'limit', limit: Number(trimmed) }
 }
 
-function lane_limit(environment: LaneEnvironment = process.env): LimitChoice {
-	return read_limit(environment[LANE_LIMIT_KEY])
+// **A live run's `lane:limit` override outranks the environment**: a running
+// parent keeps the environment it started with, so the override is the only way its limit moves. This
+// stays the one place the limit is read; the override reader is injected so a test reads none.
+async function lane_limit(
+	environment: LaneEnvironment = process.env,
+	read_override: () => Promise<number | undefined> = lane_limit_override.read_override,
+): Promise<LimitChoice> {
+	const override = await read_override()
+
+	if (override !== undefined) return { kind: 'limit', limit: override }
+
+	return read_limit(environment[LANE_LIMIT_KEY], LANE_LIMIT_KEY)
+}
+
+// **A limit above the seat count is capped at the seats**. `lane:open` refuses
+// a tenth lane however high the limit is set, so a limit past the seats offers launches bound to be
+// refused.
+function seated_limit(limit: number): number {
+	return Math.min(limit, lane_seed_policy.LAST_LANE_SEAT)
 }
 
 // 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.
-//
-// **A limit above the seat count is capped at the seats** (joshuafolkken/kit#3027). `lane:open` refuses
-// a tenth lane however high `JOSH_LANE_LIMIT` is set, so counting free lanes past the seats offers a
-// launch that is bound to be refused.
 function free_lanes(limit: number, occupied: number): number {
-	return Math.max(NO_LANES, Math.min(limit, lane_seed_policy.LAST_LANE_SEAT) - occupied)
+	return Math.max(NO_LANES, seated_limit(limit) - occupied)
 }
 
 const lane_capacity = {
 	LANE_LIMIT_KEY,
-	lane_limit,
 	free_lanes,
+	lane_limit,
+	read_limit,
+	seated_limit,
 }
 
+export type { LimitChoice }
 export { lane_capacity }

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

@@ -1,4 +1,5 @@
-import { run_issue_number } from '#scripts/run/run-issue-number'
+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'
 
@@ -8,7 +9,7 @@ interface ShipStop extends ShipResume {
 
 const CHILD_INVOCATION = 'fullrun'
 const RESUME_GUIDE = '.claude/skills/workflow-commands/pre-gate-cut.md'
-// What a detached `josh ship --detach` supervisor's command line carries (joshuafolkken/kit#2428). It ends
+// What a detached `josh ship --detach` supervisor's command line carries. It ends
 // with the `"<title> #<N>"` title on purpose, so the liveness pattern below finds it by the same trailing
 // anchor it finds a child by. **The script path alone is not enough**: where the dispatcher is TypeScript
 // (kit itself) `josh ship` runs in-process, so no process ever carries `run-ship-cli.ts` — the `pnpm josh
@@ -16,57 +17,58 @@ const RESUME_GUIDE = '.claude/skills/workflow-commands/pre-gate-cut.md'
 const SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`
 
 function child_invocation(issue: string): string {
-	run_issue_number.require_issue_number(issue)
+	issue_number_shape.require_issue_number(issue)
 
-	return `${CHILD_INVOCATION} #${issue}`
+	return `${CHILD_INVOCATION} ${issue_cite.plain(issue)}`
 }
 
 // The `pgrep -f` pattern that finds a running child: the invocation is always the last argument of
 // its command line — the resume prompts below end with it on purpose — so the anchor matches every
-// launch of `#<N>` and never `#<N>0` (joshuafolkken/kit#2421).
+// launch of `#<N>` and never `#<N>0`.
 //
-// **A detached ship supervisor counts as the child** (joshuafolkken/kit#2428). The agent ends once it has
+// **A detached ship supervisor counts as the child**. The agent ends once it has
 // handed the post-implementation region to `josh ship --detach`, and the parent books a lane whose
 // pattern stopped matching as finished — parking an issue that was still shipping. The supervisor's
 // command line ends with its `#<N>` title, so the one extended pattern covers both, and the wait, the
 // liveness read and the reaper keep searching with a single pattern.
 function process_pattern(issue: string): string {
-	run_issue_number.require_issue_number(issue)
+	issue_number_shape.require_issue_number(issue)
 
-	return `(${CHILD_INVOCATION}|${SHIP_PROCESS} .*) #${issue}$`
+	return `(${CHILD_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`
 }
 
 function resume_invocation(issue: string): string {
-	const preamble = `Resuming the lane child for issue #${issue} — do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`
+	const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} — do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`
 
 	return `${preamble} ${child_invocation(issue)}`
 }
 
-// The prompt an `outage` re-dispatch gives a resumed child (joshuafolkken/kit#2317). Its session was
+// The prompt an `outage` re-dispatch gives a resumed child. Its session was
 // relaunched with `--resume`, so its full context is already loaded — the preamble tells it not to
 // re-read the entry documents and to find where it stopped with `run:step`, redoing only the last
 // action if it did not complete.
 //
 // **It ends with `child_invocation` on purpose, not as decoration** — for the same reason
-// `resume_invocation` does: the parent's liveness poll is `pgrep -laf "<invocation>$"`, so the trailing
+// `resume_invocation` does: the parent's liveness read (`run:liveness`, `lane:await`) matches
+// `process_pattern` against the command line, so the trailing
 // `fullrun #<N>` keeps the relaunched process matching, and it is the ordinary run the child carries on.
 function outage_resume_invocation(issue: string): string {
-	const preamble = `Resuming the lane child for issue #${issue} after an API disconnection — your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`
+	const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} after an API disconnection — your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`
 
 	return `${preamble} ${child_invocation(issue)}`
 }
 
 // The prompt a lane child is relaunched with when its detached ship supervisor stopped at a failed
-// stage (joshuafolkken/kit#2428) — a red gate, a High/Medium review, a failed push or red CI. The agent
+// stage — a red gate, a High/Medium review, a failed push or red CI. The agent
 // ended at the hand-off, so this is how control comes back to one: it reads the stopped report, fixes it
 // and hands the region back. It ends with `child_invocation` for the reason `resume_invocation` does —
 // the parent's poll keeps matching the relaunched process.
 //
-// **A known stage puts the next command in the prompt** (joshuafolkken/kit#2964), so the relaunched
+// **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.
 function ship_stop_invocation(issue: string, stop?: ShipStop): string {
-	const opening = `Resuming the lane child for issue #${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 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 =
 		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.`

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

@@ -1,15 +1,15 @@
-import { run_issue_number } from '#scripts/run/run-issue-number'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 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
-// environment rather than from the model's reading of the prompt (joshuafolkken/kit#1904).
+// environment rather than from the model's reading of the prompt.
 //
-// **A dispatched child used to be indistinguishable from a person's own session.** `lane:dispatch`
-// and the `run:cut` relaunch both start the child with `claude -p "fullrun #<N>"` and a copied
-// environment, and nothing in the argv, the environment or a file said "this session was launched, not
-// typed". So `pre-gate-cut.ts` left the human-or-child question to the model, which read its own prompt
-// and — across the six children joshuafolkken/kit#1850 measured — decided "person" every time and
-// declined the cut. This variable is that missing fact, made mechanical.
+// **Without this mark a dispatched child is indistinguishable from a person's own session.**
+// `lane:dispatch` and the `run:cut` relaunch both start the child with `claude -p "fullrun #<N>"` and
+// a copied environment, and nothing in the argv, the environment or a file says "this session was
+// launched, not typed". Left to the model, the human-or-child question is answered by reading its own
+// prompt, which decides "person" and declines the cut. This variable is that missing fact, made
+// mechanical.
 //
 // **Its value is the issue number, because a mark that only said "a child" could not be told from one
 // that leaked.** A person's shell, or a parent session that was itself a dispatched child, can carry
@@ -19,7 +19,7 @@ import { lane_paths } from './lane-paths'
 // `.claude/skills/workflow-commands/pre-gate-cut.md`.
 const KEY = 'JOSH_LANE_CHILD'
 
-// **A dispatched child also asks for the five-minute prompt-cache TTL** (joshuafolkken/kit#2944). A
+// **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
 // the input rate against 1.25x for five minutes. A replay of 1,953 lane transcripts (about 57,000
 // requests) found 0.3% of request gaps over five minutes, so the shorter TTL — re-writing the prefix on
@@ -34,7 +34,7 @@ type MarkerSource = Readonly<Record<string, string | undefined>>
 // issue number rather than from text read anywhere — the same discipline `lane-dispatch.ts` applies to
 // the invocation it builds — so a malformed number fails here rather than reaching a child.
 function environment_for(issue: string): Record<string, string> {
-	run_issue_number.require_issue_number(issue)
+	issue_number_shape.require_issue_number(issue)
 
 	return { [KEY]: issue, [CACHE_TTL_KEY]: CACHE_TTL }
 }
@@ -47,14 +47,14 @@ function marked_issue(source: MarkerSource = process.env): string | undefined {
 
 	if (value === undefined) return undefined
 
-	return run_issue_number.ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
+	return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : 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
 // read as a person's run — the trust condition the header describes, applied the same way
-// `pre-gate-cut.ts` applies it to the resume decision (joshuafolkken/kit#1947).
+// `pre-gate-cut.ts` applies it to the resume decision.
 function is_child_of(directory: string, source: MarkerSource = process.env): boolean {
 	const marked = marked_issue(source)
 

package/scripts/lane/lane-cli.ts

@@ -4,6 +4,8 @@ import { epic_busy } from '#scripts/epic/epic-busy'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import type { OpenIssueData } from '#scripts/git/git-schemas'
 import { issue_cite, type IssueCiter } from '#scripts/issue/issue-cite'
+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_carry } from '#scripts/run/carry/run-carry'
 import { run_carry_reclaim } from '#scripts/run/carry/run-carry-reclaim'
@@ -16,9 +18,9 @@ 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_seed_policy } from './lane-seed'
+import { lane_stray } from './lane-stray'
 
-// `josh lane:open` / `lane:close` / `lane:list` / `lane:prune` — the lane's whole lifecycle
-// (joshuafolkken/kit#1490).
+// `josh lane:open` / `lane:close` / `lane:list` / `lane:prune` — the lane's whole lifecycle.
 //
 // **`lane:open` prints the lane's directory on standard output and nothing else**, so
 // `dir=$(pnpm josh lane:open 1490)` is what a caller needs and a refusal is an empty capture beside
@@ -32,7 +34,6 @@ const SINGLE_ARGUMENT = 1
 const ISSUE_AND_PATH_ARGUMENTS = 2
 const ALL_FLAG = '--all'
 const NONE_TOKEN = 'none'
-const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
 
 const USAGE = [
 	'Usage: josh lane:open <issue-number>',
@@ -53,8 +54,7 @@ function report_usage(): number {
 }
 
 // Read the carry record and refuse if this session has already handed off its budget via `--cut`.
-// A cut session must not open new lanes or dispatch new children — the successor owns the budget
-// (joshuafolkken/kit#2114).
+// A cut session must not open new lanes or dispatch new children — the successor owns the budget.
 async function guard_cut_session(): Promise<string | undefined> {
 	const directory = await run_carry.repository_directory()
 
@@ -72,7 +72,7 @@ async function guard_cut_session(): Promise<string | undefined> {
 function parse_lane_issue(value: string | undefined): string | undefined {
 	if (value === undefined) return undefined
 
-	return ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
+	return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
 }
 
 function parse_issue(rest: ReadonlyArray<string>): string | undefined {
@@ -88,7 +88,7 @@ function refusal_message(outcome: Exclude<OpenOutcome, { kind: 'opened' }>): str
 		return `All ${String(lane_seed_policy.LAST_LANE_SEAT)} lane seats are taken. Run \`pnpm josh lane:list\` to see them and \`pnpm josh lane:close <issue-number>\` to free one.`
 	}
 
-	return `A lane for #${outcome.lane.issue} is already open at ${outcome.lane.directory}. Run \`pnpm josh lane:close ${outcome.lane.issue}\` before opening it again.`
+	return `A lane for ${session_cite.issue(outcome.lane.issue)} is already open at ${outcome.lane.directory}. Run \`pnpm josh lane:close ${outcome.lane.issue}\` before opening it again.`
 }
 
 function report_open(outcome: OpenOutcome): number {
@@ -118,7 +118,7 @@ function report_issues(issues: ReadonlyArray<string>): number {
 function report_close(outcome: CloseOutcome): number {
 	if (outcome.reaped.length > 0) {
 		console.error(
-			`Terminated the lane child for #${outcome.issue} that had not ended by itself: process ${outcome.reaped.join(', ')}.`,
+			`Terminated the lane child for ${session_cite.issue(outcome.issue)} that had not ended by itself: process ${outcome.reaped.join(', ')}.`,
 		)
 	}
 
@@ -127,7 +127,7 @@ function report_close(outcome: CloseOutcome): number {
 	}
 
 	console.error(
-		`Closing the lane for #${outcome.issue} left this behind: ${outcome.left_behind.join(', ')}. Remove it and run \`pnpm josh lane:close ${outcome.issue}\` again.`,
+		`Closing the lane for ${session_cite.issue(outcome.issue)} left this behind: ${outcome.left_behind.join(', ')}. Remove it and run \`pnpm josh lane:close ${outcome.issue}\` again.`,
 	)
 
 	return FAILURE_EXIT_CODE
@@ -140,7 +140,7 @@ function report_sweep(outcome: SweepOutcome): number {
 
 	if (outcome.failed.length === 0) return code
 
-	const named = outcome.failed.map((issue) => `#${issue}`).join(', ')
+	const named = outcome.failed.map((issue) => session_cite.issue(issue)).join(', ')
 
 	// `lane:list` reads git's work trees, and the usual survivor is a branch whose work tree is
 	// already gone — which that listing cannot show. Closing each one again is what names it.
@@ -193,7 +193,7 @@ const OCCUPANCY_UNREADABLE =
 	'Could not read the `in-progress` listing, so the lane/label difference was not checked — that is not "everything agrees"; check `gh auth status`.'
 
 // The `in-progress` issues this repository shows running, read the way `epic:next` reads lane
-// occupancy — never rebuilt (joshuafolkken/kit#2235). A read that could not see the whole listing is
+// occupancy — never rebuilt. A read that could not see the whole listing is
 // `undefined`, so the difference is skipped rather than computed against a set known to be partial.
 async function to_holders(repo: string): Promise<ReadonlyArray<OpenIssueData> | undefined> {
 	const read = await epic_busy.read_repository(repo)
@@ -203,7 +203,7 @@ async function to_holders(repo: string): Promise<ReadonlyArray<OpenIssueData> |
 }
 
 // The repository and its running issues, read once: the listing cites each lane from the titles here
-// (joshuafolkken/kit#2943) and the occupancy check compares against the same set.
+// and the occupancy check compares against the same set.
 interface InProgress {
 	repo: string | undefined
 	holders: ReadonlyArray<OpenIssueData> | undefined
@@ -268,7 +268,14 @@ async function list_command(rest: ReadonlyArray<string>): Promise<number> {
 async function prune_command(rest: ReadonlyArray<string>): Promise<number> {
 	if (rest.length > 0) return report_usage()
 
-	return report_sweep(await lane_close.prune_lanes())
+	const code = report_sweep(await lane_close.prune_lanes())
+
+	// After the closes, so a lane whose close left its directory behind is swept in the same run. A
+	// kept stray is reported, never a failure: it waits on a person, and a non-zero exit would stop
+	// every `backlogrun` preparation until one came.
+	await lane_stray.sweep_and_report()
+
+	return code
 }
 
 // The recorded path goes to standard output on both arms, so

package/scripts/lane/lane-close.ts

@@ -6,7 +6,7 @@ import { lane_paths } from './lane-paths'
 import { lane_reap } from './lane-reap'
 import { lane_registry, type LaneInfo } from './lane-registry'
 
-// Closing a lane: no work tree, no branch, no directory (joshuafolkken/kit#1490).
+// Closing a lane: no work tree, no branch, no directory.
 //
 // **A lane is closed after a park, a failure or an interruption as readily as after a success**, so
 // every step here is written to run over a subject that is already gone or that still holds
@@ -21,7 +21,7 @@ interface LaneTargets {
 
 // The lane an issue number names: its registration, when there is one, and the paths a close acts on.
 // Resolved once here so a caller that has to look inside the tree before closing it reads the same
-// directory the close removes (joshuafolkken/kit#2476).
+// directory the close removes.
 interface ResolvedLane {
 	existing: LaneInfo | undefined
 	targets: LaneTargets
@@ -107,8 +107,8 @@ function close_kind(did_exist: boolean, left_behind: ReadonlyArray<string>): Clo
 }
 
 // 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
-// (joshuafolkken/kit#1497). Derived here from the current work tree, a close run inside a lane
+// 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())
@@ -130,8 +130,8 @@ 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 the half-discarded state
-	// joshuafolkken/kit#2421 found — the work tree gone, the child still answering `alive`.
+	// 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)
 
 	await remove_lane(targets)