@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -1,21 +1,27 @@
 import { styleText } from 'node:util'
-import { backlog_budget } from '#scripts/backlog/backlog-budget'
 import type { BudgetWait } from '#scripts/gate/core-wait'
+import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
+import { run_board_estimate } from './run-board-estimate'
 import { run_board_fit } from './run-board-fit'
+import type { FoundOf } from './run-board-found'
 import { run_board_fresh } from './run-board-fresh'
 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_now, type NowLine } from './run-board-now'
 import type { SessionOperations } from './run-board-operation-read'
+import { run_board_priority } from './run-board-priority'
+import type { ProcessGroups } from './run-board-process-groups'
 import { run_board_render_slot } from './run-board-render-slot'
+import { run_board_render_title } from './run-board-render-title'
 import type { RunActivity } from './run-board-status'
-import type { LaneUsages } from './run-board-usage'
+import type { LaneUsages, UsageScale } from './run-board-usage'
 import type { UsualTimes } from './run-board-usual'
 
 // 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. Two lines of symbols rather than sentences: the `⏰` that moves
+// events); nothing here guesses one, but the estimated finish after the progress bar, which is drawn `~`
+// as the estimate it is (`run-board-estimate.ts`). Two 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 three lines,
 // the first two 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
@@ -28,6 +34,9 @@ import type { UsualTimes } from './run-board-usual'
 
 const { HEADER_ICONS, STATE_ICONS, WORDS, bar_of, minute_of, span_of } = run_board_labels
 const { cell_of } = run_board_render_slot
+const { title_of } = run_board_render_title
+// The columns a failed read's reason is cut to, so the header keeps its line.
+const REASON_LIMIT = 40
 const { padded } = run_board_fresh
 const aged_fresh = run_board_fresh.aged
 const UNKNOWN = '-'
@@ -37,7 +46,7 @@ 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 STALE_MS = STALE_MINUTES * MS_PER_MINUTE
 const ALARM_FACTOR = 2
 const ALARM_MS = STALE_MS * ALARM_FACTOR
 const RUN_NAME = 'backlogrun'
@@ -47,6 +56,14 @@ const RUN_NAME = 'backlogrun'
 // means nothing.
 type BoardForm = 'screen' | 'chat'
 
+// What the lane cells and the processes section are drawn from, and the machine a gauge's width
+// stands for.
+interface BoardUsage {
+	lanes: LaneUsages
+	processes: ProcessGroups
+	scale: UsageScale
+}
+
 interface BoardHeader {
 	now_ms: number
 	started_ms: number
@@ -60,16 +77,27 @@ interface BoardHeader {
 	baseline_total: number | undefined
 	plan_fetched_ms: number | undefined
 	plan_failed_ms: number | undefined
+	// When the reads off this machine last failed (`run-board-gather-thread.ts`); none once they answer.
+	read_failed_ms?: number | undefined
+	// Why they failed, drawn beside the failure.
+	read_error?: string | undefined
 	// Whether a plan read is in flight.
 	is_plan_loading: boolean
 	// The machine's gauges, `undefined` before the first sample.
 	machine: MachineGauges | undefined
-	// Each running lane's CPU and memory, `undefined` where none could be read.
-	usages?: LaneUsages | undefined
+	// Each running lane's and each process group's usage, `undefined` where none could be read.
+	usages?: BoardUsage | 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
+	// How many lanes the run may hold at once, which the estimated finish stacks the waiting children on.
+	lane_limit?: number | undefined
+	// What each done row says after its time (`run-board-found.ts`); none where nothing was read.
+	found?: FoundOf | undefined
+	// Whether `JOSH_LANE_INVESTIGATION` is on; off, a merged row hides its minutes and investigation
+	// (joshuafolkken/kit#5132, joshuafolkken/kit#5194).
+	is_investigation_on: boolean
 	// The spinner's frame a running run and a running row turn, `undefined` where the output is not a
 	// terminal and they draw their still icons.
 	spinner: string | undefined
@@ -79,6 +107,8 @@ interface BoardHeader {
 	// 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
+	// A pull request's number, made a link to it where the terminal opens one (joshuafolkken/kit#4625).
+	pull_link: (number: number) => string
 }
 
 interface BoardCounts {
@@ -126,7 +156,9 @@ function quiet_mark(header: BoardHeader): RunMark {
 
 	if (header.activity.setup !== undefined) return 'setup'
 
-	return layout?.waves.length === 0 && layout.people.length > 0 ? 'human' : 'idle'
+	return layout?.queued.length === 0 && run_board_layout.people_of(layout).length > 0
+		? 'human'
+		: 'idle'
 }
 
 // The run's state, each state overriding the ones below it.
@@ -250,13 +282,13 @@ function time_parts(header: BoardHeader, mark: RunMark, now: NowLine | undefined
 	]
 }
 
-// A plan fetch is said only when it failed — the board otherwise keeps quiet about a routine read.
-function plan_warning(header: BoardHeader): string | undefined {
-	const failed = header.plan_failed_ms
-
+// A read is said only when it failed — the board otherwise keeps quiet about a routine read — and why,
+// where that is known, cut so it never pushes the line past its pane.
+function warning_of(word: string, failed: number | undefined, reason?: string): string | undefined {
 	if (failed === undefined) return undefined
+	const why = reason === undefined || reason === '' ? '' : ` ${title_of(reason, REASON_LIMIT)}`
 
-	return styleText('yellow', `⚠ ${WORDS.plan} ${minute_of(failed)}`)
+	return styleText('yellow', `${HEADER_ICONS.warning} ${word} ${minute_of(failed)}${why}`)
 }
 
 // A plan read in flight turns the spinner after ⏳ and says nothing more; a
@@ -307,20 +339,39 @@ function tally_part(counts: BoardCounts, header: BoardHeader): string {
 	return `${STATE_ICONS.merged} ${tally} ${bar}`
 }
 
-function progress_parts(counts: BoardCounts, header: BoardHeader): Array<string> {
+// The estimated finish after the bar (`run-board-estimate.ts`), once the plan says what is left to run.
+// A stopped run advances nothing, so an estimate would count down to a finish that never comes.
+function estimate_part(header: BoardHeader): string | undefined {
+	const is_moving = is_plan_read(header) && !header.activity.is_stopped
+
+	return is_moving ? run_board_estimate.part_of(header) : undefined
+}
+
+// The ⏳ count with the priorities among it (joshuafolkken/kit#4383).
+function waiting_of(counts: BoardCounts, header: BoardHeader): string {
+	return `${String(counts.remaining)}${run_board_priority.tally_of(layout_of(header))}`
+}
+
+function progress_parts(counts: BoardCounts, header: BoardHeader): Array<string | undefined> {
 	const is_read = is_plan_read(header)
 
 	return [
 		`${tally_part(counts, header)}${is_read ? plus_of(counts, header) : ''}`,
+		estimate_part(header),
 		`${STATE_ICONS.running} ${String(counts.running)}`,
-		`${STATE_ICONS.waiting} ${is_read ? String(counts.remaining) : UNKNOWN}`,
+		`${STATE_ICONS.waiting} ${is_read ? waiting_of(counts, header) : UNKNOWN}`,
 		`${STATE_ICONS.parked} ${String(counts.parked)}`,
 	]
 }
 
-// The run's progress, then what its plan read is doing.
+// The run's progress, then what its reads are doing.
 function progress_part(counts: BoardCounts, header: BoardHeader): string {
-	const parts = [...progress_parts(counts, header), loading_part(header), plan_warning(header)]
+	const parts = [
+		...progress_parts(counts, header),
+		loading_part(header),
+		warning_of(WORDS.plan, header.plan_failed_ms),
+		warning_of(WORDS.read, header.read_failed_ms, header.read_error),
+	]
 
 	return parts.filter((part) => part !== undefined).join(GAP)
 }
@@ -342,7 +393,7 @@ function now_line(counts: BoardCounts, header: BoardHeader): NowLine | undefined
 		children: running_issues(layout_of(header)),
 		running: counts.running,
 		waiting: is_plan_read(header) ? counts.remaining : undefined,
-		people: layout_of(header).people.length,
+		people: run_board_layout.people_of(layout_of(header)).length,
 	})
 }
 
@@ -375,7 +426,7 @@ function column_of(cells: ReadonlyArray<string>): Array<string> {
 }
 
 // The run's name, age and progress, then its repository, heartbeat and machine under them, then what
-// it is doing now — its time under theirs, its kind's icon under the `⚡`, the name's column left blank
+// it is doing now — its time under theirs, its kind's icon under the `💪`, the name's column left blank
 // and no label — in every state the board can be in. A stream with no event yet leaves it blank.
 function header_lines(header: BoardHeader): Array<string> {
 	const counts = counts_of(layout_of(header))
@@ -397,7 +448,26 @@ function now_legend(header: BoardHeader): string | undefined {
 	return now?.legend === undefined ? undefined : `${now.icon} ${now.legend}`
 }
 
-const run_board_header = { aged, counts_of, header_lines, is_plan_read, now_legend }
+// The estimated finish as the legend names it, on a frame that draws it alone.
+function estimate_legend(header: BoardHeader): string | undefined {
+	return estimate_part(header) === undefined ? undefined : run_board_estimate.LEGEND
+}
+
+// The third line's icon, so the legend names the phase it draws.
+function now_icon(header: BoardHeader): string | undefined {
+	return now_line(counts_of(layout_of(header)), header)?.icon
+}
+
+const run_board_header = {
+	aged,
+	counts_of,
+	estimate_legend,
+	header_lines,
+	is_plan_read,
+	now_icon,
+	now_legend,
+	warning_of,
+}
 
 export { run_board_header }
-export type { BoardCounts, BoardForm, BoardHeader }
+export type { BoardCounts, BoardForm, BoardHeader, BoardUsage }

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

@@ -0,0 +1,58 @@
+import type { SectionKey } from './run-board-fit'
+import { run_board_fold } from './run-board-fold'
+
+// The keys a live `run:board` reads: one per section, folding it or unfolding it (`run-board-fold.ts`).
+// The terminal is put in raw mode so a key arrives without Enter, which also stops it from turning
+// Ctrl-C into SIGINT — so Ctrl-C is read as a key and quits, and leaving puts the terminal back.
+
+const CTRL_C = '\u{3}'
+
+// The keyboard as the board uses it; `interrupt` is what Ctrl-C does once raw mode reads it as a key.
+interface KeyInput {
+	is_tty: boolean
+	raw: (is_raw: boolean) => void
+	listen: (on_data: (chunk: string) => void) => void
+	close: () => void
+	interrupt: () => void
+}
+
+// The sections folded so far, read at every redraw — none where no key can be read — and what puts the
+// terminal back.
+interface KeyReading {
+	folded: (() => ReadonlySet<SectionKey>) | undefined
+	stop?: (() => void) | undefined
+}
+
+// What a chunk of keys leaves folded, each key in the order typed.
+function folded_by(folded: ReadonlySet<SectionKey>, chunk: string): ReadonlySet<SectionKey> {
+	let next = folded
+
+	for (const key of chunk) next = run_board_fold.toggled(next, key)
+
+	return next
+}
+
+function read_keys(input: KeyInput | undefined): KeyReading {
+	if (input?.is_tty !== true) return { folded: undefined }
+
+	let folded: ReadonlySet<SectionKey> = new Set()
+
+	input.raw(true)
+	input.listen((chunk) => {
+		if (chunk.includes(CTRL_C)) input.interrupt()
+		else folded = folded_by(folded, chunk)
+	})
+
+	return {
+		folded: () => folded,
+		stop: () => {
+			input.raw(false)
+			input.close()
+		},
+	}
+}
+
+const run_board_keys = { CTRL_C, read_keys }
+
+export { run_board_keys }
+export type { KeyInput, KeyReading }

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

@@ -4,6 +4,8 @@ import {
 	BUGFIX_LABEL,
 	ENHANCEMENT_LABEL,
 	has_label_name,
+	PRIORITY_CRITICAL_LABEL,
+	PRIORITY_HIGH_LABEL,
 } from '#scripts/issue/issue-labels'
 import type { FiledKind } from '#scripts/run/event/run-event-filed'
 
@@ -12,12 +14,9 @@ import type { FiledKind } from '#scripts/run/event/run-event-filed'
 // there. An issue with labels from several takes the first, as the release notes do; one with none is
 // an Other Change and draws no kind.
 
-const SEMVER_MAJOR_LABEL = 'Semver-Major'
-const SEMVER_MINOR_LABEL = 'Semver-Minor'
-
 const RELEASE_KINDS: ReadonlyArray<readonly [FiledKind, ReadonlyArray<string>]> = [
-	['breaking-change', [BREAKING_CHANGE_LABEL, SEMVER_MAJOR_LABEL]],
-	['enhancement', [ENHANCEMENT_LABEL, SEMVER_MINOR_LABEL]],
+	['breaking-change', [BREAKING_CHANGE_LABEL]],
+	['enhancement', [ENHANCEMENT_LABEL]],
 	['bug', [BUGFIX_LABEL, BUG_LABEL]],
 ]
 
@@ -30,6 +29,21 @@ function kind_of(labels: ReadonlyArray<string> | undefined): FiledKind | undefin
 	return RELEASE_KINDS.find(([, names]) => names.some((name) => has_label_name(labels, name)))?.[0]
 }
 
-const run_board_kind = { KIND_ORDER, kind_of }
+// The priority a row is drawn with (joshuafolkken/kit#4383): critical over high, none for the rest.
+type BoardPriority = 'critical' | 'high'
+
+const PRIORITIES: ReadonlyArray<readonly [BoardPriority, string]> = [
+	['critical', PRIORITY_CRITICAL_LABEL],
+	['high', PRIORITY_HIGH_LABEL],
+]
+
+function priority_of(labels: ReadonlyArray<string> | undefined): BoardPriority | undefined {
+	if (labels === undefined) return undefined
+
+	return PRIORITIES.find(([, name]) => has_label_name(labels, name))?.[0]
+}
+
+const run_board_kind = { KIND_ORDER, kind_of, priority_of }
 
+export type { BoardPriority }
 export { run_board_kind }

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

@@ -1,22 +1,19 @@
 import { WriteStream } from 'node:tty'
 import { styleText } from 'node:util'
+import { figure_format } from '#scripts/lib/figure-format'
 import type { FiledKind } from '#scripts/run/event/run-event-filed'
 import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import cli_spinners from 'cli-spinners'
+import { run_board_length } from './run-board-length'
 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 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
+// where a person reads it to the minute; every length — how long the run, a row, a phase or the
+// heartbeat has run — is degree-minute-second style (`1°15′57″`), so `:` is a time of day alone and
+// the board never reads a length as a moment.
+
 // 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
@@ -40,15 +37,44 @@ const DEFAULT_FOREGROUND = `${ESC}[39m`
 const WORDS = {
 	no_run: 'no run',
 	plan: 'plan',
+	// The reads off this machine — the run's stream, its lanes and the gauges — that last failed.
+	read: 'read',
 	merged: 'merged',
 	parked: 'parked',
 	done: 'done',
 	withdrawn: 'withdrawn',
 	in_progress: 'running',
 	stopped: 'stopped',
+	paused: 'paused',
+	earlier: 'earlier run',
+	unknown: 'lane state unknown',
 	waiting: 'waiting',
+	queued: 'queued',
+	not_before: 'not before',
 	decision: 'decision',
 	waits: 'waits on',
+	// What a waiting row waits on, where the legend names its icon.
+	opening: 'opening lane',
+	installing: 'installing',
+	dispatching: 'dispatching',
+	lane: 'free lane',
+	path: 'path held',
+	named: 'named order',
+	held: 'held by triage',
+	headroom: 'memory headroom',
+	usage_limit: 'usage limit',
+	untriaged: 'untriaged',
+	solo: 'runs alone',
+	solo_ahead: 'behind solo',
+	solo_running: 'solo running',
+	// A blocker this run will not finish, which a person has to move (joshuafolkken/kit#4292).
+	on_human: 'needs a person',
+	// A lane held back by the machine-wide core budget, and why.
+	held_check: 'held',
+	memory: 'waits for memory',
+	cores: 'waits for CPU',
+	// How long a lane has run, which the lanes rule's ⏰ stands over.
+	elapsed: 'elapsed',
 	investigate: 'investigate',
 	implement: 'implement',
 	ship: 'ship',
@@ -60,21 +86,24 @@ const WORDS = {
 	followup: 'followup',
 	report: 'report',
 	failed: 'failed',
-	notes: 'findings and decisions',
+	notes: 'findings',
 	more: 'more',
 	filed: 'filed',
+	filed_run: 'filed this run',
 	breaking: 'breaking',
 	feature: 'feature',
 	fix: 'fix',
 	park: 'park',
 	note: 'note',
 	found_during: ' (found during {n})',
+	overrun: 'overrun investigation',
 	// What the run is doing now, where no stage of its own says it.
 	watching: 'watching',
 	pool_empty: 'pool empty',
 	on_person: 'waiting on a person',
 	operation: 'operation',
 	ended: 'ended',
+	estimate: 'estimated finish',
 	// The session a stopped run waits in, and what closing the board leaves.
 	resume: 'stopped — resume with',
 	keeps_running: 'Closing this screen leaves the run going · reopen with `pnpm josh backlogrun`',
@@ -105,12 +134,21 @@ const STATE_ICONS: Readonly<Record<ItemState, string>> = {
 	waiting: '⏳',
 	human: '🙋',
 	stopped: '🛑',
+	paused: '🧊',
 	withdrawn: '🚫',
+	unknown: '❔',
 }
 
 // The blocking edge, chosen on the same rule: ⛓ is a text symbol.
 const WAITS_ICON = '🔗'
 
+// A waiting row that waits on the start time its body declares rather than on a blocker
+// (joshuafolkken/kit#4079), chosen on the same rule: 🗓 is a text symbol.
+const NOT_BEFORE_ICON = '📅'
+
+// The lanes section's rule, and a waiting row that waits on a free lane.
+const LANES_ICON = '🧵'
+
 // A running row's phases as icons, chosen on the same rule; the row draws every phase it has passed,
 // so the rightmost icon is what it is doing now. Each of `josh ship`'s stages has its own; ⚓ rather
 // than 🔁, which reads as a retry.
@@ -149,6 +187,13 @@ const PHASE_WORDS: Readonly<Record<Phase, keyof Words>> = {
 // phase and state icon, so the legend names them and a row needs no word. 🆕 is a filed issue whose
 // kind is none of `FILED_KIND_ICONS`.
 const NOTES_ICON = '📌'
+// A plan row the run filed leads its title with it, in place of a findings line naming it again
+// (joshuafolkken/kit#4099).
+const FILED_RUN_MARK = '✚'
+// A merged row whose overrun investigation is running ends on it where no spinner turns
+// (joshuafolkken/kit#4772), and leads its result once it ended (joshuafolkken/kit#4818): the
+// investigate phase's own icon, for the same work.
+const OVERRUN_MARK = PHASE_ICONS.investigate
 const NOTE_ICONS: Readonly<Record<BoardNote['kind'], string>> = {
 	filed: '🆕',
 	park: STATE_ICONS.parked,
@@ -171,25 +216,32 @@ const KIND_WORDS: Readonly<Record<FiledKind, keyof Words>> = {
 	bug: 'fix',
 }
 
-// The header's gauges and marks. ⚡ rather than 🔥: a fire beside a gauge drawn green reads as an
-// alarm. ⏰ rather than ⏱, a text symbol some terminals draw one column wide: under it the 💓's digits
-// would stand a column off.
+// The header's gauges and marks. 💪 for the CPU: ⚡ is drawn too thin to see, a 🔥 beside a gauge
+// drawn green reads as an alarm, and 💻 is hard to tell from 💾. ⏰ 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: '⚡',
+	cpu: '💪',
 	memory: '🧠',
 	swap: '💾',
 	ended: '🔚',
 	loading: '⏳',
 	elapsed: '⏰',
 	heartbeat: '💓',
+	// A failed plan read: ❗ rather than ⚠, a text symbol drawn two columns wide over the blank after it.
+	warning: '❗',
+	// The estimated finish: 🎯 rather than 🏁, a done row's state icon, so the legend names each once
+	// (joshuafolkken/kit#4538).
+	estimate: '🎯',
 } as const
 
-// The kind of what the header's third line says, under the `⚡` (joshuafolkken/kit#3767): a call a
+// The kind of what the header's third line says, under the `💪` (joshuafolkken/kit#3767): a call a
 // session made, the run watching its pool, the run ended, or each of the run's own stages, keyed by the
 // stage's words before any issue. A child's event draws its row's phase icon instead. The run ended
 // draws the header's own end mark — 🏁 is already a done row's state icon.
 const NOW_ICONS = { operation: '🔧', watching: '🔭', ended: HEADER_ICONS.ended } as const
 const { STAGE, LANE_STAGE } = run_event_setup
+// The stages a lane's launch passes, which a queued row waiting on its lane leads with too.
+const LANE_STAGE_ICONS = { opening: '🚪', installing: '📥', dispatching: '📤' } as const
 const STAGE_ICONS: Readonly<Partial<Record<string, string>>> = {
 	[STAGE.STARTING]: '🚀',
 	[STAGE.PLANNING]: '📝',
@@ -197,11 +249,53 @@ const STAGE_ICONS: Readonly<Partial<Record<string, string>>> = {
 	[STAGE.JUDGING]: '🤔',
 	[STAGE.SESSION]: '💭',
 	[STAGE.NO_CHILD]: '🚫',
-	[LANE_STAGE.OPENING]: '🚪',
-	[LANE_STAGE.INSTALLING]: '📥',
-	[LANE_STAGE.DISPATCHING]: '📤',
+	[LANE_STAGE.OPENING]: LANE_STAGE_ICONS.opening,
+	[LANE_STAGE.INSTALLING]: LANE_STAGE_ICONS.installing,
+	[LANE_STAGE.DISPATCHING]: LANE_STAGE_ICONS.dispatching,
 }
 
+// What a queued or waiting row leads with (joshuafolkken/kit#4288), in place of ⏳: 📂 a path a
+// running issue holds, 📋 the declared order, ✋ a pool held for a judgment, ❓ an issue nobody has
+// judged, 🧍 a `run:solo` issue waiting for the running lanes, 🙅 a row behind it (#4294; 🚧 is a
+// held check's) and 🔒 a row a running `run:solo` issue holds (#4391), chosen on the same rule as
+// every row icon, and 🪫 the account's Claude usage limit until it resets (#4796). The rest are the
+// board's own, shared rather than copied.
+const WAIT_ICONS = {
+	usage_limit: '🪫',
+	path: '📂',
+	named: '📋',
+	held: '✋',
+	untriaged: '❓',
+	solo: '🧍',
+	solo_ahead: '🙅',
+	solo_running: '🔒',
+	lane: LANES_ICON,
+	memory: HEADER_ICONS.memory,
+	blocker: WAITS_ICON,
+	not_before: NOT_BEFORE_ICON,
+} as const
+
+// The legend's word for each icon a waiting row can lead with — a lane's stage among them. 📝, the
+// planning a row waits on, is the plan phase's icon, which the legend names already.
+const WAIT_WORDS: ReadonlyArray<readonly [icon: string, word: keyof Words]> = [
+	[LANE_STAGE_ICONS.opening, 'opening'],
+	[LANE_STAGE_ICONS.installing, 'installing'],
+	[LANE_STAGE_ICONS.dispatching, 'dispatching'],
+	[WAIT_ICONS.lane, 'lane'],
+	[WAIT_ICONS.path, 'path'],
+	[WAIT_ICONS.named, 'named'],
+	[WAIT_ICONS.held, 'held'],
+	[WAIT_ICONS.solo, 'solo'],
+	[WAIT_ICONS.solo_ahead, 'solo_ahead'],
+	[WAIT_ICONS.solo_running, 'solo_running'],
+	[WAIT_ICONS.usage_limit, 'usage_limit'],
+	[WAIT_ICONS.memory, 'headroom'],
+	[WAIT_ICONS.untriaged, 'untriaged'],
+	[WAIT_ICONS.blocker, 'waits'],
+	[STATE_ICONS.human, 'on_human'],
+	[WAIT_ICONS.not_before, 'not_before'],
+]
+
 // **The machine gauges' three colors, decided here alone**: Activity Monitor's green, yellow and red
 // in the system's dark-mode values. A palette's `green` draws blue and its `red` orange in a VSCode
 // terminal, so the normal gauge would read as the cyan plan bar and the busy one as yellow.
@@ -211,60 +305,16 @@ const GAUGE_SHADES = {
 	red: { rgb: '255;69;58', named: 'red' },
 } as const satisfies Readonly<Record<string, Shade>>
 
-function two_digits(value: number): string {
-	return String(value).padStart(CLOCK_WIDTH, CLOCK_PAD)
-}
-
-// The local wall-clock `HH:MM:SS` of a moment.
-function clock_of(ms: number): string {
-	const date = new Date(ms)
+const { two_digits, clock_of, minute_of } = figure_format
+const { minute_span_of, span_of } = run_board_length
 
-	return [date.getHours(), date.getMinutes(), date.getSeconds()]
-		.map((value) => two_digits(value))
-		.join(':')
-}
-
-// The local wall-clock `HH:MM` of a moment, for one a person reads to the minute — when a run ended, or
-// when a finding was filed.
-function minute_of(ms: number): string {
+// The local `MM-DD HH:MM` of a moment, for one that may fall on another day — when a waiting row may
+// start, in the condition column it is the widest value of (joshuafolkken/kit#4288).
+function day_minute_of(ms: number): string {
 	const date = new Date(ms)
+	const day = [date.getMonth() + 1, date.getDate()].map((value) => two_digits(value))
 
-	return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(':')
-}
-
-// 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)
-
-	return `${two_digits(minutes)}:${two_digits(seconds % SECONDS_PER_MINUTE)}`
-}
-
-// A length as its hours, and its minutes and seconds within the hour; a negative span reads as zero.
-function span_fields(ms: number): [hours: number, minutes: number, seconds: number] {
-	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)
-
-	return [hours, minutes % MINUTES_PER_HOUR, seconds % SECONDS_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 [hours, ...tail] = span_fields(ms)
-
-	return [String(hours), ...tail.map((value) => two_digits(value))].join(':')
-}
-
-// How long the run has stood at its stage, as `M:SS` with the minutes not padded, and as `span_of`'s
-// `H:MM:SS` from an hour on. It stands beside the stage's words, never in the header's time column, so
-// its one separator is not read there as a time of day.
-function stage_span_of(ms: number): string {
-	const [hours, minutes, seconds] = span_fields(ms)
-
-	return hours === 0 ? `${String(minutes)}:${two_digits(seconds)}` : span_of(ms)
+	return `${day.join('-')} ${minute_of(ms)}`
 }
 
 function is_shade(color: Paint): color is Shade {
@@ -317,6 +367,7 @@ function spinner_of(now_ms: number): string {
 
 const run_board_labels = {
 	FILED_KIND_ICONS,
+	FILED_RUN_MARK,
 	GAUGE_SHADES,
 	HEADER_ICONS,
 	KIND_BLANK,
@@ -324,6 +375,7 @@ const run_board_labels = {
 	NOTES_ICON,
 	NOTE_ICONS,
 	NOW_ICONS,
+	OVERRUN_MARK,
 	PHASE_ICONS,
 	PHASE_WORDS,
 	SPINNER_INTERVAL_MS,
@@ -332,13 +384,16 @@ const run_board_labels = {
 	WAITS_ICON,
 	WORDS,
 	bar_of,
+	LANES_ICON,
+	WAIT_ICONS,
+	WAIT_WORDS,
 	clock_of,
-	elapsed_of,
+	day_minute_of,
 	minute_of,
+	minute_span_of,
 	painted,
 	span_of,
 	spinner_of,
-	stage_span_of,
 }
 
 export { run_board_labels }