@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/scripts/backlog/backlog-drive-launch-pass.ts

@@ -9,15 +9,34 @@ const LAUNCHED = 'launched'
 const UNOPENED = 'unopened'
 // The launch port's answer for an issue its measurement declaration closed (`backlog-measure-close.ts`).
 const MEASURED_LAUNCH = 'measured' as const
+// Its answer for an issue whose declaration has no sample yet: it waits, so this drive re-offers it no
+// more and a later drive measures it again (joshuafolkken/kit#6503).
+const UNSAMPLED_LAUNCH = 'unsampled' as const
+// Its answer for an issue over the size bar its split-only unit split into children
+// (`backlog-drive-split-unit.ts`): the parent is an epic now, so it is excluded as a measured close is.
+const SPLIT_LAUNCH = 'split' as const
 
-type DriveLaunch = LaunchOutcome['kind'] | typeof MEASURED_LAUNCH
+type DriveLaunch =
+	LaunchOutcome['kind'] | typeof MEASURED_LAUNCH | typeof UNSAMPLED_LAUNCH | typeof SPLIT_LAUNCH
 
 interface Settled {
 	in_flight: Array<string>
 	measured: Array<string>
+	unsampled: Array<string>
 }
 
-function handed_back(issue: string, state: DriveState): PassResult {
+// **A refused launch is a mechanical failure, not a question** (joshuafolkken/kit#6878): it is parked
+// with `run:stalled` before it is handed back, so no session parks it as `needs-decision` and the next
+// offer does not hand it straight back. A seat probe that could not read the lanes' processes or ports
+// refuses `lane:open` too, so it reaches here as `unopened` with lanes free.
+async function handed_back(
+	issue: string,
+	outcome: DriveLaunch,
+	state: DriveState,
+	ports: DrivePorts,
+): Promise<PassResult> {
+	await ports.stall(issue, outcome)
+
 	return { kind: 'end', end: { reason: 'launch', token: undefined, issue }, state }
 }
 
@@ -30,61 +49,98 @@ async function refused(
 	state: DriveState,
 	ports: DrivePorts,
 ): Promise<PassResult> {
-	if (outcome !== UNOPENED) return handed_back(issue, state)
+	if (outcome === 'waiting') return { kind: 'continue', state }
+	if (outcome !== UNOPENED) return await handed_back(issue, outcome, state, ports)
 	if ((await ports.free_lanes()) <= NO_FREE_LANES) return { kind: 'continue', state }
 
-	return handed_back(issue, state)
+	return await handed_back(issue, outcome, state, ports)
 }
 
 // **Only a launch or a measured close is activity**: a pass that started nothing — every lane taken
 // — keeps `active` where it was, or the once-a-minute offer would restart the idle budget for good. A
 // measured issue is closed but may still read OPEN to `backlog:next`, so it is excluded as a merge is.
+// An unsampled issue started nothing: it goes to `waiting`, kept out of the offer but not counted merged.
 function launched(state: DriveState, settled: Settled, ports: DrivePorts): DriveState {
-	const { in_flight, measured } = settled
+	const { in_flight, measured, unsampled } = settled
+	const exclude = [...state.exclude, ...measured]
+	const waiting = [...(state.waiting ?? []), ...unsampled]
 
 	if (in_flight.length === state.in_flight.length && measured.length === 0) {
-		return { ...state, in_flight }
+		return { ...state, in_flight, exclude, waiting }
 	}
 
-	const exclude = [...state.exclude, ...measured]
+	return { ...state, in_flight, exclude, waiting, active: ports.now().toISOString() }
+}
 
-	return { ...state, in_flight, exclude, active: ports.now().toISOString() }
+// Whether the launch settled the issue — into flight, closed by its measurement, split by its split-only
+// unit, or waiting for a sample.
+const SETTLED: ReadonlySet<DriveLaunch> = new Set([
+	MEASURED_LAUNCH,
+	LAUNCHED,
+	UNSAMPLED_LAUNCH,
+	SPLIT_LAUNCH,
+])
+
+function is_settled(outcome: DriveLaunch): boolean {
+	return SETTLED.has(outcome)
 }
 
-// Whether the launch settled the issue — into flight, or closed by its measurement.
-function is_settled(settled: Settled, issue: string, outcome: DriveLaunch): boolean {
-	if (outcome === MEASURED_LAUNCH) settled.measured.push(issue)
+function settle(settled: Settled, issue: string, outcome: DriveLaunch): void {
+	if (outcome === MEASURED_LAUNCH || outcome === SPLIT_LAUNCH) settled.measured.push(issue)
+	if (outcome === UNSAMPLED_LAUNCH) settled.unsampled.push(issue)
 	if (outcome === LAUNCHED) settled.in_flight.push(issue)
+}
+
+interface Launched {
+	issue: string
+	outcome: DriveLaunch
+}
+
+// Every launch runs to its end before a failure is thrown, so none is still opening a lane once the
+// pass has given up.
+async function launch_each(
+	issues: ReadonlyArray<string>,
+	ports: DrivePorts,
+): Promise<Array<Launched>> {
+	const results = await Promise.allSettled(
+		issues.map(async (issue) => ({ issue, outcome: await ports.launch(issue) })),
+	)
+	const failure = results.find((result) => result.status === 'rejected')
 
-	return outcome === MEASURED_LAUNCH || outcome === LAUNCHED
+	if (failure !== undefined) throw failure.reason
+
+	return results.flatMap((result) => (result.status === 'fulfilled' ? [result.value] : []))
 }
 
 // **No more new lanes than free lanes**. `backlog:offer` lists every ready issue without reading the
 // lanes, so launching all of them overran `JOSH_LANE_LIMIT` until `lane:open` ran out of seats. An issue
 // that already holds a kept lane reuses its port seat but takes a place under the limit, ahead of a
 // fresh launch; the rest launch up to the free count (`backlog-drive-seats.ts`), read before the first.
+//
+// **The pass's launches run side by side** (joshuafolkken/kit#5519): one after another, four lanes took
+// 49 s. Their outcomes are then settled in offer order, so every lane that launched is in flight
+// whichever refused, and the first refusal in that order is the one the pass answers. A split-only unit
+// holds the pass for its minutes (`backlog-drive-split-unit.ts`): accepted, since it runs once per
+// over-bar issue and its split changes what the next offer lists.
 async function launch_all(
 	issues: ReadonlyArray<string>,
 	state: DriveState,
 	ports: DrivePorts,
 ): Promise<PassResult> {
-	const settled: Settled = { in_flight: [...state.in_flight], measured: [] }
+	const settled: Settled = { in_flight: [...state.in_flight], measured: [], unsampled: [] }
 	const launching = await backlog_drive_seats.seated(issues, ports)
+	const outcomes = await launch_each(launching, ports)
+	for (const { issue, outcome } of outcomes) settle(settled, issue, outcome)
 
-	for (const issue of launching) {
-		// eslint-disable-next-line no-await-in-loop -- lanes launch in order and the first refusal ends the pass
-		const outcome = await ports.launch(issue)
+	const refusal = outcomes.find(({ outcome }) => !is_settled(outcome))
+	const next = launched(state, settled, ports)
 
-		if (!is_settled(settled, issue, outcome)) {
-			// eslint-disable-next-line no-await-in-loop -- lanes launch in order and the first refusal ends the pass
-			return await refused(issue, outcome, launched(state, settled, ports), ports)
-		}
-	}
+	if (refusal === undefined) return { kind: 'continue', state: next }
 
-	return { kind: 'continue', state: launched(state, settled, ports) }
+	return await refused(refusal.issue, refusal.outcome, next, ports)
 }
 
-const backlog_drive_launch_pass = { MEASURED_LAUNCH, launch_all }
+const backlog_drive_launch_pass = { MEASURED_LAUNCH, SPLIT_LAUNCH, UNSAMPLED_LAUNCH, launch_all }
 
 export type { DriveLaunch }
 export { backlog_drive_launch_pass }

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

@@ -1,11 +1,13 @@
 import { git_stash } from '#scripts/git/stash/git-stash'
-import { lane_launch_cli } from '#scripts/lane/lane-launch-cli'
+import { lane_launch_cli, type LaunchOutcome } from '#scripts/lane/lane-launch-cli'
 import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import { backlog_drive_launch_pass, type DriveLaunch } from './backlog-drive-launch-pass'
 import { backlog_drive_owner } from './backlog-drive-owner'
+import { backlog_drive_split_unit } from './backlog-drive-split-unit'
+import { backlog_drive_trace } from './backlog-drive-trace'
 import { backlog_measure_close } from './backlog-measure-close'
 
-const { MEASURED_LAUNCH } = backlog_drive_launch_pass
+const { MEASURED_LAUNCH, SPLIT_LAUNCH, UNSAMPLED_LAUNCH } = backlog_drive_launch_pass
 
 // The driver's lane launch. The parent that ran `josh latest` in the primary
 // checkout leaves its rewritten lock file in a stash under this message — `backlogrun-lanes.md` →
@@ -31,20 +33,84 @@ async function latest_stash(): Promise<string | undefined> {
 	return selection.kind === 'match' ? LATEST_STASH_MESSAGE : undefined
 }
 
-// An issue its measurement declaration closed takes no lane (`backlog-measure-close.ts`).
-async function launch(issue: string, owner: string): Promise<DriveLaunch> {
+// **One launch at a time holds the stash** (joshuafolkken/kit#5519): a pass's launches run side by
+// side, and each asking the stack alone would find the stash every one of them, before any pop. The
+// claim is taken before the stack is read and given back when the launch ends, so a pop that refused
+// leaves the stash for the next pass's first launch.
+const stash_holders = new Set<string>()
+
+async function launch_ready(issue: string): Promise<LaunchOutcome> {
+	const { launch_ready_lane } = lane_launch_cli
+
+	if (stash_holders.size > 0) return await launch_ready_lane({ issue, stash: undefined })
+
+	stash_holders.add(issue)
+
+	try {
+		return await launch_ready_lane({ issue, stash: await latest_stash() })
+	} finally {
+		stash_holders.delete(issue)
+	}
+}
+
+// A refusal's stage keeps the failing step's own explanation after the issue, folded onto the event's
+// one line and capped, since the board draws the newest stage whole as its header; the
+// `no child launched` prefix the board ends the stage on is unchanged.
+const DETAIL_LIMIT = 200
+
+function no_child(issue: string, detail: string | undefined): string {
+	const event = run_event_setup.no_child(issue)
+
+	if (detail === undefined) return event
+
+	const folded = detail.replaceAll(/\s+/gu, ' ')
+	const capped = folded.length > DETAIL_LIMIT ? `${folded.slice(0, DETAIL_LIMIT)}…` : folded
+
+	return `${event}: ${capped}`
+}
+
+// An issue its measurement declaration closed, or that waits for a sample, takes no lane
+// (`backlog-measure-close.ts`, which puts the wait on the stream).
+async function measured(issue: string): Promise<DriveLaunch | undefined> {
+	const outcome = await backlog_measure_close.outcome(issue)
+
+	if (outcome === 'closed') return MEASURED_LAUNCH
+
+	return outcome === 'wait' ? UNSAMPLED_LAUNCH : undefined
+}
+
+// An issue over the size bar that its split-only unit split takes no lane either
+// (`backlog-drive-split-unit.ts`). The unit runs for minutes, so ownership is asserted again after it:
+// a driver superseded meanwhile opens no lane.
+async function opened(issue: string, owner: string): Promise<DriveLaunch> {
+	await backlog_drive_owner.assert_current(owner)
+
+	const settled = await measured(issue)
+
+	if (settled !== undefined) return settled
+	if ((await backlog_drive_split_unit.run(issue)) === 'split') return SPLIT_LAUNCH
 	await backlog_drive_owner.assert_current(owner)
-	if (await backlog_measure_close.closed(issue)) return MEASURED_LAUNCH
 	await run_event_setup.emit(run_event_setup.opening_lane(issue))
 
-	const outcome = await lane_launch_cli.launch_lane({ issue, stash: await latest_stash() })
+	const outcome = await launch_ready(issue)
 
 	// A refusal the driver waits out writes nothing else, so the lane's stage is ended here.
-	if (outcome.kind !== 'launched') await run_event_setup.emit(run_event_setup.STAGE.NO_CHILD)
+	if (outcome.kind !== 'launched' && outcome.kind !== 'waiting') {
+		await run_event_setup.emit(no_child(issue, outcome.detail))
+	}
 
 	return outcome.kind
 }
 
+// The launch opened and closed on the stream (`backlog-drive-trace.ts`).
+async function launch(issue: string, owner: string): Promise<DriveLaunch> {
+	return await backlog_drive_trace.traced(
+		issue,
+		backlog_drive_trace.STEP.LAUNCH,
+		async () => await opened(issue, owner),
+	)
+}
+
 const backlog_drive_launch = { LATEST_STASH_MESSAGE, launch }
 
 export { backlog_drive_launch }

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

@@ -0,0 +1,59 @@
+import { git_gh_issue } from '#scripts/gh/git-gh-issue'
+import { git_gh_issue_rest } from '#scripts/gh/git-gh-issue-rest'
+import { AUTO_OK_LABEL } from '#scripts/issue/issue-labels'
+
+type ListingCheck = () => Promise<boolean>
+
+// The issue numbers the `auto-ok` listing's first page holds, its pull requests left out.
+function numbers_of(body: string): ReadonlySet<number> {
+	const issues = git_gh_issue_rest.parse_rest_issues(body)
+
+	return new Set(
+		issues
+			.filter((issue) => !git_gh_issue_rest.is_pull_request(issue))
+			.map((issue) => issue.number),
+	)
+}
+
+function has_new(seen: ReadonlySet<number> | undefined, numbers: ReadonlySet<number>): boolean {
+	if (seen === undefined) return false
+
+	return [...numbers].some((number) => !seen.has(number))
+}
+
+// Whether the `auto-ok` listing's first page holds an issue the previous read lacked
+// (joshuafolkken/kit#7227). The ETag keeps the read cheap, but a running lane's own comments and
+// label edits change it too, so only a new issue number counts. The first read is the baseline,
+// and a read that fails reads as unchanged: the ask's interval still comes. A first read that fails
+// leaves an empty baseline rather than none, so an issue listed before the next read that answers
+// still counts as new (joshuafolkken/kit#7229).
+function watcher(): ListingCheck {
+	const memory: { seen?: ReadonlySet<number> } = {}
+
+	function keep(numbers: ReadonlySet<number>): void {
+		memory.seen = numbers
+	}
+
+	return async function is_changed(): Promise<boolean> {
+		try {
+			const detail = await git_gh_issue.issue_list_label_first_page(AUTO_OK_LABEL)
+			const numbers = numbers_of(detail.body)
+			const is_new = has_new(memory.seen, numbers)
+
+			keep(numbers)
+
+			return is_new
+		} catch {
+			keep(memory.seen ?? new Set())
+
+			return false
+		}
+	}
+}
+
+const backlog_drive_listing = {
+	watcher,
+}
+
+export type { ListingCheck }
+export { backlog_drive_listing }

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

@@ -5,6 +5,7 @@ import {
 	type MachineMark,
 } from '#scripts/run/board/run-board-machine'
 import type { DrivePorts, DriveState, PassResult } from './backlog-drive'
+import { backlog_hold_codes } from './backlog-hold-codes'
 
 // Whether the machine has room for one more lane (joshuafolkken/kit#4084). The lane limit counts lanes,
 // not memory, so a lane opened while the machine swapped slowed every gate already running.
@@ -18,10 +19,8 @@ import type { DrivePorts, DriveState, PassResult } from './backlog-drive'
 // yellow. The kernel's warning is no hold (joshuafolkken/kit#4199): macOS keeps it long after the
 // pressure passed, so a run held on it never resumed.
 //
-// **The 🧠 resume bar stays at yellow (70%) on measurement** (joshuafolkken/kit#4529). Across the
-// 2026-10-22 run on an 18 GB machine (106 one-minute samples, 24 after the whole-suite and vitest-worker
-// cuts merged) 🧠 never reached 70%, peaking at 67%; every memory hold, 1.3 minutes in all, came with a
-// swap burst. 💾 is what holds a lane, so a lower 🧠 bar would admit nothing sooner and only risk swap.
+// **The 🧠 resume bar stays at yellow** (joshuafolkken/kit#4529): observed memory holds came with
+// swap bursts. 💾 is what holds a lane, so a lower 🧠 bar would admit nothing sooner and only risk swap.
 //
 // **A figure that could not be read is no limit**, as in the gate's core budget: a machine without
 // `sysctl` dispatches as it did before memory was read.
@@ -31,7 +30,7 @@ const { PRESSURE_HOLD } = machine_capacity
 // Two readings closer than this give no swap rate: a page swapped in a few milliseconds is no rate.
 const MIN_RATE_MS = 1000
 // The `hold` reason a pass held by memory records, read back by `run:board` and `lane:stats`.
-const HOLD_REASON = 'memory'
+const HOLD_REASON = backlog_hold_codes.MEMORY_REASON
 
 type MemoryGauges = Pick<MachineGauges, 'memory_percent' | 'swap_mb_per_s' | 'memory_pressure'>
 

package/scripts/backlog/backlog-drive-named-offer.ts

@@ -9,14 +9,17 @@ import {
 import type { IssueState } from '#scripts/issue/issue-state'
 import { issue_state_cli } from '#scripts/issue/issue-state-cli'
 import { lane_plan } from '#scripts/lane/lane-plan'
+import { lane_plan_probe } from '#scripts/lane/lane-plan-probe'
 import type { RunCarry } from '#scripts/run/carry/run-carry'
 import { backlog_budget } from './backlog-budget'
 import type { DriveState, OfferRead } from './backlog-drive'
 import { backlog_drive_epic } from './backlog-drive-epic'
 import { backlog_drive_named } from './backlog-drive-named'
+import { backlog_drive_rate_limit } from './backlog-drive-rate-limit'
+import { backlog_drive_stalled_retry } from './backlog-drive-stalled-retry'
 import { backlog_drive_unread } from './backlog-drive-unread'
 import type { Declared } from './backlog-overlap'
-import { backlog_plan_comment } from './backlog-plan-comment'
+import { backlog_plan_comment, type PoolIssue } from './backlog-plan-comment'
 
 interface NamedContext {
 	is_only: boolean
@@ -24,6 +27,16 @@ interface NamedContext {
 	owner: string
 }
 
+interface NamedRead {
+	offer: OfferRead | undefined
+	pool: DriveState
+}
+
+interface NamedPass {
+	offer: OfferRead | undefined
+	passed: ReadonlyArray<string>
+}
+
 const NO_RETRIES = 0
 
 function max_of(forwarded: ReadonlyArray<string>): number | undefined {
@@ -105,7 +118,7 @@ async function unmerged_reason(
 }
 
 function cite(issue: number, reason: string | undefined): string | undefined {
-	return reason === undefined ? undefined : `${issue_cite.plain(issue)} (${reason})`
+	return reason === undefined ? undefined : `${issue_cite.plain_for('program', issue)} (${reason})`
 }
 
 // Each named issue that did not merge, with its reason. The issues `run:add` put in count too: one that
@@ -142,45 +155,122 @@ async function not_run(
 	return named?.is_finish === true ? await only_end(carry, named) : named
 }
 
-// What the lanes in flight declare — recorded plan, else plan comment, else body, the scope `lane:plan` and
-// `backlog:next` read. A lane the listing does not carry, or an unread listing, declares its plan alone.
-async function in_flight_declared(in_flight: ReadonlyArray<string>): Promise<Declared> {
-	const listing = await auto_ok_cli.fetch_opted_in()
-	const listed = listing.kind === 'read' ? listing.issues : []
-	const pool = in_flight
-		.map(Number)
-		.map((number) => listed.find((issue) => issue.number === number) ?? { number })
+// What `numbers` declare — recorded plan, else plan comment, else body, the scope `lane:plan` and
+// `backlog:next` read; a plan comment posted after the record wins (joshuafolkken/kit#6798). An issue
+// `listed` does not carry, or an unread listing, declares its plan alone.
+async function declared_among(
+	numbers: ReadonlyArray<number>,
+	listed: ReadonlyArray<PoolIssue>,
+): Promise<Declared> {
+	const pool = [...new Set(numbers)].map(
+		(number) => listed.find((issue) => issue.number === number) ?? { number },
+	)
 
 	return await backlog_plan_comment.declared_of(pool, process.cwd())
 }
 
-// The issues in flight, with each named one whose yielded plan a running lane still holds: the offer
-// waits on it as on a lane, so the run does not relaunch it into the same yield (joshuafolkken/kit#4926).
-// The listing is read only when a named issue yielded and a lane runs.
+// The issues in flight, with each named one whose yielded plan — or the plan comment fixed since it
+// (joshuafolkken/kit#6798) — a running lane still holds. A running lane is one in flight or one the
+// listing carries `in-progress`, the holders `lane:plan`'s probe yields to (`lane-plan-probe.ts`), so a
+// lane outside this run holds too (joshuafolkken/kit#6800). The offer waits on it as on a lane, so the
+// run does not relaunch it into the same yield (joshuafolkken/kit#4926), and offers it again once the
+// holder's lane ends and drops its `in-progress`. The listing is read only when a named issue yielded.
 async function holding(carry: RunCarry, in_flight: ReadonlyArray<string>): Promise<Array<string>> {
 	const yielded = backlog_drive_named
 		.named_issues(carry)
 		.filter((issue) => lane_plan.is_yielded(issue, process.cwd()))
-	if (yielded.length === 0 || in_flight.length === 0) return [...in_flight]
-	const declared = await in_flight_declared(in_flight)
-	const held = yielded.filter((issue) => lane_plan.is_yield_held(issue, declared, process.cwd()))
+	if (yielded.length === 0) return [...in_flight]
+	const listing = await auto_ok_cli.fetch_opted_in()
+	const listed = listing.kind === 'read' ? listing.issues : []
+	const running = lane_plan_probe.running_of(listed).map((issue) => issue.number)
+	const declared = await declared_among([...in_flight.map(Number), ...running], listed)
+	const scopes = await declared_among(yielded, listed)
+	const held = yielded.filter((issue) =>
+		lane_plan.is_yield_held(issue, declared, process.cwd(), scopes.get(issue)),
+	)
 
 	return [...new Set([...in_flight, ...held.map(String)])]
 }
 
-async function read(
+// A named launch waits for the reset while the GitHub core allowance is below the floor, before it reads
+// the issue's state (joshuafolkken/kit#6729). Only a launch reads the allowance: a wait or the run's end
+// starts nothing.
+async function launch(
+	issue: string | undefined,
+	named: OfferRead,
+	state: DriveState,
+	owner: string,
+): Promise<OfferRead | undefined> {
+	if (issue === undefined) return undefined
+
+	const held = await backlog_drive_rate_limit.held(state)
+
+	return held ?? (await classify(issue, named, state, owner))
+}
+
+// An epic `run:add` put in that waits on its children holds nothing up, like an added issue in flight
+// (joshuafolkken/kit#6883): its children are what runs, so the offer passes it as in flight and the
+// issues behind it, or the pool, fill the free lanes (joshuafolkken/kit#6840). The pool counts it
+// running, so with no lane of the run's own in flight it does not read the drain while the epic is
+// open. A failed read still waits (`retries`), so the epic's retry count reaches its hand-back.
+function is_passed(
+	carry: RunCarry,
+	issue: string | undefined,
+	offered: OfferRead | undefined,
+): issue is string {
+	if (issue === undefined || offered?.verdict !== 'wait') return false
+
+	return offered.retries === NO_RETRIES && !backlog_drive_named.is_declared(carry, issue)
+}
+
+async function offer_of(
 	carry: RunCarry,
 	state: DriveState,
+	waiting: DriveState,
 	context: NamedContext,
-): Promise<OfferRead | undefined> {
-	const waiting = { ...state, in_flight: await holding(carry, state.in_flight) }
+): Promise<NamedPass> {
 	const named = backlog_drive_named.offer(carry, waiting, context.is_only)
-	if (named?.verdict !== 'run') return await not_run(carry, named)
+	if (named?.verdict !== 'run') return { offer: await not_run(carry, named), passed: [] }
 	const budget = budget_offer(carry, state, context.forwarded)
-	if (budget.verdict !== 'run') return budget
+	if (budget.verdict !== 'run') return { offer: budget, passed: [] }
 	const [issue] = named.issues
+	const offered = await launch(issue, named, state, context.owner)
+	if (!is_passed(carry, issue, offered)) return { offer: offered, passed: [] }
+	const past = await offer_of(
+		carry,
+		state,
+		{ ...waiting, in_flight: [...waiting.in_flight, issue] },
+		context,
+	)
+
+	return { ...past, passed: [issue, ...past.passed] }
+}
+
+// A named issue the yield holds while none of the run's own lanes runs — its holder is outside the run
+// (joshuafolkken/kit#6800). The pool's offer would read nothing running as the drain and end the run
+// before the issue is offered again (`backlog-offer-cli.ts` → `mark_drain`), so the run waits on it.
+function held_alone(state: DriveState, waiting: DriveState): OfferRead | undefined {
+	if (state.in_flight.length > 0 || waiting.in_flight.length === 0) return undefined
+
+	return { verdict: 'wait', issues: [], retries: NO_RETRIES }
+}
+
+// The named offer, and the state the pool's offer reads when it names nothing: a named issue the yield
+// still holds is excluded there too, so the pool does not relaunch it into the same yield
+// (joshuafolkken/kit#4926, joshuafolkken/kit#6883). It is excluded, not counted running: no lane holds it.
+// An added epic the offer passed is counted running there (`is_passed`).
+// joshuafolkken/kit#6865: each offer first retries the mechanical parks whose stop has cleared.
+async function read(carry: RunCarry, state: DriveState, context: NamedContext): Promise<NamedRead> {
+	await backlog_drive_stalled_retry.sweep()
+	const waiting = { ...state, in_flight: await holding(carry, state.in_flight) }
+	const { offer, passed } = await offer_of(carry, state, waiting, context)
+	const pool = {
+		...state,
+		in_flight: [...state.in_flight, ...passed],
+		exclude: [...state.exclude, ...waiting.in_flight],
+	}
 
-	return issue === undefined ? undefined : await classify(issue, named, state, context.owner)
+	return { offer: offer ?? held_alone(state, waiting), pool }
 }
 
 export const backlog_drive_named_offer = { read }

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

@@ -12,8 +12,13 @@ import { backlog_named } from './backlog-named'
 const { MERGE_TOKEN } = run_merge_token
 
 const NO_RETRIES = 0
-const FIRST = 0
-const TERMINAL_OUTCOMES: ReadonlySet<string> = new Set(['merged', 'parked', 'split', 'withdrawn'])
+const TERMINAL_OUTCOMES: ReadonlySet<string> = new Set([
+	'merged',
+	'parked',
+	'human-review',
+	'split',
+	'withdrawn',
+])
 
 // The skip follows the declared order alone: an issue `run:add` put in was
 // asked for on its own, so its failure skips nothing and a declared failure does not skip it.
@@ -23,7 +28,8 @@ function is_declared(carry: RunCarry, issue: string): boolean {
 
 // An issue `run:add` put in that is already in flight holds nothing up: it was
 // asked for on its own, so the declared item behind it — an epic whose children fill the free lanes —
-// is offered beside it. A declared issue in flight still holds the ones declared after it.
+// is offered beside it. A declared issue in flight still holds the ones declared after it. When every
+// one left is such an issue in flight, nothing is named and the pool fills the free lanes (joshuafolkken/kit#6883).
 function is_held(carry: RunCarry, in_flight: ReadonlyArray<string>, issue: number): boolean {
 	return !in_flight.includes(String(issue)) || is_declared(carry, String(issue))
 }
@@ -31,7 +37,7 @@ function is_held(carry: RunCarry, in_flight: ReadonlyArray<string>, issue: numbe
 function next_of(carry: RunCarry, in_flight: ReadonlyArray<string>): number | undefined {
 	const remaining = run_carry.remaining_of(carry) ?? []
 
-	return remaining.find((issue) => is_held(carry, in_flight, issue)) ?? remaining[FIRST]
+	return remaining.find((issue) => is_held(carry, in_flight, issue))
 }
 
 // The declared issue `issue` starts after while the declared order holds it: the one declared just
@@ -189,6 +195,7 @@ function own_carried(
 }
 
 export const backlog_drive_named = {
+	is_declared,
 	next_of,
 	offer,
 	held_after,

package/scripts/backlog/backlog-drive-offer-argv.ts

@@ -1,16 +1,24 @@
 import type { RunCarry } from '#scripts/run/carry/run-carry'
 import type { DriveState } from './backlog-drive'
+import { backlog_drive_park_triage } from './backlog-drive-park-triage'
 import { backlog_offer_exclude } from './backlog-offer-exclude'
 
 // **A child in flight is never offered**. A lane child merges its own PR and
 // drops `in-progress` before GitHub closes the issue and before the loop collects it, so `backlog:next`
 // can offer it again; launching it then is refused by its still-open lane and handed to an AI session.
+// A park owing the parent triage still counts as running, so an empty pool reads as `blocked`, not the
+// drain that would owe the run's retrospective before the triage (joshuafolkken/kit#6871).
+function running_of(state: DriveState): number {
+	return state.in_flight.length + (backlog_drive_park_triage.is_owed(state) ? 1 : 0)
+}
+
 function offer_argv(
 	state: DriveState,
 	carry: RunCarry,
 	forwarded: ReadonlyArray<string>,
 ): ReadonlyArray<string> {
-	const exclude = backlog_offer_exclude.exclude_of(state.exclude, state.in_flight)
+	const settled = [...state.exclude, ...(state.waiting ?? [])]
+	const exclude = backlog_offer_exclude.exclude_of(settled, state.in_flight)
 
 	return [
 		'backlog:offer',
@@ -22,7 +30,7 @@ function offer_argv(
 		'--merged',
 		String(carry.merged),
 		'--running',
-		String(state.in_flight.length),
+		String(running_of(state)),
 		'--retries',
 		String(state.retries),
 		...backlog_offer_exclude.exclude_argv(exclude),