@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/scripts/rules/stop-rules.ts

@@ -4,6 +4,7 @@ import { filing_offer } from './filing-offer'
 import { issue_citation } from './issue-citation'
 import { lane_background } from './lane-background'
 import { reply_language } from './reply-language'
+import { stop_decision, type StopDecision } from './stop-decision'
 
 // The stop-time rules, delivered on the `Stop` hook.
 //
@@ -19,11 +20,14 @@ import { reply_language } from './reply-language'
 // permission envelope. The stop guard is a second *entry* on the one foundation, exactly as
 // `pretool-guard` is one — not a second copy of the plumbing.
 //
-// **Every rule refuses**. Missing the stop notification or leaving a hold
-// on a clean tree costs a person a silent wait or a trampled tree; a bare `#N` in the reply reaches
-// the person watching but not the model that could fix it, so it too blocks — `{"decision":"block"}`
-// is the one channel a `Stop` hook has to the model, and `stop_hook_active` caps a false positive at a
-// single wasted turn. The detection is tightened to match (`issue-citation.ts`, `filing-offer.ts`).
+// **A rule whose answer is fixed acts; only a rule that needs judgement refuses** (joshuafolkken/kit#3919).
+// The stop notification, the hold release and the citation lines are each one mechanical operation the
+// hook can run itself, so they come back as `actions` and the stop goes through: a refusal is a whole
+// model turn spent re-reading the context to run a command the hook already knew. `stop-actions.ts`
+// runs them, and only an action that fails falls back to its refusal. The rest — the reply's language,
+// an unattended filing offer, a lane's index request or running task, a headless parent's wait — need
+// the model, so they still block with `{"decision":"block"}`, the one channel a `Stop` hook has to it;
+// `stop_hook_active` caps a false positive at a single wasted turn.
 
 const SWITCH_ENV_KEY = 'JOSH_STOP_GUARD'
 const BLOCK_DECISION = 'block'
@@ -40,14 +44,22 @@ type StopPayload = z.infer<typeof stop_payload_schema>
 
 // What one stop looks like to the rules, computed once by the CLI from the payload and the world.
 interface StopContext {
-	// The `run:hold` record for this working tree is still in place (`held` or `stale`).
-	hold_present: boolean
+	// The Issue the `run:hold` record for this working tree names (`held` or `stale`) — `new` for an
+	// unnumbered entry — or `undefined` when no record is in place.
+	hold_issue: string | undefined
+	// That record is this session's own run's, or its owner cannot be told (`run-hold-session.ts`). A
+	// hold another run took is that run's pause to announce and release, never this session's.
+	hold_owned: boolean
+	// The person opened this turn with a question: the reply answers someone at the session, not a
+	// pause waiting on them (`stop-decision.ts` → `is_question`).
+	answers_question: boolean
 	// `git status --porcelain` came back empty.
 	tree_clean: boolean
 	// That record carries a `prrun` stop mark: the run stopped at a green pull
 	// request and keeps the hold over a clean tree on purpose, so a person can look before it merges.
 	prrun_stopped: boolean
-	// A `confirmation` notify is on this run's transcript tail.
+	// A `confirmation` notify is on this run's transcript tail, or the hook's own send is recorded on the
+	// hold since the pause began (`run-hold-session.ts` → `is_notified_since`).
 	notified: boolean
 	// The turn's session-facing reply text.
 	message: string
@@ -56,7 +68,8 @@ interface StopContext {
 	// This stop already forced a continuation earlier in the prompt — the loop-breaker Claude Code
 	// documents, so a run that will not comply is not blocked forever.
 	stop_hook_active: boolean
-	// A pre-gate cut record is in place for this work tree. A dispatched lane child ends its turn at
+	// This turn ended at a cut — its record is in place, or this turn relaunched the successor that may
+	// already have cleared it (`stop-guard.ts` → `is_cut_stop`). A dispatched lane child ends its turn at
 	// the cut holding the tree by design and hands off to a fresh process (`pre-gate-cut.md`), so that
 	// turn-end is an automatic continuation, not the person-waiting pause the block rules are for.
 	cut_pending: boolean
@@ -90,15 +103,26 @@ interface StopContext {
 	backlog_parent: boolean
 }
 
+// The operations the hook runs itself instead of refusing — each carries what it acts on.
+type StopAction =
+	| { kind: 'notify'; issue: string; message: string; decision: StopDecision }
+	| { kind: 'release'; issue: string }
+	| { kind: 'cite'; references: ReadonlyArray<string> }
+
+// `reason` refuses the stop; otherwise `actions` run, and `blocks_on_failure` says whether a failed one
+// falls back to its refusal — never past the loop-breaker.
 interface StopOutcome {
 	reason: string | undefined
+	actions: ReadonlyArray<StopAction>
+	blocks_on_failure: boolean
 }
 
-const NO_OUTCOME: StopOutcome = { reason: undefined }
+const NO_OUTCOME: StopOutcome = { reason: undefined, actions: [], blocks_on_failure: false }
 
 // **A mid-workflow stop is announced off-screen before it happens.** `CLAUDE.md` → "Mid-workflow stop
 // notification" requires the `confirmation` Telegram before any pause; the hold is what says a run is
-// mid-workflow, and the transcript is what says the notify was sent.
+// mid-workflow, and the transcript is what says the notify was sent. The hook sends it; this reason is
+// only the fallback for a send that failed.
 const STOP_NOTIFY_REASON =
 	'⛔ mid-workflow stop notification: this working tree is still held by a run and no `confirmation` ' +
 	'Telegram was sent this turn. Send ' +
@@ -109,13 +133,14 @@ const STOP_NOTIFY_REASON =
 // **A clean tree that still holds is a tree the next run will trample.** `working-tree-hold.md`: a stop that
 // leaves the tree clean releases the hold; a `halfrun` pre-commit stop and a `needs-human-review` stop
 // keep it because their tree is dirty, which is why this row is silent whenever the tree is not clean.
+// The hook releases it; this reason is only the fallback for a release that failed.
 const HOLD_RELEASE_REASON =
 	'⛔ working-tree hold not released: this working tree is clean but its `run:hold` record is still in ' +
 	'place. Release it with `pnpm josh run:release <N>` (bare for a `new` entry; ' +
 	'`working-tree-hold.md`), then confirm in one line that it was released — do not repeat your ' +
 	'previous reply.'
 
-// **A refusal that corrects rather than advises**. The bare `#N` is already
+// **The fallback when the hook could not print the citation lines itself**. The bare `#N` is already
 // on screen and the hook cannot unsay it, so the reason does the one thing that helps the *next* reply:
 // it names the numbers it detected and hands over the exact `issue:cite` call that prints the
 // paste-ready lines, then asks for the corrected citation lines alone — not the whole reply reissued.
@@ -246,42 +271,52 @@ function needs_filing(context: StopContext): boolean {
 //
 // **A lane handed to the detached ship stands them down too**: the hold now
 // belongs to the supervisor driving the merge, and the person hears from that supervisor's own notify.
+//
+// **Another run's hold stands them down as well**: the pause and the claim are that run's.
 function is_held_idle(context: StopContext): boolean {
-	return context.hold_present && !context.agent_pending && !context.handed_off
+	if (context.hold_issue === undefined || !context.hold_owned) return false
+
+	return !context.agent_pending && !context.handed_off
 }
 
+// **A stop that answers the person's question is no pause** (joshuafolkken/kit#3961): they are reading
+// the reply where it was written, whatever the tree's hold says.
 function needs_notify(context: StopContext): boolean {
-	return is_held_idle(context) && !context.notified
+	return is_held_idle(context) && !context.notified && !context.answers_question
 }
 
-function needs_release(context: StopContext): boolean {
-	return is_held_idle(context) && context.tree_clean && !context.prrun_stopped
+// The notify a stop owes but cannot send: its reply names no decision to announce.
+function needs_decision(context: StopContext): boolean {
+	return needs_notify(context) && stop_decision.decision_of(context.message) === undefined
 }
 
-function citation_reason(context: StopContext): string | undefined {
-	const references = issue_citation.unquoted_references(context.message, context.prompt)
-	if (references.length === 0) return undefined
-
-	return build_citation_reason(references)
+function needs_release(context: StopContext): boolean {
+	return is_held_idle(context) && context.tree_clean && !context.prrun_stopped
 }
 
-// The two rules on how a reply is written. **A headless agent's reply has no reader**:
-// its text lands in a stream-json log, so correcting its citations or its
-// language costs a turn and reaches nobody. The artifacts a person does read — a Telegram, an Issue, a
-// pull request — are held to the same rules by their own guards, not here.
-function wording_reason(context: StopContext): string | undefined {
-	if (context.headless_agent) return undefined
+// The bare references the citation lines are printed for. **A headless agent's reply has no reader**:
+// its text lands in a stream-json log, so correcting its citations or its language costs a turn and
+// reaches nobody. The artifacts a person does read — a Telegram, an Issue, a pull request — are held
+// to the same rules by their own guards, not here.
+function bare_references(context: StopContext): ReadonlyArray<string> {
+	if (context.headless_agent) return []
 
-	return citation_reason(context) ?? language_reason(context)
+	return issue_citation.unquoted_references(context.message, context.prompt)
 }
 
-// The three rules that read the reply itself, filing offer first and the language last. A drifted reply
+// The two rules that read the reply and need the model, the filing offer first. A drifted reply
 // refused for another reason is not rewritten, but the drift still ends: `block_envelope` appends the
 // session-language note to every refusal, so the turn it continues is written in the session language.
 function reply_reason(context: StopContext): string | undefined {
 	if (needs_filing(context)) return FILING_OFFER_REASON
+	if (context.headless_agent) return undefined
 
-	return wording_reason(context)
+	return language_reason(context)
+}
+
+// Sent back once; past the loop-breaker the run has said nothing is awaited, and nothing is sent.
+function decision_reason(context: StopContext): string | undefined {
+	return needs_decision(context) ? stop_decision.DECISION_REASON : undefined
 }
 
 // The headless wait holds past the loop-breaker until the spin bound is reached.
@@ -306,24 +341,56 @@ function needs_background_wait(context: StopContext): boolean {
 	return context.lane_child && context.background_pending
 }
 
-// The two hold rules, notify ahead of release — behind the lane index route
-// and the lane background wait, since the notify they would ask for announces
-// a pause the run has no reason to take.
-function hold_reason(context: StopContext): string | undefined {
+// The two lane rules that mean the run is not pausing at all — ahead of every action, since the notify
+// would announce a pause the run has no reason to take.
+function lane_reason(context: StopContext): string | undefined {
 	if (needs_index_route(context)) return LANE_INDEX_REASON
 	if (needs_background_wait(context)) return lane_background.LANE_BACKGROUND_STOP_REASON
-	if (needs_notify(context)) return STOP_NOTIFY_REASON
-	if (needs_release(context)) return HOLD_RELEASE_REASON
 
 	return undefined
 }
 
-// First-wins across every rule. Two things stand every rule down: `stop_hook_active` (the
-// loop-breaker, so a run that already got one continuation this prompt may stop) and a pre-gate cut in
-// flight (a lane child's automatic turn-end, not a person-waiting pause). The two hold rules keep their
-// order ahead of the reply rules, so a stop that both still owes its notify and holds a bare `#N` still
-// reports the notify first; the filing offer goes ahead of the citation, since the filing it forces
-// produces the citation the reply then needs.
+// The refusals that need the model: the lane rules alone, else the reply's own and the decision
+// together. **Joined, since the loop-breaker grants one continuation**: a decision refusal queued behind
+// a language or filing refusal would never be sent, and its stop would pass with no notify.
+function model_reason(context: StopContext): string | undefined {
+	const lane = lane_reason(context)
+	if (lane !== undefined) return lane
+
+	const reasons = [reply_reason(context), decision_reason(context)].filter(
+		(reason) => reason !== undefined,
+	)
+
+	return reasons.length === 0 ? undefined : reasons.join('\n\n')
+}
+
+// The notify carries the reply's own decision; a reply with none sends nothing (`needs_decision`).
+function notify_actions(context: StopContext, issue: string): Array<StopAction> {
+	const decision = stop_decision.decision_of(context.message)
+	if (decision === undefined || !needs_notify(context)) return []
+
+	return [{ kind: 'notify', issue, message: context.message, decision }]
+}
+
+function hold_actions(context: StopContext): Array<StopAction> {
+	const issue = context.hold_issue
+	if (issue === undefined) return []
+
+	const notify = notify_actions(context, issue)
+
+	return needs_release(context) ? [...notify, { kind: 'release', issue }] : notify
+}
+
+// The actions in the order they run: the notify ahead of the release that ends the hold it reports.
+function stop_actions(context: StopContext): ReadonlyArray<StopAction> {
+	const references = bare_references(context)
+	const cite: Array<StopAction> = references.length > 0 ? [{ kind: 'cite', references }] : []
+
+	return [...hold_actions(context), ...cite]
+}
+
+// First-wins across the refusals. `stop_hook_active` is the loop-breaker, so a run that already got one
+// continuation this prompt may stop; the lane rules go first, then the filing offer, then the language.
 //
 // **The headless wait comes first and outlasts `stop_hook_active` up to its spin bound**.
 // The loop-breaker exists so a person is not wedged behind a rule the run will not satisfy; a headless
@@ -334,18 +401,49 @@ function block_reason(context: StopContext): string | undefined {
 	if (is_headless_held(context)) return HEADLESS_WAIT_REASON
 	if (context.stop_hook_active || context.cut_pending) return undefined
 
-	return hold_reason(context) ?? reply_reason(context)
+	return model_reason(context)
+}
+
+// **The actions run only on the stop that goes through**, so a refused stop never notifies a pause its
+// continuation then cancels, while the continuation's own stop, past the loop-breaker, still runs them
+// and a failure there no longer refuses. A lane child still waiting on its own work runs none, and a
+// pre-gate cut in flight stands everything but the headless wait down: it is a lane child's automatic
+// turn-end, not a person-waiting pause.
+function runs_actions(context: StopContext, reason: string | undefined): boolean {
+	return reason === undefined && !context.cut_pending && lane_reason(context) === undefined
 }
 
 function stop_outcome(context: StopContext): StopOutcome {
-	return { reason: block_reason(context) }
+	const reason = block_reason(context)
+	if (!runs_actions(context, reason)) return { ...NO_OUTCOME, reason }
+
+	const actions = stop_actions(context)
+	if (actions.length === 0) return NO_OUTCOME
+
+	return { reason, actions, blocks_on_failure: !context.stop_hook_active }
+}
+
+// The refusal an action falls back to when the hook could not run it.
+function fallback_reason(action: StopAction): string {
+	if (action.kind === 'notify') return STOP_NOTIFY_REASON
+	if (action.kind === 'release') return HOLD_RELEASE_REASON
+
+	return build_citation_reason(action.references)
 }
 
 // The documented shape a `Stop` hook blocks with: `reason` is fed back to Claude, which then continues
 // instead of stopping. Plain stdout is not it — only this envelope holds the stop. Every reason leaves
 // with the session-language note, so no rule can hand the model an English-only turn.
-function block_envelope(reason: string, lang: string): string {
-	return JSON.stringify({ decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` })
+// `notice` is what the hook already did on this stop, shown to the person alongside.
+function block_envelope(reason: string, lang: string, notice?: string): string {
+	const refusal = { decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` }
+
+	return JSON.stringify(notice === undefined ? refusal : { ...refusal, systemMessage: notice })
+}
+
+// The shape a `Stop` hook shows the person a line in without holding the stop: `systemMessage` alone.
+function notice_envelope(notice: string): string {
+	return JSON.stringify({ systemMessage: notice })
 }
 
 function parse_stop_payload(raw_payload: string): StopPayload | undefined {
@@ -371,10 +469,12 @@ const stop_rules = {
 	block_envelope,
 	build_language_reason,
 	count_headless_refusals,
+	fallback_reason,
 	is_enabled,
+	notice_envelope,
 	parse_stop_payload,
 	stop_outcome,
 }
 
-export type { StopContext, StopOutcome }
+export type { StopAction, StopContext, StopOutcome }
 export { stop_rules }

package/scripts/rules/tail-commands.ts

@@ -30,6 +30,20 @@ function prior_bash_commands(tail: string): ReadonlyArray<string> {
 	return tail.split('\n').flatMap((line) => bash_commands_of(line))
 }
 
-const tail_commands = { is_bash_use, prior_bash_commands }
+// **Whether a call `is_call` names answered with the `token` line** — the call and its own result
+// paired off parsed blocks, so a transcript that merely quotes the command or the token does not
+// count. An unreadable text reads as no answer.
+function answered(text: string, is_call: (command: string) => boolean, token: string): boolean {
+	const blocks = time_transcript_line.parse_text(text).flatMap((line) => line.blocks)
+	const call_ids = new Set(
+		blocks
+			.filter((block) => is_call(time_shell.bash_command(block.input)))
+			.map((block) => block.id),
+	)
+
+	return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token))
+}
+
+const tail_commands = { answered, is_bash_use, prior_bash_commands }
 
 export { tail_commands }

package/scripts/run/board/run-board-cli.ts

@@ -2,6 +2,7 @@
 import { setTimeout as sleep } from 'node:timers/promises'
 import { fileURLToPath } from 'node:url'
 import { styleText } from 'node:util'
+import { core_budget } from '#scripts/gate/core-budget'
 import { machine_capacity } from '#scripts/gate/machine-capacity'
 import { telegram_notify } from '#scripts/notify/telegram-notify'
 import { run_progress } from '#scripts/run/progress/run-progress'
@@ -51,6 +52,7 @@ const LIVE_PORTS: BoardPorts = {
 	read_plan: async (scope) => await run_board_plan.read_plan(scope),
 	read_local: run_board_read.read_local,
 	read_machine: machine_capacity.read_sample,
+	read_waits: () => core_budget.budget_waits(),
 	read_usage: run_board_usage_read.usage_reader(),
 	read_closed: async (issues) => await run_board_closed.read_all(issues),
 	read_thanks: async () => await run_board_thanks_read.read_thanks(),

package/scripts/run/board/run-board-closed.ts

@@ -18,10 +18,13 @@ interface ClosedIssue {
 	closed_ms: number | undefined
 	// Closed by a merged pull request, rather than closed by hand.
 	is_merged: boolean
+	// Closed as not planned — withdrawn rather than finished (joshuafolkken/kit#3958).
+	is_not_planned: boolean
 }
 
-const CLOSED_FIELDS = 'title,state,closedAt,labels'
+const CLOSED_FIELDS = 'title,state,stateReason,closedAt,labels'
 const CLOSED_STATE = 'CLOSED'
+const NOT_PLANNED_REASON = 'not_planned'
 const STILL_OPEN = 'open' as const
 
 // What one issue answered: closed, still open, or `undefined` when it could not be read.
@@ -41,6 +44,7 @@ const READ_CONCURRENCY = 4
 const closed_schema = z.looseObject({
 	title: z.string(),
 	state: z.string(),
+	stateReason: z.string().nullish(),
 	closedAt: z.string().nullish(),
 	labels: z.array(issue_label_schema).default([]),
 })
@@ -69,7 +73,9 @@ async function read_closed(issue: number): Promise<ClosedRead> {
 
 	const labels = view.labels.map((label) => label.name)
 
-	return { title: view.title, labels, closed_ms: closed_ms_of(view), is_merged }
+	const is_not_planned = view.stateReason === NOT_PLANNED_REASON
+
+	return { title: view.title, labels, closed_ms: closed_ms_of(view), is_merged, is_not_planned }
 }
 
 async function read_all(

package/scripts/run/board/run-board-github.ts

@@ -73,12 +73,20 @@ function fold_plan(state: BoardState): BoardState {
 	}
 }
 
+// joshuafolkken/kit#3969: the planned issues whose open lane may be this run's though the stream never
+// saw it launched. An earlier run's lane is not, so its issue waits until this run launches it.
+function lanes_in_run(plan: BoardPlan, local: LocalRead): ReadonlySet<number> {
+	const earlier = new Set(local.earlier_lanes?.map(Number))
+
+	return new Set([...run_board_layout.numbers_of(plan)].filter((issue) => !earlier.has(issue)))
+}
+
 function statuses_for(
 	state: BoardState,
 	plan: BoardPlan,
 	local: LocalRead,
 ): ReadonlyMap<number, ItemStatus> {
-	const in_run = run_board_layout.numbers_of(plan)
+	const in_run = lanes_in_run(plan, local)
 	const stopped = run_board_idle.stopped_of(state.idle_since, state.read_ms)
 
 	return run_board_status.statuses_of(local.events, local.lanes, in_run, stopped)

package/scripts/run/board/run-board-header.ts

@@ -1,5 +1,6 @@
 import { styleText } from 'node:util'
 import { backlog_budget } from '#scripts/backlog/backlog-budget'
+import type { BudgetWait } from '#scripts/gate/core-wait'
 import { run_board_fit } from './run-board-fit'
 import { run_board_fresh } from './run-board-fresh'
 import { run_board_labels } from './run-board-labels'
@@ -65,6 +66,8 @@ interface BoardHeader {
 	machine: MachineGauges | undefined
 	// Each running lane's CPU and memory, `undefined` where none could be read.
 	usages?: LaneUsages | undefined
+	// The claims waiting in the machine-wide core budget (`run-board-render-waits.ts`).
+	budget_waits?: ReadonlyArray<BudgetWait> | undefined
 	// How long each phase usually takes; a running row's phase time is colored against it.
 	usual?: UsualTimes | undefined
 	// The spinner's frame a running run and a running row turn, `undefined` where the output is not a
@@ -107,7 +110,7 @@ function count_state(rows: ReadonlyArray<BoardRow>, state: BoardRow['state']): n
 function counts_of(layout: BoardLayout): BoardCounts {
 	const total = run_board_layout.rows_of(layout).length
 	const parked = count_state(layout.active, 'parked')
-	const settled = count_state(layout.active, 'merged') + parked + count_state(layout.active, 'done')
+	const settled = layout.active.filter((row) => run_board_layout.is_settled(row.state)).length
 	const running = count_state(layout.active, 'running')
 
 	return { total, settled, parked, running, remaining: total - settled - running }

package/scripts/run/board/run-board-labels.ts

@@ -43,6 +43,7 @@ const WORDS = {
 	merged: 'merged',
 	parked: 'parked',
 	done: 'done',
+	withdrawn: 'withdrawn',
 	in_progress: 'running',
 	stopped: 'stopped',
 	waiting: 'waiting',
@@ -104,6 +105,7 @@ const STATE_ICONS: Readonly<Record<ItemState, string>> = {
 	waiting: '⏳',
 	human: '🙋',
 	stopped: '🛑',
+	withdrawn: '🚫',
 }
 
 // The blocking edge, chosen on the same rule: ⛓ is a text symbol.

package/scripts/run/board/run-board-layout.ts

@@ -82,7 +82,7 @@ interface Drawn extends Overlay {
 	reason_of: ReasonOf | undefined
 }
 
-const SETTLED_STATES: ReadonlySet<ItemState> = new Set(['merged', 'parked', 'done'])
+const SETTLED_STATES: ReadonlySet<ItemState> = new Set(['merged', 'parked', 'done', 'withdrawn'])
 
 function is_settled(state: ItemState): boolean {
 	return SETTLED_STATES.has(state)

package/scripts/run/board/run-board-read.ts

@@ -37,9 +37,15 @@ interface LocalRead {
 	// The open lanes no child is working in at this read (`lane-spent.ts`); one is drawn stopped once it
 	// has stayed so (`run-board-idle.ts`).
 	idle_lanes?: ReadonlyArray<string> | undefined
+	// The open lanes that last took a child before the run started — an earlier run's, until this run
+	// dispatches into one again.
+	earlier_lanes?: ReadonlyArray<string> | undefined
 	// How many more lanes the limit allows beside the live ones, as `lane:limit` counts them;
 	// `undefined` where the limit could not be read, so nothing is said about it.
 	free_lanes?: number | undefined
+	// The issues whose lanes hold a place under the limit (`backlog-occupied.ts`), named beside a row
+	// that waits for a free lane.
+	occupied_lanes?: ReadonlyArray<string> | undefined
 	// How long each phase usually takes, from the repository's lane ledger.
 	usual?: UsualTimes | undefined
 }
@@ -81,6 +87,13 @@ function sources_of(
 	}
 }
 
+// joshuafolkken/kit#3969: a lane whose last dispatch is unknown is not called earlier.
+function earlier_lanes(lanes: ReadonlyArray<LaneInfo>, started_ms: number): Array<string> {
+	return lanes
+		.filter((lane) => lane.dispatched_ms !== undefined && lane.dispatched_ms < started_ms)
+		.map((lane) => lane.issue)
+}
+
 // `undefined` when no run has started here.
 async function read_local(): Promise<LocalRead | undefined> {
 	const repository = await run_carry.repository_directory()
@@ -90,6 +103,7 @@ async function read_local(): Promise<LocalRead | undefined> {
 
 	const events = run_event_stream.read_events(run_event_stream.target_of(repository))
 	const lanes = await lane_registry.list_lanes()
+	const occupied = await backlog_ready.occupied_lanes(lanes)
 
 	return {
 		started_ms: span.started_ms,
@@ -101,7 +115,9 @@ async function read_local(): Promise<LocalRead | undefined> {
 		is_stranded: run_stranded_detect.is_stranded_at(repository),
 		operations: run_board_operation_read.read(sources_of(repository, lanes, transcript)),
 		idle_lanes: lane_spent.idle_lanes(lanes),
+		earlier_lanes: earlier_lanes(lanes, span.started_ms),
 		free_lanes: await backlog_ready.free_lanes_beside(lanes),
+		occupied_lanes: occupied.map((lane) => lane.issue),
 		usual: run_board_usual.read(repository),
 	}
 }

package/scripts/run/board/run-board-reason.ts

@@ -36,6 +36,9 @@ interface ReasonRead extends Overlay {
 	events: ReadonlyArray<RunEvent>
 	// How many more lanes the limit allows; `undefined` where it could not be read.
 	free_lanes: number | undefined
+	// The issues whose lanes fill the limit, named after `no free lane` so a lane an earlier run left
+	// behind shows on the row it holds back.
+	occupied_lanes?: ReadonlyArray<string> | undefined
 	// A stopped run opens no lane, so a stage its stream ends on is not one any lane is at.
 	is_stopped: boolean
 }
@@ -92,6 +95,12 @@ function overlap_of(child: EpicChild, read: ReasonRead, pool: Pool): string | un
 		: `${WORDS.overlaps} ${String(clash.holder)} (${clash.path})`
 }
 
+function no_lane_of(occupied: ReadonlyArray<string> = []): string {
+	if (occupied.length === 0) return WORDS.no_lane
+
+	return `${WORDS.no_lane} — ${occupied.join(' ')}`
+}
+
 // A candidate nothing blocks, in the order `backlog:next` answers: the pool held for a judgment, then
 // a path a running issue declares, then a pool with no lane left.
 function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): string | undefined {
@@ -101,7 +110,7 @@ function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): string | un
 
 	if (overlap !== undefined) return overlap
 
-	return read.free_lanes === NO_FREE_LANES ? WORDS.no_lane : undefined
+	return read.free_lanes === NO_FREE_LANES ? no_lane_of(read.occupied_lanes) : undefined
 }
 
 function wait_of(child: EpicChild, read: ReasonRead, pool: Pool): RowReason | undefined {

package/scripts/run/board/run-board-render-legend.ts

@@ -32,6 +32,7 @@ const STATE_LEGEND: ReadonlyArray<readonly [ItemState, keyof Words]> = [
 	['merged', 'merged'],
 	['parked', 'parked'],
 	['done', 'done'],
+	['withdrawn', 'withdrawn'],
 	['running', 'in_progress'],
 	['stopped', 'stopped'],
 	['waiting', 'waiting'],

package/scripts/run/board/run-board-render-slot.ts

@@ -9,7 +9,7 @@ import { run_board_usage_text } from './run-board-usage-text'
 // blanks on any other row.
 
 const { finish_of, text_of } = run_board_usage_text
-const FINISHED: ReadonlySet<ItemState> = new Set(['merged', 'done'])
+const FINISHED: ReadonlySet<ItemState> = new Set(['merged', 'done', 'withdrawn'])
 const BLANK = ' '
 
 // What one frame's column is drawn from: each lane's usage, and the running rows the frame draws —

package/scripts/run/board/run-board-render-waits.ts

@@ -0,0 +1,41 @@
+import { core_wait, type BudgetWait } from '#scripts/gate/core-wait'
+
+// The claims waiting in the machine-wide core budget, under the header (joshuafolkken/kit#3943): a lane
+// held back by memory pressure otherwise reads the same as one that is stuck. Each line names the
+// command, the lane it runs in — the main checkout where none, and another repository's checkout by
+// name, unlinked — how long it has waited, and why.
+
+const MS_PER_SECOND = 1000
+// 🚧 rather than ⏳, which a waiting row already draws, or 🚦, the gate stage's; an emoji a terminal
+// draws two columns wide.
+const BUDGET_ICON = '🚧'
+const GAP = '  '
+const MAIN_CHECKOUT = 'main'
+
+function place_text(wait: BudgetWait, link: (reference: string) => string): string {
+	if (wait.elsewhere !== undefined) return wait.elsewhere
+
+	return wait.lane === undefined ? MAIN_CHECKOUT : link(wait.lane)
+}
+
+function wait_text(wait: BudgetWait, link: (reference: string) => string): string {
+	const lane = place_text(wait, link)
+	const seconds = `${String(Math.round(wait.waited_ms / MS_PER_SECOND))}s`
+	const parts = [wait.command ?? 'a step', lane, seconds, core_wait.REASON_TEXT[wait.reason]]
+
+	return `${BUDGET_ICON} ${parts.join(GAP)}`
+}
+
+// Nothing is drawn while no claim waits.
+function wait_lines(
+	waits: ReadonlyArray<BudgetWait> | undefined,
+	link: (reference: string) => string,
+): Array<string> {
+	if (waits === undefined || waits.length === 0) return []
+
+	return ['', ...waits.map((wait) => wait_text(wait, link))]
+}
+
+const run_board_render_waits = { BUDGET_ICON, wait_lines }
+
+export { run_board_render_waits }

package/scripts/run/board/run-board-render.ts

@@ -24,6 +24,7 @@ import { run_board_render_slot, type UsageSlot } from './run-board-render-slot'
 import { run_board_render_tail } from './run-board-render-tail'
 import { run_board_render_thanks } from './run-board-render-thanks'
 import { run_board_render_title } from './run-board-render-title'
+import { run_board_render_waits } from './run-board-render-waits'
 import { run_board_row_yield } from './run-board-row-yield'
 import type { Thanks } from './run-board-thanks-csv'
 
@@ -388,7 +389,11 @@ function bounded(parts: FrameParts, bounds: FrameBounds): Array<string> {
 
 function render(view: BoardView): Array<string> {
 	const { header, notes } = view
-	const above = [...run_board_header.header_lines(header), ...resume_lines(view.resume)]
+	const above = [
+		...run_board_header.header_lines(header),
+		...run_board_render_waits.wait_lines(header.budget_waits, header.link),
+		...resume_lines(view.resume),
+	]
 	const parts = {
 		above,
 		plan: plan_sections(header, view.size),

package/scripts/run/board/run-board-row-yield.ts

@@ -9,6 +9,7 @@ import type { ItemState } from './run-board-status'
 const YIELD_STAGES: Readonly<Record<ItemState, YieldStage>> = {
 	merged: 'finished',
 	done: 'finished',
+	withdrawn: 'finished',
 	waiting: 'pending',
 	human: 'pending',
 	parked: 'parked',