@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/scripts/backlog/backlog-arrival.ts

@@ -7,11 +7,12 @@ import { backlog_arrival_added } from './backlog-arrival-added'
 import { backlog_next } from './backlog-next'
 import { backlog_ready, type ReadyPorts, type ReadyReading } from './backlog-ready'
 import { backlog_stalled } from './backlog-stalled'
+import { backlog_stalled_detect } from './backlog-stalled-detect'
 
 // The arrival probe a `backlogrun` parent's `--wait` watcher runs while children are in flight.
 // Without it, an issue opted in with `auto-ok` mid-run is picked up only when the parent
 // next wakes — a child's merge, or the progress interval — so in practice the ten-minute stall detector
-// becomes the pick-up, and the person gets a ⏳ notification for the wait.
+// becomes the pick-up, ten minutes late.
 //
 // **The watcher's exit is the only thing that wakes a live parent**, so the probe rides it: once a
 // minute it reads the backlog the pick-up line reads (`backlog_ready.read_ready`, cheap first — a full
@@ -66,15 +67,18 @@ async function bounded_ready_issues(): Promise<ReadonlyArray<string>> {
 	return answered_issues(await backlog_ready.read_backlog_next(COMMAND_TIMEOUT_MS))
 }
 
-// The backlog reads, plus whether `run:add` handed the run an issue since a given instant.
+// The backlog reads, whether `run:add` handed the run an issue since a given instant, and the stall
+// detector's record of whether work and a free lane coexist (joshuafolkken/kit#4349).
 interface ArrivalPorts extends ReadyPorts {
 	is_added_since: (since_ms: number) => Promise<boolean>
+	observe_offerable: (is_offerable: boolean) => Promise<void>
 }
 
 const ARRIVAL_PORTS: ArrivalPorts = {
 	free_lane_count: backlog_ready.free_lane_count,
 	ready_issues: bounded_ready_issues,
 	is_added_since: backlog_arrival_added.is_added_since,
+	observe_offerable: backlog_stalled_detect.observe_offerable,
 }
 
 interface ArrivalProbe {
@@ -94,6 +98,11 @@ function arrivals(
 	return is_raised ? reading.issues : reading.issues.filter((issue) => !baseline.has(issue))
 }
 
+// The stall detector's condition, off the reading the probe already made.
+function is_offerable(reading: ReadyReading): boolean {
+	return reading.issues.length > NONE && reading.free_lanes > NO_FREE
+}
+
 // The baseline is the whole runnable pool, free lane or not: an issue that was waiting for a lane is not
 // new when one frees, and the child's merge that freed it already wakes the parent.
 //
@@ -149,7 +158,7 @@ async function retry_baseline(
 function pool_probe_of(
 	initial: ReadonlySet<string> | undefined,
 	first_ms: number,
-	ports: ReadyPorts,
+	ports: ArrivalPorts,
 	is_raised: () => boolean,
 ): ArrivalProbe {
 	let next_ms = first_ms
@@ -168,6 +177,8 @@ function pool_probe_of(
 
 		const reading = await read_reading(ports)
 
+		if (reading !== undefined) await ports.observe_offerable(is_offerable(reading))
+
 		return reading !== undefined && arrivals(baseline, reading, is_raised()).length > NONE
 	}
 

package/scripts/backlog/backlog-budget-cli.ts

@@ -1,7 +1,6 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
 import { path_decision } from '#scripts/josh/path-decision'
 import { cli_flags } from '#scripts/lib/cli-flags'
+import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 import {
 	backlog_budget,
 	type BacklogAnswer,
@@ -13,7 +12,6 @@ import {
 // command line, hand it to the pure decision, print the verdict on stdout and the reason on stderr
 // through the printer every mechanically-decided command in this repository already shares.
 
-const ARGV_OFFSET = 2
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const JSON_KEY = 'budget'
@@ -54,19 +52,6 @@ function to_time_ms(raw: string | undefined): number | undefined {
 	return Number.isNaN(parsed) ? undefined : parsed
 }
 
-// Digits and nothing else. `Number('')`, `Number(' ')` and `Number('0x10')` are all safe integers, so
-// a check that only asked `Number.isSafeInteger` would read an unset shell variable — `--max
-// "$max_issues"` — as a maximum of zero and finish the run having done nothing.
-const COUNT_PATTERN = /^\d+$/u
-
-function to_count(raw: string | undefined): number | undefined {
-	if (raw === undefined || !COUNT_PATTERN.test(raw)) return undefined
-
-	const parsed = Number(raw)
-
-	return Number.isSafeInteger(parsed) ? parsed : undefined
-}
-
 // A flag that was given but could not be read makes the whole invocation unreadable. Falling back to
 // the default instead would answer a question nobody asked — a mistyped `--idle 0` would read as the
 // default watch and hold a run open that was asked to finish at its first empty backlog.
@@ -80,10 +65,10 @@ type Counts = Record<(typeof COUNT_NAMES)[number], number | undefined>
 
 function counts_of(values: ParsedValues): Counts {
 	return {
-		idle: to_count(cli_flags.string_of(values.idle)),
-		max: to_count(cli_flags.string_of(values.max)),
-		merged: to_count(cli_flags.string_of(values.merged)),
-		running: to_count(cli_flags.string_of(values.running)),
+		idle: cli_flags.to_count(cli_flags.string_of(values.idle)),
+		max: cli_flags.to_count(cli_flags.string_of(values.max)),
+		merged: cli_flags.to_count(cli_flags.string_of(values.merged)),
+		running: cli_flags.to_count(cli_flags.string_of(values.running)),
 	}
 }
 
@@ -102,7 +87,7 @@ function to_idle_ms(idle_minutes: number | undefined): number | undefined {
 	if (idle_minutes === undefined) return backlog_budget.DEFAULT_IDLE_MS
 	if (idle_minutes === NO_IDLE_MINUTES) return undefined
 
-	return idle_minutes * backlog_budget.MS_PER_MINUTE
+	return idle_minutes * MS_PER_MINUTE
 }
 
 // An idle watch measured from the run's start is not the watch that was asked for. A run already
@@ -117,7 +102,7 @@ function to_idle_ms(idle_minutes: number | undefined): number | undefined {
 // lands on the very first ask, before the run has started anything, and the fix is one flag the loop
 // already holds: it always knows when it last had work.
 function is_watch_readable(values: ParsedValues): boolean {
-	if (to_idle_ms(to_count(cli_flags.string_of(values.idle))) === undefined) return true
+	if (to_idle_ms(cli_flags.to_count(cli_flags.string_of(values.idle))) === undefined) return true
 
 	return cli_flags.string_of(values.active) !== undefined
 }
@@ -197,28 +182,17 @@ function run(argv: ReadonlyArray<string>, now_ms: number = Date.now()): number {
 	return SUCCESS_EXIT_CODE
 }
 
-// `process.exitCode` rather than `process.exit()`, for the reason `backlog:next` records: the whole
-// contract is `answer=$(pnpm josh backlog:budget …)`, and exiting outright can cut the pipe before it
-// has drained.
-function main(argv: ReadonlyArray<string>): void {
-	process.exitCode = run(argv)
-}
-
 const backlog_budget_cli = {
 	JSON_KEY,
 	OPTIONS,
 	SUCCESS_EXIT_CODE,
 	USAGE,
 	build_input,
-	main,
 	read_arguments,
 	run,
 	to_answer,
-	to_count,
 	to_time_ms,
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET))
-
 export { backlog_budget_cli }
 export type { ParsedValues }

package/scripts/backlog/backlog-budget-main.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { backlog_budget_cli } from './backlog-budget-cli'
+
+// The `josh backlog:budget` entry, kept apart from `backlog-budget-cli.ts` because other modules
+// import that one: a bundle is one file, so a main guard there would fire for every command that
+// carries it (joshuafolkken/kit#4186).
+//
+// `process.exitCode` rather than `process.exit()`, for the reason `backlog:next` records: the whole
+// contract is `answer=$(pnpm josh backlog:budget …)`, and exiting outright can cut the pipe before it
+// has drained.
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = backlog_budget_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/backlog/backlog-budget.ts

@@ -1,3 +1,5 @@
+import { MS_PER_MINUTE, MS_PER_SECOND } from '#scripts/lib/timeouts'
+
 // `josh backlog:budget` — whether a `backlogrun` may start more work, keep watching, or finish.
 //
 // `backlog:next` says what may start; it says nothing about when the run itself should end. Without
@@ -17,7 +19,6 @@
 // and `josh review:level` are commands: a count and an elapsed time kept in an agent's head are a
 // one-shot judgement — a threshold asked once and then never again while the run walks past it.
 
-const MS_PER_MINUTE = 60_000
 const MINUTES_PER_HOUR = 60
 
 // **How long a run with nothing to do waits, and the only time bound a run has.** It is counted from
@@ -34,7 +35,6 @@ const DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE
 // once, without waiting it out. `backlogrun-progress.md` → "Waiting, and never waiting forever" holds
 // the row; the figure is here because `idle_watch_reason` below has to say it.
 const OFFER_INTERVAL_SECONDS = 60
-const MS_PER_SECOND = 1000
 const OFFER_INTERVAL_MS = OFFER_INTERVAL_SECONDS * MS_PER_SECOND
 
 const RUN_VERDICT = 'run'
@@ -42,7 +42,7 @@ const WATCH_VERDICT = 'watch'
 const STOP_VERDICT = 'stop'
 const TRIAGE_VERDICT = 'triage'
 
-// `run` — start what `backlog:next` offered. `watch` — sleep the polling interval and ask again,
+// `run` — start what `backlog:next` offered. `watch` — sleep the re-ask floor and ask again,
 // except while something of the run's own is in flight, where the wake is the progress watcher's exit
 // and the interval is only a floor (`docs/maintainers/backlogrun-driver.md` → "Waiting while
 // something is in flight").
@@ -87,7 +87,7 @@ interface BudgetDecision {
 }
 
 const BLOCKED_REASON =
-	'Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.'
+	'Everything opted in is blocked or already running, so waiting can still change the answer. Ask again at the re-ask floor (60 s).'
 
 const TRIAGE_REASON =
 	'An opted-in candidate carries neither `run:solo` nor `run:lane`, so nothing starts until it is judged. Read each issue named above, record its order and one of the two labels with a comment, then ask again.'
@@ -121,7 +121,7 @@ function max_reached_reason(merged: number, max_issues: number): string {
 }
 
 function draining_reason(running: number, reason: string): string {
-	return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish — ${reason}`
+	return `Start nothing more and wait on \`pnpm josh lane:await\` until the running children merge (running: ${String(running)}). Then report and finish — ${reason}`
 }
 
 function idle_expired_reason(answer: BacklogAnswer, idle_budget_ms: number): string {
@@ -140,7 +140,7 @@ function idle_watch_reason(answer: BacklogAnswer, left_ms: number): string {
 // **The watch runs down while they drain, and restarts at each one collected.** A collected child is
 // work, so it moves `active_at`; an ask that offered nothing never does.
 function running_watch_reason(answer: BacklogAnswer, running: number, left_ms: number): string {
-	return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree until they merge and poll at the polling interval — the watch is running down meanwhile.`
+	return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree and wait on \`pnpm josh lane:await\` until they merge — the watch is running down meanwhile.`
 }
 
 function watching_reason(input: BudgetInput, left_ms: number): string {
@@ -231,7 +231,6 @@ const backlog_budget = {
 	DEFAULT_IDLE_MINUTES,
 	DEFAULT_IDLE_MS,
 	IDLE_WAIT_HOURS,
-	MS_PER_MINUTE,
 	OFFER_INTERVAL_MS,
 	RUN_VERDICT,
 	STOP_VERDICT,

package/scripts/backlog/backlog-defect-priority.ts

@@ -18,10 +18,11 @@ function above_message(measured: DefectRate): string {
 	return `The defect rate ${defect_rate.rate_text(measured)} is above its baseline ${String(defect_rate.BASELINE_RATE)}, so defects are offered first and new mechanisms last.`
 }
 
-// An unreadable body reads as empty: the labels still classify `route:interrupt`, and anything else
-// keeps its usual place rather than being deferred on a read that failed.
+// The body the listing already carried, else one read for it (joshuafolkken/kit#4550). An unreadable
+// body reads as empty: the labels still classify `route:interrupt`, and anything else keeps its usual
+// place rather than being deferred on a read that failed.
 async function kind_of_child(child: EpicChild): Promise<IssueKind> {
-	const body = await git_gh_command.issue_get_body(String(child.number), child.repo)
+	const body = child.body ?? (await git_gh_command.issue_get_body(String(child.number), child.repo))
 
 	return defect_rate.kind_of({ body: body ?? '', labels: child.labels })
 }

package/scripts/backlog/backlog-drive-adopt.ts

@@ -0,0 +1,67 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
+import { run_event_stream } from '#scripts/run/event/run-event-stream'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import type { DrivePorts, DriveState } from './backlog-drive'
+import { backlog_drive_restore } from './backlog-drive-restore'
+
+// **A lane the drive did not launch is still the run's to collect** (joshuafolkken/kit#4373). The loop
+// held only the lanes it was seeded with and the ones it launched, so a child the parent dispatched
+// itself with `lane:launch` — an interrupt in a named run — finished, merged and was never handed to
+// `run:merge`: no `merge` event and no collected lane until `run:carry --end`, 91 minutes later. The
+// stop was `run_pass` collecting only `state.in_flight` (`backlog-drive.ts`), seeded once at start
+// (`backlog-drive-cli.ts` `seeded_lanes`). Adopted, a child that ends with its pull request unmerged
+// is classified `failed` by `run:merge` (`run-merge.ts` `unfinished_outcome`), which puts it on the
+// stream as a park with its cause (`run-merge-cli.ts` `on_parked_failure`) — the reason a lane left
+// unmerged is recorded.
+
+// The open lanes on a child this run launched and never settled — what the drive adopts while it runs
+// and `run:carry --end` collects once it has stopped.
+async function active_lanes(): Promise<ReadonlyArray<LaneInfo>> {
+	const active = backlog_drive_restore.active_issues(await run_event_stream_emit.current_events())
+	const lanes = await lane_registry.list_lanes()
+
+	return lanes.filter((lane) => !lane.is_stranded && active.has(lane.issue))
+}
+
+function adopted_note(issue: string): string {
+	return `${issue_cite.plain(issue)} adopted by backlog:drive: its lane was launched outside the loop`
+}
+
+async function note_adopted(issue: string): Promise<void> {
+	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.NOTE, adopted_note(issue))
+}
+
+// The active lanes the loop does not hold, each put on the stream with why it is adopted.
+async function adoptable(in_flight: ReadonlyArray<string>): Promise<ReadonlyArray<string>> {
+	const lanes = await active_lanes()
+	const issues = lanes.map((lane) => lane.issue).filter((issue) => !in_flight.includes(issue))
+
+	await Promise.all(
+		issues.map(async (issue) => {
+			await note_adopted(issue)
+		}),
+	)
+
+	return issues
+}
+
+// The state with every adoptable lane in flight, so its child is collected as soon as it ends. Asked on
+// an offered pass only, not every poll: the read walks the run's whole event stream. A stopping run
+// adopts nothing: the child whose unparked failure stopped it left the stream unsettled, so adopting
+// would collect — and count — it again.
+async function held(
+	state: DriveState,
+	should_offer: boolean,
+	ports: Pick<DrivePorts, 'adoptable'>,
+): Promise<DriveState> {
+	if (!should_offer || state.is_stopping) return state
+
+	const adopting = await ports.adoptable(state.in_flight)
+
+	return adopting.length === 0 ? state : { ...state, in_flight: [...state.in_flight, ...adopting] }
+}
+
+const backlog_drive_adopt = { active_lanes, adoptable, held }
+
+export { backlog_drive_adopt }

package/scripts/backlog/backlog-drive-args.ts

@@ -1,5 +1,6 @@
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { cli_flags } from '#scripts/lib/cli-flags'
+import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 import type { DriveState } from './backlog-drive'
 
 // The `josh backlog:drive` flags — read into a `DriveContext`, and written back as the `resume:` line —
@@ -7,9 +8,7 @@ import type { DriveState } from './backlog-drive'
 // `backlog_drive_cli` re-exports `parse` and `resume_line` under the names they always had, so the move
 // changed no call site and no suite that reads them through `backlog_drive_cli`.
 
-const MS_PER_MINUTE = 60_000
 const LIST_SEPARATOR = ','
-const COUNT_PATTERN = /^\d+$/u
 const USAGE =
 	'Usage: josh backlog:drive --owner <pid> [--active <ISO-8601>] [--max <n>] [--idle <minutes>] [--only] [--exclude <n>[,<n>...]] [--await <n>[,<n>...]] [--window <minutes>] [--stopped <n>]'
 
@@ -57,7 +56,7 @@ function to_issues(raw: string | undefined): ReadonlyArray<string> | undefined {
 function forwarded_of(values: Values): ReadonlyArray<string> | undefined {
 	const pairs = (['max', 'idle'] as const).filter((name) => values[name] !== undefined)
 
-	if (pairs.some((name) => !COUNT_PATTERN.test(values[name] ?? ''))) return undefined
+	if (pairs.some((name) => cli_flags.to_count(values[name]) === undefined)) return undefined
 
 	return pairs.flatMap((name) => [`--${name}`, values[name] ?? ''])
 }
@@ -68,7 +67,7 @@ function window_of(raw: string | undefined): number | undefined {
 }
 
 function is_valid_window(raw: string | undefined): boolean {
-	return raw === undefined || COUNT_PATTERN.test(raw)
+	return raw === undefined || cli_flags.to_count(raw) !== undefined
 }
 
 function is_valid_single(values: Values): boolean {
@@ -81,7 +80,7 @@ function is_valid_single(values: Values): boolean {
 function owner_of(values: Values | undefined): string | undefined {
 	const owner = values?.owner
 
-	return owner !== undefined && COUNT_PATTERN.test(owner) ? owner : undefined
+	return cli_flags.to_count(owner) === undefined ? undefined : owner
 }
 
 function to_context(values: Values, owner: string): DriveContext | undefined {

package/scripts/backlog/backlog-drive-cli.ts

@@ -12,7 +12,8 @@ import { error_text } from '#scripts/lib/error-message'
 import { json_value } from '#scripts/lib/json-value'
 import { run_carry, type RunCarry } from '#scripts/run/carry/run-carry'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
-import { run_merge_cli, type MergeResult } from '#scripts/run/merge/run-merge-cli'
+import type { MergeResult } from '#scripts/run/merge/run-merge-cli'
+import { run_merge_driver } from '#scripts/run/merge/run-merge-driver'
 import { z } from 'zod'
 import { backlog_budget } from './backlog-budget'
 import {
@@ -23,14 +24,19 @@ import {
 	type LoopPorts,
 	type OfferRead,
 } from './backlog-drive'
+import { backlog_drive_adopt } from './backlog-drive-adopt'
 import { backlog_drive_args, type DriveContext } from './backlog-drive-args'
 import { backlog_drive_carried } from './backlog-drive-carried'
 import { backlog_drive_finish } from './backlog-drive-finish'
+import { backlog_drive_hold, type HoldRecorder } from './backlog-drive-hold'
+import { backlog_drive_idle } from './backlog-drive-idle'
 import { backlog_drive_launch } from './backlog-drive-launch'
+import { backlog_drive_memory } from './backlog-drive-memory'
 import { backlog_drive_named } from './backlog-drive-named'
 import { backlog_drive_named_offer } from './backlog-drive-named-offer'
 import { backlog_drive_offer_argv } from './backlog-drive-offer-argv'
 import { backlog_drive_owner } from './backlog-drive-owner'
+import { backlog_drive_paused } from './backlog-drive-paused'
 import { backlog_drive_restore } from './backlog-drive-restore'
 import { backlog_drive_retrospective } from './backlog-drive-retrospective'
 import { backlog_drive_seats } from './backlog-drive-seats'
@@ -59,6 +65,8 @@ const offer_read_schema = z.object({
 	issues: z.array(z.string()),
 	retries: z.number(),
 	answer: z.string().optional(),
+	cause: z.string().optional(),
+	waiting: z.array(z.number()).optional(),
 	reason: z.string().optional(),
 	is_finish: z.boolean().optional(),
 })
@@ -106,20 +114,21 @@ function merge_token(out: string, code: number): string {
 	return ''
 }
 
+// A `run:merge` that printed no result — a crash before its verdict — answers no token, which the loop
+// never reads as a collection.
+function unprinted(code: number): MergeResult {
+	return { token: '', code, is_offer: true, outcome: 'unresolved' }
+}
+
 // The child's transcript, where its lane recorded one, so `run:merge` can tell an API outage from a
-// failure exactly as it does for the parent that passes `--output` by hand. No hand-off threshold: the
-// supervisor runs this loop, and a process has no context to cut.
+// failure exactly as it does for the parent that passes `--output` by hand. Run as its own process
+// (`run-merge-driver.ts`), so a fix merged since this loop started is the code that decides the child.
 async function merge(issue: string, owner: string): Promise<MergeResult> {
 	await backlog_drive_owner.assert_current(owner)
 	const lane = await lane_registry.find_open_lane(issue)
-	const result = await run_merge_cli.merge_child({
-		child: issue,
-		epic: undefined,
-		repo: undefined,
-		over: undefined,
-		owner: run_carry.owner_of(Number(owner)),
-		output: lane?.output,
-	})
+	const argv = run_merge_driver.argv_of({ child: issue, owner, output: lane?.output })
+	const ran = await josh_command.josh_run(argv, should_forward_stderr)
+	const result = run_merge_driver.read(ran.out) ?? unprinted(ran.code)
 
 	await backlog_drive_named.mark_done(issue, result, owner)
 
@@ -130,17 +139,18 @@ async function merge(issue: string, owner: string): Promise<MergeResult> {
 // a restart after it ended — is read as having appeared, so it is collected after the re-confirm window
 // rather than waited on until the never-appeared timeout. One that never appeared is collected too:
 // `run:merge` reads its state rather than this loop guessing.
-function finished_checker(seeded: ReadonlyArray<string>): (issue: string) => boolean {
+function finished_checker(seeded: ReadonlySet<string>): (issue: string) => boolean {
 	const states = new Map<string, AwaitState>()
 	const config = {
 		is_running: lane_await.is_process_running_default,
+		is_shipped: lane_await.is_shipped_default,
 		reconfirm_ms: lane_await.RECONFIRM_MS,
 		never_appeared_timeout_ms: lane_await.NEVER_APPEARED_TIMEOUT_MS,
 	}
 
 	return (issue: string): boolean => {
 		const state = states.get(issue) ?? {
-			appeared: seeded.includes(issue),
+			appeared: seeded.has(issue),
 			disappeared_at: undefined,
 			first_polled_at: undefined,
 		}
@@ -181,19 +191,61 @@ function judgement_reader(): () => Promise<number> {
 	}
 }
 
+// The reports an offered pass leaves: why it started nothing, the idle notice and the paused notice.
+function reporters(holds: HoldRecorder): Pick<LoopPorts, 'hold' | 'idle' | 'paused'> {
+	return {
+		hold: holds.hold,
+		idle: backlog_drive_idle.notify,
+		paused: async () => {
+			await backlog_drive_paused.notify()
+		},
+	}
+}
+
+// What a launch is weighed against: the free lanes, a kept lane, and the memory for one more.
+function room_ports(): Pick<LoopPorts, 'free_lanes' | 'has_lane' | 'limit_room' | 'memory_held'> {
+	return {
+		free_lanes: backlog_ready.drive_free_lane_count,
+		limit_room: backlog_ready.drive_limit_room,
+		has_lane: backlog_drive_seats.has_kept_lane,
+		memory_held: backlog_drive_memory.gauge(),
+	}
+}
+
+// The children's ports. An adopted lane was dispatched like a seeded one, so a child already gone is
+// collected rather than waited on until the never-appeared timeout.
+function child_ports(
+	seeded: ReadonlyArray<string>,
+	owner: string,
+): Pick<LoopPorts, 'adoptable' | 'is_finished' | 'merge'> {
+	const known = new Set(seeded)
+
+	return {
+		is_finished: finished_checker(known),
+		merge: async (issue) => await merge(issue, owner),
+		adoptable: async (in_flight) => {
+			const adopting = await backlog_drive_adopt.adoptable(in_flight)
+
+			for (const issue of adopting) known.add(issue)
+
+			return adopting
+		},
+	}
+}
+
 function ports_of(
 	context: DriveContext,
 	seeded: ReadonlyArray<string>,
 	last: { state: DriveState },
+	holds: HoldRecorder,
 ): LoopPorts {
 	return {
-		is_finished: finished_checker(seeded),
-		merge: async (issue) => await merge(issue, context.owner),
+		...child_ports(seeded, context.owner),
 		offer: async (state) => await read_offer(state, context),
 		launch: async (issue) => await backlog_drive_launch.launch(issue, context.owner),
-		free_lanes: backlog_ready.drive_free_lane_count,
-		has_lane: backlog_drive_seats.has_kept_lane,
+		...room_ports(),
 		judgement_owed: judgement_reader(),
+		...reporters(holds),
 		now: () => new Date(),
 		sleep: async (milliseconds) => {
 			await sleep(milliseconds)
@@ -205,7 +257,15 @@ function ports_of(
 	}
 }
 
-async function seeded_lanes(context: DriveContext): Promise<ReadonlyArray<string> | undefined> {
+// The lanes still in flight, and the children this run withdrew: a withdrawal while the drive was
+// handed back is never collected by this invocation, so its exclusion is read from the stream
+// (joshuafolkken/kit#4365).
+interface Seeded {
+	lanes: ReadonlyArray<string>
+	withdrawn: ReadonlyArray<string>
+}
+
+async function seeded_lanes(context: DriveContext): Promise<Seeded | undefined> {
 	const carry = await read_record()
 
 	if (carry === undefined) return undefined
@@ -216,9 +276,13 @@ async function seeded_lanes(context: DriveContext): Promise<ReadonlyArray<string
 
 	const open = await open_lanes()
 	const lanes = [...new Set([...open.map((lane) => lane.issue), ...context.awaited])]
-	const dispatched = await backlog_drive_carried.carried(open)
+	const carried = await backlog_drive_carried.carried(open)
+	const dispatched = backlog_drive_named.own_carried(carry, carried, context.is_only)
 
-	return backlog_drive_restore.restore(lanes, events, carry.merged_issues ?? [], dispatched)
+	return {
+		lanes: backlog_drive_restore.restore(lanes, events, carry.merged_issues ?? [], dispatched),
+		withdrawn: backlog_drive_restore.withdrawn_issues(events),
+	}
 }
 
 // The interval between two asks is `backlog:budget`'s own, so the driver keeps the one its reason prints.
@@ -226,19 +290,39 @@ function loop_config(window_ms: number | undefined): LoopConfig {
 	return { poll_ms: POLL_MS, offer_ms: backlog_budget.OFFER_INTERVAL_MS, window_ms }
 }
 
+// The hand-back, the ledger's hold included — the lanes now wait on a session — and the resume line.
+async function report_end(
+	end: DriveEnd,
+	state: DriveState,
+	context: DriveContext,
+	holds: HoldRecorder,
+): Promise<void> {
+	await holds.end(end)
+	console.info(end_line(end))
+	console.info(backlog_drive_args.resume_line(state, context))
+}
+
+function seeded_state(seeded: Seeded, context: DriveContext): DriveState {
+	const fresh = backlog_drive.initial_state(
+		seeded.lanes,
+		context.active ?? new Date().toISOString(),
+	)
+	const initial =
+		context.stopped === undefined ? fresh : backlog_drive.merge_stopped(context.stopped, fresh)
+
+	return { ...initial, exclude: [...new Set([...context.exclude, ...seeded.withdrawn])] }
+}
+
 async function drive(context: DriveContext): Promise<number> {
 	const seeded = await seeded_lanes(context)
 
 	if (seeded === undefined) return FAILURE_EXIT_CODE
-	const fresh = backlog_drive.initial_state(seeded, context.active ?? new Date().toISOString())
-	const initial =
-		context.stopped === undefined ? fresh : backlog_drive.merge_stopped(context.stopped, fresh)
-	const last = { state: { ...initial, exclude: [...context.exclude] } }
-	const config = loop_config(context.window_ms)
-	const end = await backlog_drive.run_loop(last.state, config, ports_of(context, seeded, last))
+	const last = { state: seeded_state(seeded, context) }
+	const holds = backlog_drive_hold.recorder()
+	const ports = ports_of(context, seeded.lanes, last, holds)
+	const end = await backlog_drive.run_loop(last.state, loop_config(context.window_ms), ports)
 
-	console.info(end_line(end))
-	console.info(backlog_drive_args.resume_line(last.state, context))
+	await report_end(end, last.state, context, holds)
 
 	return SUCCESS_EXIT_CODE
 }
@@ -288,6 +372,7 @@ const backlog_drive_cli = {
 	read_offer,
 	resume_line: backlog_drive_args.resume_line,
 	run,
+	seeded_state,
 	to_offer,
 }