@joshuafolkken/kit 1.1379.0 → 1.1387.0

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

@@ -1,33 +1,36 @@
 import { styleText } from 'node:util'
 import { backlog_budget } from '#scripts/backlog/backlog-budget'
-import { backlog_idle, type IdleWindow } from '#scripts/backlog/backlog-idle'
+import { run_board_fit } from './run-board-fit'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type BoardLayout, type BoardRow } from './run-board-layout'
 import { run_board_machine, type MachineGauges } from './run-board-machine'
+import { run_board_render_slot } from './run-board-render-slot'
 import type { RunActivity } from './run-board-status'
 import type { LaneUsages } from './run-board-usage'
 
-// The top of `run:board`: whether the run is moving, how long it has run, how long it has left, how
-// fresh its last event is, and how far through the plan it is — and, while it waits on an empty
-// backlog, until when it waits and what ends the wait. Every time comes from a record (the carry's
-// start, the stream's events, the `idle` window); nothing here guesses one. Lines of symbols rather
-// than sentences: the `⏱` that moves every second is the proof the board is live, so no `updated`
-// line is drawn. Beside the time, the machine the run is on, so a slow run reads apart from a stuck
-// one. **Always two lines**: the run's state with its progress, then the time with the machine. A
-// value not read yet is drawn `-`, never `0`, so a header still loading reads as unknown rather than
-// as an empty run.
-
-const { HEADER_ICONS, STATE_ICONS, WORDS, bar_of, clock_of, elapsed_of, left_of, minute_of } =
-	run_board_labels
+// The top of `run:board`: whether the run is moving, how long it has run, how fresh its last event is,
+// and how far through the plan it is. Every time comes from a record (the carry's start, the stream's
+// events); nothing here guesses one. Lines of symbols rather than sentences: the `⏰` that moves every
+// second is the proof the board is live, so no `updated` line is drawn. **Always two lines, in three
+// columns**: the run's mark and name over its repository's, the run's age over the `💓`, then the
+// progress over the machine the run is on — so the first line reads as how far the run is and the
+// second as what it runs on, a slow run apart from a stuck one. Both are written the same while the
+// run works and while it waits, so a wait is read off the mark and the `💓` rather than off a line
+// that changes shape. A value not read yet is drawn `-`, never `0`, so a header still loading reads
+// as unknown rather than as an empty run.
+
+const { HEADER_ICONS, STATE_ICONS, WORDS, bar_of, minute_of, span_of } = run_board_labels
+const { cell_of } = run_board_render_slot
 const UNKNOWN = '-'
-const { GAP } = run_board_machine
+const BLANK = ' '
+const REPO_SEPARATOR = '/'
+const { GAP, PERCENT_WIDTH } = run_board_machine
 // A running run whose newest event is older than this is drawn as stale, so a hang stands out; past
 // twice that it is drawn as alarming.
 const STALE_MINUTES = 15
 const STALE_MS = STALE_MINUTES * backlog_budget.MS_PER_MINUTE
 const ALARM_FACTOR = 2
 const ALARM_MS = STALE_MS * ALARM_FACTOR
-const INDENT = '  '
 const RUN_NAME = 'backlogrun'
 
 // Who reads the frame: a person on a screen, or a chat a session answers a progress question in, which
@@ -56,6 +59,8 @@ interface BoardHeader {
 	// terminal and they draw their still icons.
 	spinner: string | undefined
 	form: BoardForm
+	// The repository the plan was read for, as `owner/repo`; `undefined` before a plan is read.
+	repo: string | undefined
 	// An issue reference as the board draws it — `3450` or `owner/repo#12` — made a link where the
 	// terminal opens one.
 	link: (reference: string) => string
@@ -69,13 +74,15 @@ interface BoardCounts {
 	remaining: number
 }
 
-type RunMark = 'running' | 'idle' | 'human' | 'stopped'
+// `setup` is a run with no child running that is getting one ready (`run-board-setup.ts`).
+type RunMark = 'running' | 'setup' | 'idle' | 'human' | 'stopped'
 
 type TextColor = Parameters<typeof styleText>[0]
 
 // The run's state as a colored glyph before its name.
 const RUN_MARKS: Readonly<Record<RunMark, { glyph: string; color: TextColor }>> = {
 	running: { glyph: '▶', color: 'green' },
+	setup: { glyph: '▶', color: 'green' },
 	idle: { glyph: '⏸', color: 'yellow' },
 	human: { glyph: '✋', color: 'magenta' },
 	stopped: { glyph: '■', color: 'gray' },
@@ -94,45 +101,90 @@ function counts_of(layout: BoardLayout): BoardCounts {
 	return { total, settled, parked, running, remaining: total - settled - running }
 }
 
+// The marks of a run that is working: they turn the spinner, and only they can go stale.
+const WORKING_MARKS: ReadonlySet<RunMark> = new Set<RunMark>(['running', 'setup'])
+// What follows the stage once the plan is read: how many issues the run is setting up for.
+const STAGE_SEPARATOR = ' · '
+const PLANNED = 'planned'
+
 // Nothing running: the run is waiting on a person when all the plan has left is what
-// `needs-decision` holds, and otherwise idle.
-function quiet_mark(layout: BoardLayout | undefined): RunMark {
-	return layout?.waves.length === 0 && layout.people.length > 0 ? 'human' : 'idle'
+// `needs-decision` holds; otherwise it is getting a child ready, or idle.
+function quiet_mark(header: BoardHeader): RunMark {
+	const { layout } = header
+
+	if (layout?.waves.length === 0 && layout.people.length > 0) return 'human'
+
+	return header.activity.is_preparing === true ? 'setup' : 'idle'
 }
 
 // The run's state, each state overriding the ones below it.
 function mark_of(header: BoardHeader, running: number): RunMark {
 	if (header.activity.is_stopped) return 'stopped'
-	if (running > 0) return 'running'
 
-	return header.activity.idle === undefined ? quiet_mark(header.layout) : 'idle'
+	return running > 0 ? 'running' : quiet_mark(header)
 }
 
-// A running run turns the spinner in place of ▶, both one column wide; every other mark stands still.
+// A working run turns the spinner in place of ▶, both one column wide; every other mark stands still.
 function run_part(mark: RunMark, spinner: string | undefined): string {
 	const { glyph, color } = RUN_MARKS[mark]
-	const shown = mark === 'running' ? (spinner ?? glyph) : glyph
+	const shown = WORKING_MARKS.has(mark) ? (spinner ?? glyph) : glyph
 
 	return styleText(color, `${shown} ${RUN_NAME}`)
 }
 
+// The repository's own name — `kit` of `owner/kit` — under the run's, past the mark's columns, so a
+// board open beside another repository's is told apart. Blank before a plan names one.
+function repo_part(header: BoardHeader, mark: RunMark): string {
+	const name = header.repo?.split(REPO_SEPARATOR).at(-1) ?? ''
+	const indent = run_board_fit.width_of(RUN_MARKS[mark].glyph) + BLANK.length
+
+	return `${BLANK.repeat(indent)}${name}`
+}
+
 function aged(part: string, age_ms: number): string {
 	if (age_ms > ALARM_MS) return styleText('red', part)
 
 	return age_ms > STALE_MS ? styleText('yellow', part) : part
 }
 
-// How long ago the stream last moved; only a running run can be stale, so only it is colored. An ended
-// run has no heartbeat to keep: one counting on would read as a hang.
-function heartbeat_part(header: BoardHeader, mark: RunMark): string | undefined {
+// How long ago the stream last moved. An ended run has no heartbeat to keep: one counting on would
+// read as a hang.
+function age_of(header: BoardHeader): number | undefined {
 	const last = header.activity.last_event_ms
 
 	if (last === undefined || header.ended_ms !== undefined) return undefined
 
-	const age = header.now_ms - last
-	const part = `💓 ${elapsed_of(age)}`
+	return header.now_ms - last
+}
+
+// The minute an ended run ended, standing where its heartbeat did. Blank while the run has none to draw.
+function ended_part(header: BoardHeader): string {
+	const { ended_ms } = header
 
-	return mark === 'running' ? aged(part, age) : part
+	return ended_ms === undefined ? '' : `${HEADER_ICONS.ended} ${minute_of(ended_ms)}`
+}
+
+// The `💓` under the run's age, in the `⏰`'s own format with its digits right-aligned to `width` —
+// only a working run can be stale, so only it is colored. Only an ended run draws anything else there:
+// the minute it ended.
+function beat_part(header: BoardHeader, mark: RunMark, width: number): string {
+	const age = age_of(header)
+
+	if (age === undefined) return ended_part(header)
+
+	const part = `${HEADER_ICONS.heartbeat} ${span_of(age).padStart(width)}`
+
+	return WORKING_MARKS.has(mark) ? aged(part, age) : part
+}
+
+// A run's age over the `💓`, or over the minute an ended run ended: the shorter of the two lengths is
+// right-aligned to the longer, so the digits stand in one column when only one has passed ten hours.
+function time_parts(header: BoardHeader, mark: RunMark): Array<string> {
+	const elapsed = span_of((header.ended_ms ?? header.now_ms) - header.started_ms)
+	const age = age_of(header)
+	const width = Math.max(elapsed.length, age === undefined ? 0 : span_of(age).length)
+
+	return [`${HEADER_ICONS.elapsed} ${elapsed.padStart(width)}`, beat_part(header, mark, width)]
 }
 
 // A plan fetch is said only when it failed — the board otherwise keeps quiet about a routine read.
@@ -152,23 +204,6 @@ function loading_part(header: BoardHeader): string | undefined {
 	return is_plan_loading && spinner !== undefined ? `${HEADER_ICONS.loading} ${spinner}` : undefined
 }
 
-// A running run's age and time left before the cut-off, or an ended run's frozen duration and the
-// minute it ended — an ended run has no cut-off left.
-function time_parts(header: BoardHeader): Array<string> {
-	const { now_ms, started_ms, ended_ms } = header
-
-	if (ended_ms !== undefined) {
-		return [
-			`⏱ ${elapsed_of(ended_ms - started_ms)}`,
-			`${HEADER_ICONS.ended} ${minute_of(ended_ms)}`,
-		]
-	}
-
-	const cutoff = started_ms + backlog_budget.WHOLE_RUN_BUDGET_MS
-
-	return [`⏱ ${elapsed_of(now_ms - started_ms)}`, `⌛ ${left_of(cutoff - now_ms)}`]
-}
-
 function layout_of(header: BoardHeader): BoardLayout {
 	return header.layout ?? run_board_layout.EMPTY_LAYOUT
 }
@@ -186,14 +221,25 @@ function plus_of(counts: BoardCounts, header: BoardHeader): string {
 	return added > 0 ? ` (+${String(added)})` : ''
 }
 
-// Icon, figure, then bar, as the machine gauges: the settled count is right-aligned to the total's
-// width, so the bar starts in one column as the count grows. Arrivals since the board first looked
-// follow the bar, where they cannot move it.
-function tally_part(counts: BoardCounts, is_read: boolean): string {
+// The plan's total as the tally draws it, unknown until the plan is read.
+function total_of(counts: BoardCounts, header: BoardHeader): string {
+	return is_plan_read(header) ? String(counts.total) : UNKNOWN
+}
+
+// The width the tally and the machine's first figure are both right-aligned to — the wider of a full
+// tally and a full percent — so the progress bar and the gauge under it start in one column, and
+// neither moves as a count or a percent gains a digit.
+function figure_width(total: string): number {
+	return Math.max(PERCENT_WIDTH, `${total}/${total}`.length)
+}
+
+// Icon, figure, then bar, as the machine gauges. Arrivals since the board first looked follow the
+// bar, where they cannot move it.
+function tally_part(counts: BoardCounts, header: BoardHeader): string {
 	const { settled } = counts
-	const total = is_read ? String(counts.total) : UNKNOWN
-	const tally = `${String(settled)}/${total}`.padStart(`${total}/${total}`.length)
-	const bar = is_read ? bar_of(settled, counts.total) : bar_of(0, 0)
+	const total = total_of(counts, header)
+	const tally = `${String(settled)}/${total}`.padStart(figure_width(total))
+	const bar = is_plan_read(header) ? bar_of(settled, counts.total) : bar_of(0, 0)
 
 	return `${STATE_ICONS.merged} ${tally} ${bar}`
 }
@@ -202,45 +248,32 @@ function progress_parts(counts: BoardCounts, header: BoardHeader): Array<string>
 	const is_read = is_plan_read(header)
 
 	return [
-		`${tally_part(counts, is_read)}${is_read ? plus_of(counts, header) : ''}`,
+		`${tally_part(counts, header)}${is_read ? plus_of(counts, header) : ''}`,
 		`${STATE_ICONS.running} ${String(counts.running)}`,
 		`${STATE_ICONS.waiting} ${is_read ? String(counts.remaining) : UNKNOWN}`,
 		`${STATE_ICONS.parked} ${String(counts.parked)}`,
 	]
 }
 
-// The run's mark and its progress, then how fresh its stream is and what its plan read is doing.
-function state_line(counts: BoardCounts, header: BoardHeader): string {
-	const mark = mark_of(header, counts.running)
-	const parts = [
-		run_part(mark, header.spinner),
-		...progress_parts(counts, header),
-		heartbeat_part(header, mark),
-		loading_part(header),
-		plan_warning(header),
-	]
+// The stage a run is at before its first child launches, standing where the progress will: a tally of
+// nothing settled says less than what the run is doing. Only a run marked as setting up is at a stage:
+// a stopped run and one waiting on a person keep their progress.
+function stage_part(counts: BoardCounts, header: BoardHeader, mark: RunMark): string | undefined {
+	const { setup } = header.activity
 
-	return parts.filter((part) => part !== undefined).join(GAP)
-}
+	if (setup === undefined || mark !== 'setup') return undefined
+	if (!is_plan_read(header)) return setup
 
-function idle_line(idle: IdleWindow, now_ms: number): string {
-	const ending = idle.bound === 'idle' ? WORDS.idle_end_idle : WORDS.idle_end_run
-	const left = `${elapsed_of(idle.until_ms - now_ms)} ${WORDS.idle_left}`
-	const until = `${WORDS.idle_until} ${clock_of(idle.until_ms)} (${left}) → ${ending}`
-	const next_check = `${WORDS.next_check} ${clock_of(backlog_idle.next_check_ms(idle))}`
-
-	return `${INDENT}${RUN_MARKS.idle.glyph} ${until} · ${next_check}`
+	return `${setup}${STAGE_SEPARATOR}${String(counts.total)} ${PLANNED}`
 }
 
-// The wait, under the header's blank line, drawn only while it is what the run is doing: no child
-// running and the run not ended. The children running are the run's own, read
-// locally, so a board still waiting on GitHub never draws a running run as waiting.
-function idle_lines(header: BoardHeader): Array<string> {
-	const { idle, is_stopped } = header.activity
-
-	if (is_stopped || idle === undefined || counts_of(layout_of(header)).running > 0) return []
+// The run's stage or its progress, then what its plan read is doing.
+function progress_part(counts: BoardCounts, header: BoardHeader, mark: RunMark): string {
+	const stage = stage_part(counts, header, mark)
+	const progress = stage === undefined ? progress_parts(counts, header) : [stage]
+	const parts = [...progress, loading_part(header), plan_warning(header)]
 
-	return ['', idle_line(idle, header.now_ms)]
+	return parts.filter((part) => part !== undefined).join(GAP)
 }
 
 // The gauges the machine line draws: every one on a screen, the memory alone in a chat.
@@ -257,19 +290,35 @@ const MACHINE_UNKNOWN = [HEADER_ICONS.cpu, HEADER_ICONS.memory, HEADER_ICONS.swa
 	.map((icon) => `${icon} ${UNKNOWN}`)
 	.join(GAP)
 
-// The time, then the machine the run is on.
-function clock_line(header: BoardHeader): string {
-	const machine = run_board_machine.line_of(machine_of(header)) ?? MACHINE_UNKNOWN
+// The machine the run is on, its first figure as wide as the tally over it.
+function machine_part(counts: BoardCounts, header: BoardHeader): string {
+	const width = figure_width(total_of(counts, header))
 
-	return [...time_parts(header), machine].join(GAP)
+	return run_board_machine.line_of(machine_of(header), width) ?? MACHINE_UNKNOWN
 }
 
-// The run's state with its progress, then the time with the machine, in every state the board can be in.
+// Both lines' cells of one column, the narrower padded to the wider as the terminal counts them.
+function column_of(cells: ReadonlyArray<string>): Array<string> {
+	const width = Math.max(...cells.map((cell) => run_board_fit.width_of(cell)))
+
+	return cells.map((cell) => cell_of(cell, width))
+}
+
+// The run's name, age and progress, then its repository, heartbeat and machine under them, in every
+// state the board can be in.
 function header_lines(header: BoardHeader): Array<string> {
-	return [state_line(counts_of(layout_of(header)), header), clock_line(header)]
+	const counts = counts_of(layout_of(header))
+	const mark = mark_of(header, counts.running)
+	const columns = [
+		column_of([run_part(mark, header.spinner), repo_part(header, mark)]),
+		column_of(time_parts(header, mark)),
+		[progress_part(counts, header, mark), machine_part(counts, header)],
+	]
+
+	return [0, 1].map((line) => columns.map((column) => column[line]).join(GAP))
 }
 
-const run_board_header = { counts_of, header_lines, idle_lines, is_plan_read }
+const run_board_header = { counts_of, header_lines, is_plan_read }
 
 export { run_board_header }
 export type { BoardCounts, BoardForm, BoardHeader }

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

@@ -6,16 +6,16 @@ import type { BoardNote } from './run-board-notes'
 import type { Phase } from './run-board-phase'
 import type { ItemState } from './run-board-status'
 
-// The words and the clock `run:board` draws with. A moment on the board is a local `HH:MM:SS` clock;
-// how long something has run is a short `MM:SS`, so a person reads the board against the clock on
-// their own screen.
+// The words and the clock `run:board` draws with. A moment on the board is a local clock, `HH:MM`
+// where a person reads it to the minute; how long a row or the heartbeat has run is a short `MM:SS`,
+// and how long the run has run or its wait has left is `H:MM:SS` — two separators are a length and one
+// is a time of day, so the header's time column never reads a length as a moment.
 
 const CLOCK_WIDTH = 2
 const CLOCK_PAD = '0'
 const MS_PER_SECOND = 1000
 const SECONDS_PER_MINUTE = 60
 const MINUTES_PER_HOUR = 60
-const MS_PER_MINUTE = MS_PER_SECOND * SECONDS_PER_MINUTE
 // Every gauge is this wide — the plan, the machine and a row's phase.
 const BAR_WIDTH = 10
 // A centered square done and a thin line left: the shapes alone tell the two apart where no color is
@@ -58,11 +58,6 @@ const WORDS = {
 	followup: 'followup',
 	report: 'report',
 	failed: 'failed',
-	idle_until: 'wait ends',
-	idle_left: 'left',
-	idle_end_idle: 'ends and reports if nothing new',
-	idle_end_run: 'ends at the whole-run cut-off and reports',
-	next_check: 'next check',
 	notes: 'findings and decisions',
 	more: 'more',
 	filed: 'filed',
@@ -168,13 +163,16 @@ const KIND_WORDS: Readonly<Record<FiledKind, keyof Words>> = {
 }
 
 // The header's gauges and marks. ⚡ rather than 🔥: a fire beside a gauge drawn green reads as an
-// alarm.
+// alarm. ⏰ rather than ⏱, a text symbol some terminals draw one column wide: under it the 💓's digits
+// would stand a column off.
 const HEADER_ICONS = {
 	cpu: '⚡',
 	memory: '🧠',
 	swap: '💾',
 	ended: '🔚',
 	loading: '⏳',
+	elapsed: '⏰',
+	heartbeat: '💓',
 } as const
 
 // **The machine gauges' three colors, decided here alone**: Activity Monitor's green, yellow and red
@@ -207,8 +205,8 @@ function minute_of(ms: number): string {
 	return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(':')
 }
 
-// How long something has run, as `MM:SS` whose minutes never carry into hours (`61:05`), so the header
-// and every row read one short column; a negative span reads as zero.
+// How long a row's child has run, as `MM:SS` whose minutes never carry into hours (`61:05`), so every
+// row reads one short column; a negative span reads as zero.
 function elapsed_of(ms: number): string {
 	const seconds = Math.floor(Math.max(0, ms) / MS_PER_SECOND)
 	const minutes = Math.floor(seconds / SECONDS_PER_MINUTE)
@@ -216,12 +214,15 @@ function elapsed_of(ms: number): string {
 	return `${two_digits(minutes)}:${two_digits(seconds % SECONDS_PER_MINUTE)}`
 }
 
-// How long is left, as `7h38m`; a deadline already passed reads as zero.
-function left_of(ms: number): string {
-	const minutes = Math.floor(Math.max(0, ms) / MS_PER_MINUTE)
+// How long the run has run or its stream has been silent, as `H:MM:SS` with the hours not padded; a negative
+// span reads as zero. Always three fields, so a run under an hour (`0:03:25`) never reads as a time.
+function span_of(ms: number): string {
+	const seconds = Math.floor(Math.max(0, ms) / MS_PER_SECOND)
+	const minutes = Math.floor(seconds / SECONDS_PER_MINUTE)
 	const hours = Math.floor(minutes / MINUTES_PER_HOUR)
+	const tail = [minutes % MINUTES_PER_HOUR, seconds % SECONDS_PER_MINUTE]
 
-	return `${String(hours)}h${two_digits(minutes % MINUTES_PER_HOUR)}m`
+	return [String(hours), ...tail.map((value) => two_digits(value))].join(':')
 }
 
 function is_shade(color: Paint): color is Shade {
@@ -289,9 +290,9 @@ const run_board_labels = {
 	bar_of,
 	clock_of,
 	elapsed_of,
-	left_of,
 	minute_of,
 	painted,
+	span_of,
 	spinner_of,
 }
 

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

@@ -157,28 +157,40 @@ function alert_of(spec: GaugeSpec, value: number, pressure: number | undefined):
 	return verdict ?? threshold_alert(value, spec)
 }
 
+// One gauge's reading: its value, the width its figure is right-aligned to where that is wider than
+// the figure's own, and the kernel's pressure verdict where the gauge takes one.
+interface Reading {
+	value: number | undefined
+	width: number
+	pressure?: number | undefined
+}
+
 // Icon, figure, then bar: the figure is what a person reads, and its fixed
 // width keeps every bar starting in one column. The bar stops full past `spec.full`; the figure still
 // says how far past, and takes the warning colors only, so a quiet machine's figures stay the terminal's
 // own.
-function gauge(spec: GaugeSpec, value: number | undefined, pressure?: number): string | undefined {
+function gauge(spec: GaugeSpec, reading: Reading): string | undefined {
+	const { value, width } = reading
+
 	if (value === undefined) return undefined
 
-	const alert = alert_of(spec, value, pressure)
+	const alert = alert_of(spec, value, reading.pressure)
 	const warning = alert === 'normal' ? undefined : GAUGE_SHADES[alert]
 	const bar = bar_of(value, spec.full, undefined, warning ?? spec.normal)
 
-	return `${spec.icon} ${painted(warning, spec.format(value))} ${bar}`
+	return `${spec.icon} ${painted(warning, spec.format(value).padStart(width))} ${bar}`
 }
 
-// `undefined` when not one gauge could be read, so the header draws no line at all.
-function line_of(gauges: MachineGauges | undefined): string | undefined {
+// `undefined` when not one gauge could be read, so the header draws no line at all. `width` is the
+// header's figure column: a figure narrower than it is right-aligned to it, so the first gauge's bar
+// starts under the progress bar whichever gauge that is.
+function line_of(gauges: MachineGauges | undefined, width = 0): string | undefined {
 	if (gauges === undefined) return undefined
 
 	const parts = [
-		gauge(SPECS.cpu, gauges.cpu_percent),
-		gauge(SPECS.memory, gauges.memory_percent, gauges.memory_pressure),
-		gauge(SPECS.swap, gauges.swap_mb_per_s),
+		gauge(SPECS.cpu, { value: gauges.cpu_percent, width }),
+		gauge(SPECS.memory, { value: gauges.memory_percent, width, pressure: gauges.memory_pressure }),
+		gauge(SPECS.swap, { value: gauges.swap_mb_per_s, width }),
 	].filter((part) => part !== undefined)
 
 	return parts.length === 0 ? undefined : parts.join(GAP)
@@ -188,6 +200,7 @@ const run_board_machine = {
 	CPU_YELLOW,
 	GAP,
 	MEMORY_YELLOW,
+	PERCENT_WIDTH,
 	gauges_of,
 	line_of,
 	percent_text,

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

@@ -1,8 +1,10 @@
 import type { NamedPlan } from '#scripts/backlog/backlog-plan'
+import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
 import { lane_registry } from '#scripts/lane/lane-registry'
 import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_carry_ended } from '#scripts/run/carry/run-carry-ended'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_stranded_detect } from '#scripts/run/run-stranded-detect'
 import { run_board_scope } from './run-board-scope'
 import { run_board_span, type BoardSpan } from './run-board-span'
 
@@ -18,6 +20,9 @@ interface LocalRead {
 	lanes: ReadonlyArray<string>
 	// The session a stopped run is resumed from; `undefined` otherwise.
 	resume: string | undefined
+	// The run is carried but nothing drives it — its owner and its supervisor are both gone
+	// (`run-stranded.ts`). Drawn as a stopped run, since no one is looking for its next issue.
+	is_stranded: boolean
 }
 
 interface SpanHere {
@@ -28,10 +33,11 @@ interface SpanHere {
 function span_here(repository: string): SpanHere {
 	const read = run_carry.read_carry(run_carry.carry_path(repository))
 	const ended = run_carry_ended.read_ended(run_carry_ended.ended_path(repository))
+	const launch = backlogrun_launch.pending_launch(repository)
 
 	return {
-		span: run_board_span.span_of(read, ended),
-		resume: run_board_span.resume_of(read, ended),
+		span: run_board_span.span_of(read, ended, launch),
+		resume: run_board_span.resume_of(read, ended, launch),
 	}
 }
 
@@ -53,6 +59,7 @@ async function read_local(): Promise<LocalRead | undefined> {
 		events: run_board_span.events_of(events, span),
 		lanes: lanes.map((lane) => lane.issue),
 		resume,
+		is_stranded: run_stranded_detect.is_stranded_at(repository),
 	}
 }
 

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

@@ -373,11 +373,7 @@ 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),
-		...run_board_header.idle_lines(header),
-	]
+	const above = [...run_board_header.header_lines(header), ...resume_lines(view.resume)]
 	const parts = {
 		above,
 		plan: plan_sections(header, view.size),

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

@@ -0,0 +1,73 @@
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+
+// What the run's `setup` events (`run-event-setup.ts`) tell `run:board`: the stage a run is at before
+// its first child launches, whether it is preparing a launch now, and which lanes are not children yet.
+// The events carry it all — nothing here infers a stage from which records exist.
+
+const KIND = run_event_stream.EVENT_KIND
+
+interface SetupRead {
+	// The newest stage's own words while the run is starting; `undefined` from the first launch — or a
+	// drain before one — on, when the plan's counts say more than a stage does.
+	setup: string | undefined
+	// The run is getting a child ready: any stage while it is starting, a lane opening after that.
+	is_preparing: boolean
+}
+
+const NO_SETUP: SetupRead = { setup: undefined, is_preparing: false }
+
+function is_setup(event: RunEvent): boolean {
+	return event.kind === KIND.SETUP
+}
+
+function has_launched(events: ReadonlyArray<RunEvent>): boolean {
+	return events.some((event) => event.kind === KIND.CHILD_LAUNCH)
+}
+
+// The start is over at the first launch, or at a drain that came before one: a run whose backlog
+// emptied with nothing launched is watching, and the hand-off each wake of that watch writes is not a
+// run getting ready.
+function has_started(events: ReadonlyArray<RunEvent>): boolean {
+	return has_launched(events) || events.some((event) => event.kind === KIND.DRAIN)
+}
+
+// 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.
+function is_opening(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
+	if (run_event_scope.issue_named(stage) === undefined) return false
+
+	const position = events.findLast((event) => !run_event_stream.TRACE_KINDS.has(event.kind))
+
+	return position === undefined || position.pos < stage.pos
+}
+
+function read(events: ReadonlyArray<RunEvent>): SetupRead {
+	const stage = events.findLast((event) => is_setup(event))
+
+	if (stage === undefined) return NO_SETUP
+	if (!has_started(events)) return { setup: stage.text, is_preparing: true }
+
+	return { setup: undefined, is_preparing: is_opening(events, stage) }
+}
+
+function names(event: RunEvent, issue: number): boolean {
+	return Number(run_event_scope.issue_named(event)) === issue
+}
+
+// A lane the stream saw no launch for is not yet this run's child when the run says it is still
+// setting up: it has launched nothing at all, so any lane here is an earlier run's, or it is opening
+// this very lane. A stream with no stage on it says neither, and the lane is read as before.
+function is_lane_pending(events: ReadonlyArray<RunEvent>, issue: number): boolean {
+	const stages = events.filter((event) => is_setup(event))
+
+	if (stages.length === 0) return false
+
+	return !has_launched(events) || stages.some((stage) => names(stage, issue))
+}
+
+const run_board_setup = { is_lane_pending, read }
+
+export { run_board_setup }
+export type { SetupRead }