@joshuafolkken/kit 1.2116.0 → 1.3000.0

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

@@ -1,3 +1,4 @@
+import { run_board_earlier } from './run-board-earlier'
 import {
 	run_board_fit,
 	type FrameParts,
@@ -25,14 +26,18 @@ import { run_board_render_found } from './run-board-render-found'
 import { run_board_render_icon } from './run-board-render-icon'
 import { run_board_render_lanes, type LaneCells } from './run-board-render-lanes'
 import { run_board_render_lead } from './run-board-render-lead'
+import { run_board_render_none } from './run-board-render-none'
 import { run_board_render_notes } from './run-board-render-notes'
 import { run_board_render_processes } from './run-board-render-processes'
+import { run_board_render_quota } from './run-board-render-quota'
 import { run_board_render_section } from './run-board-render-section'
 import { run_board_render_tail } from './run-board-render-tail'
+import { run_board_render_throughput } from './run-board-render-throughput'
 import { run_board_render_time } from './run-board-render-time'
 import { run_board_render_title, type RowCut, type RowFit } from './run-board-render-title'
 import { run_board_row_yield } from './run-board-row-yield'
 import type { Thanks } from './run-board-thanks-csv'
+import type { ThroughputRow } from './run-board-throughput'
 
 // The whole `run:board` screen as lines — pure, so what a person sees is tested apart from the
 // terminal. The header says where the run is; under it the run's own rows, then the ones waiting on a
@@ -41,19 +46,19 @@ import type { Thanks } from './run-board-thanks-csv'
 // at the foot names the symbols, so a row carries only what differs between rows. Every word is
 // English whatever the session language: one set of words reads the same on every board.
 
-const { FILED_KIND_ICONS, KIND_BLANK, STATE_ICONS, WAITS_ICON, WORDS, clock_of } = run_board_labels
+const { FILED_KIND_ICONS, KIND_BLANK, STATE_ICONS, WAITS_ICON, WORDS } = run_board_labels
 const { time_of, time_width } = run_board_render_time
 const { state_icon } = run_board_render_icon
 const { NOTE_LIMIT } = run_board_render_notes
 const { lane_cells_of, lanes_section, number_text } = run_board_render_lanes
 const { indent_of, lead_of: lane_lead_of, running_fresh } = run_board_render_lead
-const { ELLIPSIS, TITLE_LIMIT, WHOLE, columns_cut, fitted, reason_text, row_overrun, title_of } =
+const { ELLIPSIS, TITLE_LIMIT, WHOLE, fitted, fitted_limit, row_overrun, title_of } =
 	run_board_render_title
 const { width_of } = run_board_fit
 const { padded } = run_board_fresh
-const { condition_of, waits_of } = run_board_render_condition
+const { condition_of, tail_of, waits_of } = run_board_render_condition
 const { legend_lines, resume_lines, thanks_part } = run_board_render_foot
-const { ROW_INDENT, done_section, keyed, plan_section } = run_board_render_section
+const { ROW_INDENT, done_section, kept_section, keyed, plan_section } = run_board_render_section
 const GAP = '  '
 // The fewest columns a done row's end is cut to before its title gives them up: its minutes and a cut
 // start of what follows.
@@ -71,11 +76,10 @@ interface BoardView extends FrameBounds {
 	// The reviewers thanked above the legend, and the link a name with a page is wrapped in.
 	thanks?: Thanks | undefined
 	link?: Link | undefined
+	// The 📈 throughput rows; none draws no section.
+	throughput?: ReadonlyArray<ThroughputRow> | undefined
 }
 
-// When the reads off this machine last failed, and why.
-type ReadFailure = Pick<BoardHeader, 'read_error' | 'read_failed_ms'>
-
 // What every row of one frame is drawn with: the header, how wide the time column is, so a
 // `2°05′30″` and a `42″` end in the same column, and the lane cells after a row's lead where its
 // section draws them.
@@ -173,13 +177,15 @@ function head_text(row: BoardRow, frame: RowFrame): string {
 	return joined([lead, time])
 }
 
-function same(reference: string): string {
-	return reference
+// What a row draws after its title: its tail, an earlier run's row's led by 🧳 — so an earlier run's row
+// draws one even where its tail is empty.
+function drawn_tail(row: BoardRow, frame: RowFrame): Array<string> {
+	return run_board_earlier.earlier_marked(row, run_board_render_tail.tail_of(row, frame.header))
 }
 
-// A row up to what was filed during it: its head, then its tail where it draws one.
+// A row up to what was filed during it: its head, then what it draws after its title.
 function tailed_head(row: BoardRow, frame: RowFrame): string {
-	return joined([head_text(row, frame), ...run_board_render_tail.tail_of(row, frame.header)])
+	return joined([head_text(row, frame), ...drawn_tail(row, frame)])
 }
 
 // The columns the pane leaves after `head` and its gap, where the frame is kept within one and the
@@ -190,28 +196,14 @@ function room_after(indent: string, head: string, frame: RowFrame): number | und
 	return frame.columns - width_of(`${indent}${head}${GAP}`)
 }
 
-// What was filed during a done row, in `room`: a pane too narrow for it cuts its end on an ellipsis
-// rather than the title, so the time column stays where every other row has it
-// (joshuafolkken/kit#4922). The cut text's references are left unlinked, so no hyperlink escape is cut
-// in two.
-function found_fitted(room: number | undefined, row: BoardRow, header: BoardHeader): string {
-	const found = run_board_render_found.found_text(row, header)
-
-	if (found === '' || room === undefined || width_of(found) <= room) return found
-
-	const unlinked = run_board_render_found.found_text(row, { ...header, link: same })
-
-	return columns_cut(unlinked, Math.max(1, room))
-}
-
 // Every row carries its state's icon, or the icon of what it waits on; a running row ends on its tail
 // (`run-board-render-tail.ts`), a done row on what was filed during it (`run-board-render-found.ts`),
 // and a row with nothing after its padded columns ends where its text does.
 function row_text(indent: string, row: BoardRow, frame: RowFrame): string {
-	const { header } = frame
+	const { header, reason_cut } = frame
 	const head = tailed_head(row, frame)
-	const found = found_fitted(room_after(indent, head, frame), row, header)
-	const notes = [waits_of(row, header, frame.is_conditioned), reason_text(row, frame.reason_cut)]
+	const found = run_board_render_found.found_fitted(room_after(indent, head, frame), row, header)
+	const notes = [waits_of(row, header, frame.is_conditioned), tail_of(row, reason_cut, header)]
 
 	return `${indent}${joined([head, found, ...notes]).trimEnd()}`
 }
@@ -240,15 +232,16 @@ function row_draw(
 // A row drawn with lane cells keeps its head on one line, its title giving up their columns where the
 // pane is narrow. A row that draws a tail keeps its whole line, giving up the columns its section's
 // rows give up together (joshuafolkken/kit#4226). A done row keeps its title's width and cuts the end of
-// what was filed during it instead (`found_fitted`), unless that end is squeezed out.
+// what was filed during it instead (`run-board-render-found.ts` found_fitted), unless that end is
+// squeezed out.
 function row_fit(indent: string, row: BoardRow, frame: RowFrame): RowFit {
-	const is_tailed = run_board_render_tail.tail_of(row, frame.header).length > 0
+	const is_tailed = drawn_tail(row, frame).length > 0
 
 	return {
 		is_line_kept: is_tailed || is_found_squeezed(indent, row, frame),
 		lead: frame.filed.has(row.number) ? FILED_LEAD.length : 0,
 		head: (cut) => `${indent}${head_text(row, { ...frame, ...cut })}`,
-		is_head_kept: frame.cells !== undefined,
+		is_head_kept: frame.is_lane_row === true,
 		shared: is_tailed ? frame.shared : undefined,
 	}
 }
@@ -335,18 +328,38 @@ function frame_of(
 }
 
 // The rows not yet started under one heading, in the order they are offered: a running batch starts
-// each once a lane and its paths are free, never wave by wave (joshuafolkken/kit#4137).
+// each once a lane and its paths are free, never wave by wave (joshuafolkken/kit#4137); kept at none.
 function queued_section(layout: BoardLayout, frame: RowFrame): Array<PlanSection> {
-	return plan_section(
-		`${STATE_ICONS.waiting} ${WORDS.queued}`,
-		layout.queued.flatMap((entry) => entry_lines(entry, { ...frame, is_conditioned: true })),
+	const lines = layout.queued.flatMap((entry) =>
+		entry_lines(entry, { ...frame, is_conditioned: true }),
 	)
+
+	return [kept_section(`${STATE_ICONS.waiting} ${WORDS.queued}`, lines)]
+}
+
+// The column the lane rows' titles end in as drawn, cut as `fitted` cuts them, where every rule ends
+// (joshuafolkken/kit#5520), kept within the pane; none without a lane row.
+function rule_width(rows: ReadonlyArray<BoardRow>, frame: RowFrame): number | undefined {
+	const ends = rows.map((row) => {
+		const fit = row_fit(indent_of(row), row, frame)
+		const draw = row_draw(indent_of(row), row, frame, fit)
+		const title_limit = fitted_limit(row, frame.columns, draw, fit) ?? TITLE_LIMIT
+
+		return width_of(`${indent_of(row)}${head_text(row, { ...frame, title_limit })}`)
+	})
+
+	if (ends.length === 0) return undefined
+
+	return Math.min(Math.max(...ends), frame.columns ?? Infinity)
 }
 
 // The rows above the findings: the run's own, the earlier run's lanes still holding a place, then the
 // ones waiting on a person's decision — a child parked on one and an untouched plan row alike
 // (joshuafolkken/kit#4099).
-function active_sections(layout: BoardLayout, frame: RowFrame): Array<PlanSection> {
+function active_sections(
+	layout: BoardLayout,
+	frame: RowFrame,
+): Pick<FrameParts, 'plan' | 'rule_width'> {
 	const people = run_board_layout.people_of(layout)
 	const lead = run_board_layout.lanes_drawn(layout)
 	const decision = `${STATE_ICONS.human} ${WORDS.decision}`
@@ -356,9 +369,13 @@ function active_sections(layout: BoardLayout, frame: RowFrame): Array<PlanSectio
 	const lanes = lanes_section(
 		lead.map((row) => row_line(indent_of(row), row, { ...lane_frame, shared })),
 		cells,
+		frame.header,
+		frame.columns,
 	)
 
-	return [...lanes, ...rows_section(decision, people, frame)]
+	const plan = [...lanes, ...rows_section(decision, people, frame)]
+
+	return { plan, rule_width: rule_width(lead, { ...lane_frame, shared }) }
 }
 
 // The plan's rest under the findings, the 🔗 waiting rows giving way before them.
@@ -366,7 +383,7 @@ function plan_parts(
 	header: BoardHeader,
 	notes: ReadonlyArray<BoardNote>,
 	size: TerminalSize | undefined,
-): Pick<FrameParts, 'below' | 'plan'> {
+): Pick<FrameParts, 'below' | 'plan' | 'rule_width'> {
 	const { layout } = header
 
 	if (layout === undefined) return { plan: [] }
@@ -377,7 +394,7 @@ function plan_parts(
 	const waiting = `${WAITS_ICON} ${WORDS.waiting}`
 
 	return {
-		plan: active_sections(layout, frame),
+		...active_sections(layout, frame),
 		below: [
 			...keyed('queued', queued_section(layout, frame)),
 			...keyed('waiting', rows_section(waiting, layout.unreached, conditioned, 'waiting')),
@@ -391,6 +408,8 @@ function render(view: BoardView): Array<string> {
 	const above = [...run_board_header.header_lines(header), ...resume_lines(view.resume)]
 	const parts = {
 		above,
+		throughput: run_board_render_throughput.throughput_part(view.throughput),
+		usage: run_board_render_quota.usage_part({ ...header, hold: header.quota_hold }),
 		...plan_parts(header, notes, view.size),
 		processes: run_board_render_processes.processes_part(header),
 		notes: run_board_render_notes.notes_part(notes, { ...header, columns: view.size?.columns }),
@@ -402,28 +421,11 @@ function render(view: BoardView): Array<string> {
 	return bounded(parts, view)
 }
 
-// No run read here — or the reads failed, which the line says, and why, in place of `no run`: a read
-// that failed cannot tell whether a run is there.
-function render_no_run(
-	now_ms: number,
-	bounds: FrameBounds = {},
-	failure: ReadFailure = {},
-): Array<string> {
-	const { read_failed_ms, read_error } = failure
-	const warning = run_board_header.warning_of(WORDS.read, read_failed_ms, read_error)
-	const said = warning === undefined ? WORDS.no_run : undefined
-	const parts = ['■ backlogrun', said, clock_of(now_ms), warning]
-	const above = [parts.filter((part) => part !== undefined).join(GAP)]
-	const notes = { head: [], lines: [], hidden: 0 }
-
-	return bounded({ above, plan: [], notes, legend: [], footer: bounds.footer ?? [] }, bounds)
-}
-
 const run_board_render = {
 	NOTE_LIMIT,
 	TITLE_LIMIT,
 	render,
-	render_no_run,
+	render_no_run: run_board_render_none.render_no_run,
 }
 
 export { run_board_render }

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

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

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

@@ -1,15 +1,22 @@
 import type { NamedPlan } from '#scripts/backlog/backlog-plan'
+import { run_carry_added, type CarryAddition } from '#scripts/run/carry/run-carry-added'
 import { run_invocation } from '#scripts/run/run-invocation'
+import { run_board_single } from './run-board-single'
 
 // Which plan a run covers, read off the invocation its carry record kept, so the board draws only what
 // the run was asked to do. The invocation is parsed through the grammar the run itself uses, into the
 // shape `backlog:plan` renders a named prefix from, so the board and the plan agree on it.
-// An invocation that does not parse names nothing, which is the bare `backlogrun`'s plan.
-function scope_of(invocation: string): NamedPlan {
-	return {
-		issues: run_invocation.issue_numbers(invocation) ?? [],
-		only: run_invocation.has_only(invocation),
-	}
+// An invocation that does not parse names nothing, which is the bare `backlogrun`'s plan. A single
+// `fullrun #N` or `halfrun #N` covers its own issue alone (`run-board-single.ts`).
+// The issues `run:add` handed the run join the declared ones in the order the driver works them
+// (`run_carry_added.ordered`), so an `--only` run draws them too (joshuafolkken/kit#6836).
+function scope_of(invocation: string, added?: ReadonlyArray<CarryAddition>): NamedPlan {
+	return (
+		run_board_single.scope_of(invocation) ?? {
+			issues: run_carry_added.ordered(run_invocation.issue_numbers(invocation) ?? [], added),
+			only: run_invocation.has_only(invocation),
+		}
+	)
 }
 
 const run_board_scope = { scope_of }

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

@@ -0,0 +1,107 @@
+import { backlog_hold_text } from '#scripts/backlog/backlog-hold-text'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_board_labels } from './run-board-labels'
+import { run_board_layout, type BoardLayout, type BoardRow } from './run-board-layout'
+import { run_board_setup } from './run-board-setup'
+
+// Why a lane seat stands empty (joshuafolkken/kit#6538): one line per seat the limit allows and no lane
+// holds. The first seat names the newest launch's refusal — its issue and the failing step's own words
+// (`backlog-drive-launch.ts`) — until a later launch supersedes it; every other seat says whether a
+// queued row could take it, read off the rows' own reasons (`run-board-reason.ts`), with the driver's
+// open ledger hold. A seat a runnable row is about to take, with nothing holding the driver, draws no line.
+
+const KIND = run_event_stream.EVENT_KIND
+const { STAGE } = run_event_setup
+const { WAIT_ICONS } = run_board_labels
+const NO_CANDIDATE = 'no issue ready to start'
+const HELD = 'held'
+// The row waits that a free seat itself, or the driver's hold, answers — the row could run in the seat.
+const ROOM_ICONS: ReadonlySet<string> = new Set([
+	WAIT_ICONS.lane,
+	WAIT_ICONS.memory,
+	WAIT_ICONS.usage_limit,
+])
+
+interface SeatRead {
+	// The newest launch's refusal after `no child launched`: `#<N>` and the failing step's words.
+	refusal?: string | undefined
+	// The ledger's open hold (`lane-held-stats.ts`); `undefined` once released.
+	hold?: string | undefined
+}
+
+// What the seat lines are drawn from: the room the lanes heading counts and the rows waiting for it.
+interface SeatRoom {
+	seats?: SeatRead | undefined
+	lane_limit?: number | undefined
+	occupied_count?: number | undefined
+	layout?: BoardLayout | undefined
+}
+
+function is_launch_result(event: RunEvent): boolean {
+	return event.kind === KIND.CHILD_LAUNCH || run_board_setup.is_refusal(event)
+}
+
+function read_of(events: ReadonlyArray<RunEvent>, hold: string | undefined): SeatRead {
+	const last = events.findLast((event) => is_launch_result(event))
+	const refusal =
+		last !== undefined && run_board_setup.is_refusal(last)
+			? last.text.slice(STAGE.NO_CHILD.length).trim()
+			: undefined
+
+	return { refusal, hold }
+}
+
+function free_count(room: SeatRoom): number {
+	const { lane_limit, occupied_count } = room
+
+	if (lane_limit === undefined || occupied_count === undefined) return 0
+
+	return Math.max(0, lane_limit - occupied_count)
+}
+
+// A stalled or needs-decision row is queued too, but the driver offers only a waiting one.
+function is_runnable(row: BoardRow): boolean {
+	if (row.state !== 'waiting' || row.waits.length > 0) return false
+
+	return row.reason?.icon === undefined || ROOM_ICONS.has(row.reason.icon)
+}
+
+function has_candidate(layout: BoardLayout | undefined): boolean {
+	return (
+		layout !== undefined && run_board_layout.queued_rows(layout).some((row) => is_runnable(row))
+	)
+}
+
+function with_hold(lead: string, hold: string | undefined): string {
+	return hold === undefined ? lead : `${lead} — ${backlog_hold_text.text_of(hold)}`
+}
+
+// What a seat no refusal explains says: no runnable row, or the hold that keeps a runnable one out —
+// the hold as a sentence, never its ledger code (`backlog-hold-text.ts`).
+function idle_reason(room: SeatRoom): string | undefined {
+	const hold = room.seats?.hold
+
+	if (!has_candidate(room.layout)) return with_hold(NO_CANDIDATE, hold)
+
+	return hold === undefined ? undefined : with_hold(HELD, hold)
+}
+
+// No seat line where the seats are unread — before the plan is read, or once the run stopped.
+function reasons_of(room: SeatRoom): Array<string> {
+	if (room.seats === undefined) return []
+
+	const idle = idle_reason(room)
+	const { refusal } = room.seats
+	const first = refusal === undefined ? idle : `blocked: ${refusal}`
+	const reasons = Array.from({ length: free_count(room) }, (_, index) =>
+		index === 0 ? first : idle,
+	)
+
+	return reasons.filter((reason) => reason !== undefined)
+}
+
+const run_board_seat = { NO_CANDIDATE, read_of, reasons_of }
+
+export { run_board_seat }
+export type { SeatRead, SeatRoom }

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

@@ -0,0 +1,33 @@
+import type { ItemState, ItemStatus } from './run-board-status'
+
+// What a child keeps of its run when it settles into a state other than running — shared by the
+// stream fold (`run-board-status.ts`) and a lane's stop (`run-board-lane-stop.ts`).
+
+// The newest launch carried on, where the child launched more than once.
+function relaunch_of(status: ItemStatus | undefined): Pick<ItemStatus, 'launched_ms'> {
+	return status?.launched_ms === undefined ? {} : { launched_ms: status.launched_ms }
+}
+
+// What a settled child keeps of its run: its newest launch, its spans on a lane, and its track.
+function kept_of(
+	previous: ItemStatus | undefined,
+): Pick<ItemStatus, 'launched_ms' | 'spans' | 'track'> {
+	const spans = previous?.spans
+	const track = previous?.track
+
+	return {
+		...relaunch_of(previous),
+		...(spans !== undefined && { spans }),
+		...(track !== undefined && { track }),
+	}
+}
+
+// The status a child settles into: its start and the track it had reached, so a settled row still
+// draws how it got there.
+function settled_as(previous: ItemStatus | undefined, state: ItemState): ItemStatus {
+	return { state, started_ms: previous?.started_ms, ...kept_of(previous) }
+}
+
+const run_board_settle = { relaunch_of, settled_as }
+
+export { run_board_settle }

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

@@ -21,14 +21,25 @@ interface SetupRead {
 
 const NO_SETUP: SetupRead = { setup: undefined, setup_ms: undefined }
 
-// The stages of a hand-back to a session. Only the supervisor's next hand-off ends one, whatever the
-// session writes to the stream meanwhile.
-const JUDGMENT_STAGES: ReadonlySet<string> = new Set([STAGE.JUDGING, STAGE.SESSION])
+// The stages of a hand-back to a session, and of the retrospective unit the driver waits on at a drain
+// (joshuafolkken/kit#6745). Only the run's next stage ends one, whatever the session or the unit writes
+// to the stream meanwhile.
+const SESSION_STAGES: ReadonlySet<string> = new Set([
+	STAGE.JUDGING,
+	STAGE.SESSION,
+	STAGE.RETROSPECTIVE,
+])
 
 function is_setup(event: RunEvent): boolean {
 	return event.kind === KIND.SETUP
 }
 
+// A launch that returned without a child (`run_event_setup.no_child`): it ends its own lane's stage,
+// and prepares nothing a person waits on.
+function is_refusal(event: RunEvent): boolean {
+	return is_setup(event) && event.text.startsWith(STAGE.NO_CHILD)
+}
+
 function has_launched(events: ReadonlyArray<RunEvent>): boolean {
 	return events.some((event) => event.kind === KIND.CHILD_LAUNCH)
 }
@@ -42,9 +53,9 @@ function has_started(events: ReadonlyArray<RunEvent>): boolean {
 
 // A lane is opening while the stage naming its issue is newer than the run's newest position: the
 // launch it leads to, or whatever the run did instead, ends it. A stage that names no issue — a
-// hand-off between two children — prepares nothing a person waits on.
+// hand-off between two children — or a refusal prepares nothing a person waits on.
 function is_opening(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
-	if (run_event_scope.issue_named(stage) === undefined) return false
+	if (run_event_scope.issue_named(stage) === undefined || is_refusal(stage)) return false
 
 	const position = events.findLast((event) => !run_event_stream.TRACE_KINDS.has(event.kind))
 
@@ -54,7 +65,7 @@ function is_opening(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
 // Whether the run is at `stage` now: at any stage while it is starting; after that only at one it is
 // itself working through.
 function is_standing(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
-	if (!has_started(events) || JUDGMENT_STAGES.has(stage.text)) return true
+	if (!has_started(events) || SESSION_STAGES.has(stage.text)) return true
 
 	return is_opening(events, stage)
 }
@@ -84,27 +95,31 @@ function is_step_for(event: RunEvent, issue: number): boolean {
 	return is_setup(event) || !run_event_stream.TRACE_KINDS.has(event.kind)
 }
 
-// A stage that names no issue: a hand-off to the driver, a hand-back to a session, or a launch that
-// returned without a child. A lane's launch runs inside one driver pass, so a newer one of these says
-// that launch has returned.
+// A stage that names no issue: a hand-off to the driver or a hand-back to a session. A pass's launches
+// all return before either, so a newer one of these says every launch has returned.
 function is_run_stage(event: RunEvent): boolean {
 	return is_setup(event) && run_event_scope.issue_named(event) === undefined
 }
 
+// A stage of `issue`'s lane itself, not the refusal that ended it.
+function is_lane_stage(event: RunEvent, issue: number): boolean {
+	return is_setup(event) && names(event, issue) && !is_refusal(event)
+}
+
 // The stage `issue`'s own lane is at: the newest stage naming it, until the run does anything else for
-// that issue — its launch, or whatever ended the attempt — or writes a stage naming none, which is all
-// a launch that left no child puts on the stream: the driver says so itself, since a refusal it waits
-// out is followed by no hand-off. Read per issue, so two lanes opened side by side each stand at their
-// own stage whatever the other has reached.
+// that issue — its launch, its refusal (the driver writes that itself, since a refusal it waits out is
+// followed by no hand-off), or whatever ended the attempt — or writes a stage naming none. Read per
+// issue, so two lanes opened side by side each stand at their own stage whatever the other has
+// reached, a refusal of the other included.
 function lane_stage(events: ReadonlyArray<RunEvent>, issue: number): LaneStage | undefined {
 	const step = events.findLast((event) => is_run_stage(event) || is_step_for(event, issue))
 
-	if (step === undefined || !is_setup(step) || !names(step, issue)) return undefined
+	if (step === undefined || !is_lane_stage(step, issue)) return undefined
 
 	return { text: step.text, at_ms: Date.parse(step.at) }
 }
 
-const run_board_setup = { lane_stage, read }
+const run_board_setup = { is_refusal, lane_stage, read }
 
 export { run_board_setup }
 export type { LaneStage, SetupRead }

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

@@ -0,0 +1,123 @@
+import type { NamedPlan } from '#scripts/backlog/backlog-plan'
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { lane_paths } from '#scripts/lane/lane-paths'
+import { stamped_memo } from '#scripts/lib/stamped-memo'
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_hold, type HoldRead } from '#scripts/run/hold/run-hold'
+import type { BoardSpan } from './run-board-span'
+
+// A single `fullrun #N` or `halfrun #N` has no carry record; the only record that says it is running
+// here is this checkout's hold (`run-hold.ts`), so the board draws it from there — no store of its own
+// (joshuafolkken/kit#6597). The hold marks a `fullrun` (`is_fullrun`); `run:entry` claims a `halfrun`
+// unmarked (`run-entry-children.ts`), so an unmarked numbered hold is one.
+
+const FULLRUN = 'fullrun'
+const HALFRUN = 'halfrun'
+const SINGLE_INVOCATION = /^(?<command>fullrun|halfrun) #(?<issue>\d+)$/u
+// The launch the board reads a row's running state from, placed before every event of the run.
+const LAUNCH_POSITION = 0
+
+interface SingleRun {
+	command: string
+	issue: number
+}
+
+// The checkout's own git directory, resolved once per working directory: resolving it runs a `git`
+// subprocess the redraw would wait on, as `run-board-read.ts`'s main work tree does.
+const directories = stamped_memo.create<Promise<string | undefined>>()
+
+// A held, numbered hold is a running run unless a stop marked it: a stopped `halfrun` or `prrun` keeps
+// its hold across a person's latency (`run_hold.is_stop_marked`), long after the run stopped.
+function is_running(read: HoldRead): read is Extract<HoldRead, { kind: 'held' }> {
+	if (read.kind !== 'held') return false
+
+	return issue_number_shape.is_issue_number(read.hold.issue) && !run_hold.is_stop_marked(read.hold)
+}
+
+function span_of(read: HoldRead): BoardSpan | undefined {
+	if (!is_running(read)) return undefined
+
+	const started_ms = run_event_scope.moment_of(read.hold.taken_at)
+
+	if (started_ms === undefined) return undefined
+
+	const command = read.hold.is_fullrun === true ? FULLRUN : HALFRUN
+
+	return {
+		invocation: `${command} ${issue_cite.plain_for('program', read.hold.issue)}`,
+		started_ms,
+		ended_ms: undefined,
+	}
+}
+
+// A failed resolve is forgotten, so a `git` that timed out once is asked again on the next redraw, as
+// `run-board-read.ts`'s main work tree is.
+async function directory_here(): Promise<string | undefined> {
+	try {
+		return await directories.of(
+			process.cwd(),
+			stamped_memo.NO_STAMP,
+			async () => await run_hold.worktree_directory(),
+		)
+	} catch (error) {
+		directories.keep(new Set())
+		throw error
+	}
+}
+
+// The single run held in this checkout; `undefined` where none is. A lane's hold is its `backlogrun`
+// child's, drawn as that run's row, so only outside a lane does a hold outrank the carry record — a
+// `fullrun` in another checkout beside a running `backlogrun`.
+async function span_here(is_carried: boolean): Promise<BoardSpan | undefined> {
+	if (is_carried && lane_paths.lane_issue_of(process.cwd()) !== undefined) return undefined
+
+	const directory = await directory_here()
+
+	if (directory === undefined) return undefined
+
+	return span_of(run_hold.read_hold(run_hold.hold_path(directory)))
+}
+
+// The command and issue of a single run's invocation; `undefined` for any other run's.
+function single_of(invocation: string): SingleRun | undefined {
+	const { command, issue } = SINGLE_INVOCATION.exec(invocation)?.groups ?? {}
+
+	if (command === undefined || issue === undefined) return undefined
+
+	return { command, issue: Number(issue) }
+}
+
+// A single run covers its own issue alone; `undefined` for any other run's invocation.
+function scope_of(invocation: string): NamedPlan | undefined {
+	const single = single_of(invocation)
+
+	return single === undefined ? undefined : { issues: [single.issue], only: true }
+}
+
+// A single run's issue is running from the hold on: the launch event its row's phase is read after
+// (`run-board-status.ts`), which no lane dispatch wrote for it. Every other run's events stay as read.
+function events_of(span: BoardSpan, events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
+	const single = single_of(span.invocation)
+
+	if (single === undefined) return events
+
+	const launch: RunEvent = {
+		pos: LAUNCH_POSITION,
+		at: new Date(span.started_ms).toISOString(),
+		kind: run_event_stream.EVENT_KIND.CHILD_LAUNCH,
+		text: `${issue_cite.plain_for('program', single.issue)} ${single.command}`,
+	}
+
+	return [launch, ...events]
+}
+
+// The run's name the board's header draws; `undefined` for a `backlogrun`, the header's own.
+function name_of(invocation: string): string | undefined {
+	return single_of(invocation)?.command
+}
+
+const run_board_single = { events_of, name_of, scope_of, span_here, span_of }
+
+export { run_board_single }