@joshuafolkken/kit 1.1471.0 → 1.1784.0

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

@@ -4,15 +4,24 @@ import type { WavePlan } from '#scripts/backlog/backlog-waves'
 import type { EpicChild } from '#scripts/epic/epic-graph'
 import type { IssueReference } from '#scripts/epic/epic-reference'
 import { issue_cite } from '#scripts/issue/issue-cite'
-import { has_label_name, NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
+import {
+	has_label_name,
+	NEEDS_DECISION_LABEL,
+	RUN_SOLO_LABEL,
+	RUN_STALLED_LABEL,
+} from '#scripts/issue/issue-labels'
 import type { FiledKind } from '#scripts/run/event/run-event-filed'
-import { run_board_kind } from './run-board-kind'
+import { run_stalled } from '#scripts/run/park/run-stalled'
+import { run_board_earlier, type EarlierLanes } from './run-board-earlier'
+import { run_board_kind, type BoardPriority } from './run-board-kind'
 import type { ItemState, ItemStatus } from './run-board-status'
 
 // The plan with each issue's status laid over it — pure, so the order the board
-// draws is tested apart from the screen. **The order is the plan's**: the waves are `backlog_waves.build`'s,
-// the same play-forward `backlog:plan --waves` prints, so a merge, a park or a new arrival that changes the
-// plan changes the board with it. The plan leaves out what a run already holds or has closed, so those
+// draws is tested apart from the screen. **The order is the plan's**: the queued rows run in
+// `backlog_waves.build`'s order, the same play-forward `backlog:plan --waves` prints, so a merge, a park or
+// a new arrival that changes the plan changes the board with it. The board draws them as one queue, not
+// as waves: a running batch dispatches each row once a lane is free and its paths are, never wave by
+// wave (joshuafolkken/kit#4137). The plan leaves out what a run already holds or has closed, so those
 // rows come from the stream instead, in the leading active section.
 //
 // **An epic and its children are a tree; every other dependency is not.** A child an opted-in epic
@@ -29,41 +38,64 @@ interface BoardPlan {
 	// The paths each issue's body declares (`Plan.scope.declared`), which a waiting row is checked
 	// against a running one by; a plan read without them checks none.
 	declared?: Declared | undefined
+	// The issues the classifier withholds for a person (`EpicNextResult.blocked_on_people`) — a blocker
+	// this run will not finish among them — whose waiting row leads with 🙋.
+	withheld?: ReadonlySet<number> | undefined
 }
 
-// Why a waiting row waits, or the stage its lane's launch is at, in the board's own words.
+// Why a waiting row waits, or the stage its lane's launch is at, as one value its row only draws
+// (joshuafolkken/kit#4288): the icon it leads with in place of ⏳, the condition column's value, and
+// what follows its title. A parked, withdrawn or stalled row draws its tail alone.
 interface RowReason {
-	text: string
-	// When the row entered a stage, where the reason is one — how long it has stood there is counted
-	// from it.
+	icon?: string | undefined
+	// The condition column's figure — a lane count, a memory reading, a start time.
+	value?: string | undefined
+	// The issues the wait names, in place of a figure: the first in the condition column, with
+	// `+<rest>` where the rest follow its title.
+	issues?: ReadonlyArray<string> | undefined
+	tail?: string | undefined
+	// When the row entered a stage, where the reason is one — the condition column counts how long it
+	// has stood there from it.
 	since_ms?: number | undefined
+	// The start time its body declares and the row waits on, which orders the 📅 rows.
+	not_before_ms?: number | undefined
 }
 
-// What a waiting child's row says after its blockers; `undefined` says nothing.
-type ReasonOf = (child: EpicChild) => RowReason | undefined
+// What a waiting child's row says, given the blockers still standing for it; `undefined` says nothing.
+type ReasonOf = (child: EpicChild, waits: ReadonlyArray<string>) => RowReason | undefined
 
 interface BoardRow {
 	number: number
 	title: string | undefined
 	// The release category its labels place it in (joshuafolkken/kit#3577), none for an Other Change.
 	kind: FiledKind | undefined
+	// The priority label it carries (joshuafolkken/kit#4383), none for a normal one.
+	priority?: BoardPriority | undefined
 	state: ItemState
 	status: ItemStatus | undefined
 	// The standing blockers this row still waits on, as the plan names them.
 	waits: ReadonlyArray<string>
-	// Why the row waits beyond its blockers (`run-board-reason.ts`); a row the run has touched has none.
+	// Why the row waits beyond its blockers (`run-board-reason.ts`), or why a parked or withdrawn row
+	// ended; any other row the run has touched has none.
 	reason?: RowReason | undefined
+	// An earlier run's lane (`run-board-earlier.ts`): drawn as its status says, marked 🧳.
+	is_earlier?: boolean | undefined
+	// A touched child carrying `run:solo`, which nothing else starts beside while it runs.
+	is_solo?: boolean | undefined
 }
 
-type WaveEntry =
+type QueuedEntry =
 	| { kind: 'row'; row: BoardRow }
 	| { kind: 'epic'; epic: number; title: string | undefined; rows: Array<BoardRow> }
 
 interface BoardLayout {
 	active: ReadonlyArray<BoardRow>
-	waves: ReadonlyArray<ReadonlyArray<WaveEntry>>
+	queued: ReadonlyArray<QueuedEntry>
 	people: ReadonlyArray<BoardRow>
 	unreached: ReadonlyArray<BoardRow>
+	// The earlier run's lanes that still hold a place under the limit, and the lanes with no record —
+	// drawn after the run's own lanes, and no row the header counts.
+	earlier?: ReadonlyArray<BoardRow> | undefined
 }
 
 // What an active row is named and classified by — each issue's title and labels.
@@ -72,6 +104,8 @@ interface RowRead {
 	labels: ReadonlyMap<number, ReadonlyArray<string>>
 }
 
+const NO_READ: RowRead = { titles: new Map(), labels: new Map() }
+
 interface Overlay {
 	plan: BoardPlan
 	statuses: ReadonlyMap<number, ItemStatus>
@@ -82,7 +116,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)
@@ -107,46 +141,137 @@ function is_blocked(child: EpicChild, overlay: Overlay): boolean {
 	return child.blocked_by.some((edge) => is_waiting_on(edge, overlay))
 }
 
+// A stalled row's right end names the action that resumes it (`run-stalled.ts`), with no event to
+// name its cause.
+function stalled_reason(number: number): RowReason {
+	return { tail: run_stalled.row_text(number) }
+}
+
+// Why a waiting row waits, or what resumes a stalled one.
+function plan_reason(
+	child: EpicChild,
+	state: ItemState,
+	overlay: Drawn,
+	waits: ReadonlyArray<string>,
+): RowReason | undefined {
+	if (state === 'stopped') return stalled_reason(child.number)
+
+	return state === 'waiting' ? overlay.reason_of?.(child, waits) : undefined
+}
+
 function plan_row(child: EpicChild, state: ItemState, overlay: Drawn): BoardRow {
 	const { context } = overlay.plan
 	const waits = child.blocked_by
 		.filter((edge) => is_waiting_on(edge, overlay))
 		.map((edge) => reference_of(edge, context.repo))
-	const reason = state === 'waiting' ? overlay.reason_of?.(child) : undefined
+	const reason = plan_reason(child, state, overlay, waits)
 
 	return {
 		...(reason !== undefined && { reason }),
 		number: child.number,
 		title: context.titles.get(child.number),
 		kind: run_board_kind.kind_of(child.labels),
+		priority: run_board_kind.priority_of(child.labels),
 		state,
 		status: undefined,
 		waits,
 	}
 }
 
-function started_of(row: BoardRow): number {
-	return row.status?.started_ms ?? Infinity
+// A child that has ended for good — drawn in the done section rather than the leading one.
+const FINISHED_STATES: ReadonlySet<ItemState> = new Set(['merged', 'done', 'withdrawn'])
+
+function is_finished(state: ItemState): boolean {
+	return FINISHED_STATES.has(state)
 }
 
-// Every child the run has touched, in the order each started.
-function active_rows(statuses: ReadonlyMap<number, ItemStatus>, read: RowRead): Array<BoardRow> {
-	const rows = [...statuses].map(([number, status]) => ({
+// Running rows first, then the parked and stopped ones, then the finished ones. A row parked on a
+// decision ranks among the parked, though the render draws it in its own 🙋 section.
+function rank_of(row: BoardRow): number {
+	if (row.state === 'running') return 0
+
+	return is_finished(row.state) ? Infinity : 1
+}
+
+// A finished row sorts by its end, the newest first and one with none last; any other by its start.
+function key_of(row: BoardRow): number {
+	const { started_ms = Infinity, ended_ms = -Infinity } = row.status ?? {}
+
+	return is_finished(row.state) ? -ended_ms : started_ms
+}
+
+function compared(left: number, right: number): number {
+	if (left === right) return 0
+
+	return left < right ? -1 : 1
+}
+
+function active_order(left: BoardRow, right: BoardRow): number {
+	return compared(rank_of(left), rank_of(right)) || compared(key_of(left), key_of(right))
+}
+
+// The states a row its labels say stalled can be drawn in: 🛑, and 💤 where its last park event was
+// bare — `run:merge`'s park of a child already labelled (`on_parked`) after the ship-stop cap's.
+const STALLED_STATES: ReadonlySet<ItemState> = new Set(['stopped', 'parked'])
+
+// A row its labels say stalled, which no ending event explains.
+function is_stalled(status: ItemStatus, labels: ReadonlyArray<string> = []): boolean {
+	return STALLED_STATES.has(status.state) && has_label_name(labels, RUN_STALLED_LABEL)
+}
+
+// The reason a parked or withdrawn row draws where ⏳ draws why it waits — its ending event's own —
+// and a stalled row the action that resumes it.
+function ending_reason(
+	number: number,
+	status: ItemStatus,
+	labels: ReadonlyArray<string> | undefined,
+): Pick<BoardRow, 'reason'> {
+	if (status.reason !== undefined) return { reason: { tail: status.reason } }
+
+	return is_stalled(status, labels) ? { reason: stalled_reason(number) } : {}
+}
+
+// A park waiting on a person's decision (joshuafolkken/kit#4099) — the one answer the 🙋 decision
+// section and the findings section read a park reason by.
+function is_decision(reason: string | undefined): boolean {
+	return reason?.includes(NEEDS_DECISION_LABEL) === true
+}
+
+function solo_flag(labels: ReadonlyArray<string> = []): Pick<BoardRow, 'is_solo'> {
+	return has_label_name(labels, RUN_SOLO_LABEL) ? { is_solo: true } : {}
+}
+
+// A child parked on a decision is a 🙋 row: it waits on a person, as an untouched `needs-decision`
+// child does, and the section it is drawn in already says why, so its row draws no reason.
+function touched_row(number: number, status: ItemStatus, read: RowRead): BoardRow {
+	const is_asked = status.state === 'parked' && is_decision(status.reason)
+	const labels = read.labels.get(number)
+
+	return {
+		...(!is_asked && ending_reason(number, status, labels)),
+		...solo_flag(labels),
 		number,
 		title: read.titles.get(number),
-		kind: run_board_kind.kind_of(read.labels.get(number)),
-		state: status.state,
+		kind: run_board_kind.kind_of(labels),
+		priority: run_board_kind.priority_of(labels),
+		state: is_asked ? 'human' : status.state,
 		status,
 		waits: [],
-	}))
+	}
+}
 
-	return rows.toSorted((left, right) => started_of(left) - started_of(right))
+// Every child the run has touched: the running ones and then the parked ones in the order each
+// started, then the finished ones from the newest end.
+function active_rows(statuses: ReadonlyMap<number, ItemStatus>, read: RowRead): Array<BoardRow> {
+	const rows = [...statuses].map(([number, status]) => touched_row(number, status, read))
+
+	return rows.toSorted(active_order)
 }
 
 // The epic row carries its own title, read from the same open listing as its children's — an opted-in
 // epic is an open issue.
 function place_in_epic(
-	entries: Array<WaveEntry>,
+	entries: Array<QueuedEntry>,
 	epic: number,
 	overlay: Drawn,
 	row: BoardRow,
@@ -162,22 +287,21 @@ function is_untouched(child: EpicChild, overlay: Overlay): boolean {
 	return !overlay.statuses.has(child.number)
 }
 
-function is_human(child: EpicChild): boolean {
-	return has_label_name(child.labels, NEEDS_DECISION_LABEL)
-}
+// A plan row waits, unless it waits on a person's decision — the one wait the board marks — or the run
+// stalled on it mechanically (`run:stalled`), which is drawn as the stop it is, never as a decision.
+function plan_state(child: EpicChild): ItemState {
+	if (has_label_name(child.labels, NEEDS_DECISION_LABEL)) return 'human'
 
-// A wave row waits, unless it waits on a person's decision — the one wait the board marks.
-function wave_state(child: EpicChild): ItemState {
-	return is_human(child) ? 'human' : 'waiting'
+	return has_label_name(child.labels, RUN_STALLED_LABEL) ? 'stopped' : 'waiting'
 }
 
-// One wave, its rows in the plan's order, an epic's children gathered under the epic where the first
+// The queue, its rows in the plan's order, an epic's children gathered under the epic where the first
 // of them falls.
-function wave_entries(wave: ReadonlyArray<EpicChild>, overlay: Drawn): Array<WaveEntry> {
-	const entries: Array<WaveEntry> = []
+function queued_entries(queue: ReadonlyArray<EpicChild>, overlay: Drawn): Array<QueuedEntry> {
+	const entries: Array<QueuedEntry> = []
 
-	for (const child of wave) {
-		const row = plan_row(child, wave_state(child), overlay)
+	for (const child of queue) {
+		const row = plan_row(child, plan_state(child), overlay)
 		const epic = overlay.plan.tracked.get(child.number)
 
 		if (epic === undefined) entries.push({ kind: 'row', row })
@@ -187,12 +311,21 @@ function wave_entries(wave: ReadonlyArray<EpicChild>, overlay: Drawn): Array<Wav
 	return entries
 }
 
-function unreached_rows(overlay: Drawn, is_people: boolean): Array<BoardRow> {
-	const state: ItemState = is_people ? 'human' : 'waiting'
+// A row waiting on no start time keeps its plan place ahead of every 📅 row, which follow from the
+// earliest start (joshuafolkken/kit#4104).
+function start_order(left: BoardRow, right: BoardRow): number {
+	const { not_before_ms: left_ms = -Infinity } = left.reason ?? {}
+	const { not_before_ms: right_ms = -Infinity } = right.reason ?? {}
 
+	return compared(left_ms, right_ms)
+}
+
+function unreached_rows(overlay: Drawn, is_people: boolean): Array<BoardRow> {
 	return overlay.plan.waves.unreached
-		.filter((child) => is_untouched(child, overlay) && is_human(child) === is_people)
-		.map((child) => plan_row(child, state, overlay))
+		.filter((child) => is_untouched(child, overlay))
+		.map((child) => plan_row(child, plan_state(child), overlay))
+		.filter((row) => (row.state === 'human') === is_people)
+		.toSorted(start_order)
 }
 
 // Every issue the plan holds, wave or unreached.
@@ -201,10 +334,10 @@ function children_of(plan: BoardPlan): Array<EpicChild> {
 }
 
 // The children whose rows wait on the run rather than on a person: the run has not touched them, and
-// no decision is asked of anyone.
+// it is neither parked for a decision nor stalled.
 function waiting_children(overlay: Overlay): Array<EpicChild> {
 	return children_of(overlay.plan).filter(
-		(child) => is_untouched(child, overlay) && !is_human(child),
+		(child) => is_untouched(child, overlay) && plan_state(child) === 'waiting',
 	)
 }
 
@@ -212,59 +345,105 @@ function layout_of(
 	plan: BoardPlan,
 	statuses: ReadonlyMap<number, ItemStatus>,
 	reason_of?: ReasonOf,
+	earlier: EarlierLanes = run_board_earlier.NO_EARLIER,
 ): BoardLayout {
 	const overlay = { plan, statuses, reason_of }
-	const waves = plan.waves.waves.map((wave) =>
-		wave_entries(
-			wave.filter((child) => is_untouched(child, overlay)),
-			overlay,
-		),
-	)
+	const queue = plan.waves.waves.flat().filter((child) => is_untouched(child, overlay))
+	const read = { titles: plan.context.titles, labels: plan.labels }
 
 	return {
-		active: active_rows(statuses, { titles: plan.context.titles, labels: plan.labels }),
-		waves: waves.filter((wave) => wave.length > 0),
+		active: active_rows(statuses, read),
+		queued: queued_entries(queue, overlay),
 		people: unreached_rows(overlay, true),
 		unreached: unreached_rows(overlay, false),
+		earlier: run_board_earlier.rows_of(earlier, statuses, read),
 	}
 }
 
-const EMPTY_LAYOUT: BoardLayout = { active: [], waves: [], people: [], unreached: [] }
+const EMPTY_LAYOUT: BoardLayout = { active: [], queued: [], people: [], unreached: [] }
 
 // The run's own children before the plan is read: the stream and the lanes are local and read at
 // once, so the rows, their states and how long each has run are drawn while GitHub answers; the titles
 // and every issue the run has not touched wait for the plan.
-function local_layout_of(statuses: ReadonlyMap<number, ItemStatus>): BoardLayout {
+function local_layout_of(
+	statuses: ReadonlyMap<number, ItemStatus>,
+	earlier: EarlierLanes = run_board_earlier.NO_EARLIER,
+	read: RowRead = NO_READ,
+): BoardLayout {
 	return {
 		...EMPTY_LAYOUT,
-		active: active_rows(statuses, { titles: new Map(), labels: new Map() }),
+		active: active_rows(statuses, read),
+		earlier: run_board_earlier.rows_of(earlier, statuses, read),
 	}
 }
 
-// The run's scope a lane is checked against.
+// The run's scope a lane is checked against — its running issues too, which no wave holds.
 function numbers_of(plan: BoardPlan): ReadonlySet<number> {
-	return new Set(children_of(plan).map((child) => child.number))
+	const running = plan.waves.running ?? []
+
+	return new Set([...children_of(plan), ...running].map((child) => child.number))
 }
 
 // Every row the layout draws, an epic's children among them — what the header counts and the legend reads.
 function rows_of(layout: BoardLayout): Array<BoardRow> {
-	const waves = layout.waves
-		.flat()
-		.flatMap((entry) => (entry.kind === 'row' ? [entry.row] : entry.rows))
+	const queued = layout.queued.flatMap((entry) => (entry.kind === 'row' ? [entry.row] : entry.rows))
+
+	return [...layout.active, ...queued, ...layout.people, ...layout.unreached]
+}
+
+// Every row the frame draws — the counted ones and the earlier run's lanes — what the legend reads.
+function drawn_rows(layout: BoardLayout): Array<BoardRow> {
+	return [...rows_of(layout), ...(layout.earlier ?? [])]
+}
+
+// Every row waiting on a person's decision: the touched children parked on one, then the untouched
+// `needs-decision` children — what the 🙋 section draws and the header counts as a person's.
+function people_of(layout: BoardLayout): Array<BoardRow> {
+	const asked = layout.active.filter((row) => row.state === 'human')
+
+	return [...asked, ...layout.people]
+}
+
+// The run's own rows `apart` does not name, then the earlier run's lanes still holding a place.
+function lane_rows(layout: BoardLayout, apart: ReadonlyArray<BoardRow>): Array<BoardRow> {
+	const own = layout.active.filter((row) => !apart.includes(row))
+
+	return [...own, ...(layout.earlier ?? [])]
+}
+
+// The lanes section's rows: those neither finished nor waiting on a person's decision.
+function lanes_drawn(layout: BoardLayout): Array<BoardRow> {
+	const finished = layout.active.filter((row) => is_finished(row.state))
+
+	return lane_rows(layout, [...finished, ...people_of(layout)])
+}
+
+// The parked children the findings section says the park of: still parked on the board, their rows
+// drawing no park reason of their own. A child a person released or closed is no row of this
+// (joshuafolkken/kit#4127), and a reason its row draws is not said twice.
+function listed_parks(layout: BoardLayout): ReadonlySet<number> {
+	const parks = layout.active.filter((row) => row.state === 'parked' && row.reason === undefined)
 
-	return [...layout.active, ...waves, ...layout.people, ...layout.unreached]
+	return new Set(parks.map((row) => row.number))
 }
 
 const run_board_layout = {
 	EMPTY_LAYOUT,
+	drawn_rows,
 	is_blocked,
+	is_decision,
+	is_finished,
 	is_settled,
+	lane_rows,
+	lanes_drawn,
 	layout_of,
+	listed_parks,
 	local_layout_of,
+	people_of,
 	numbers_of,
 	rows_of,
 	waiting_children,
 }
 
 export { run_board_layout }
-export type { BoardLayout, BoardPlan, BoardRow, Overlay, ReasonOf, RowReason, WaveEntry }
+export type { BoardLayout, BoardPlan, BoardRow, Overlay, QueuedEntry, ReasonOf, RowRead, RowReason }

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

@@ -0,0 +1,52 @@
+import { figure_format } from '#scripts/lib/figure-format'
+import { MS_PER_MINUTE, MS_PER_SECOND, SECONDS_PER_MINUTE } from '#scripts/lib/timeouts'
+
+// Every length `run:board` draws — how long the run, a row, a phase or the heartbeat has run — in
+// degree-minute-second style (`1°15′57″`), so a length never shares the clock's `:`. Re-exported by
+// `run-board-labels.ts`, where the board's words and clock are read from.
+
+const MINUTES_PER_HOUR = 60
+// A length's units — hours, minutes and seconds — so a length never shares the clock's `:`.
+const SPAN_UNITS = { hours: '°', minutes: '′', seconds: '″' } as const
+// The seconds a length rounded to its minute draws, which `minute_span_of` leaves off.
+const ZERO_SECONDS = `00${SPAN_UNITS.seconds}`
+
+const { two_digits } = figure_format
+
+// A length as its hours, and its minutes and seconds within the hour, each its count with the mark it
+// is drawn with; a negative span reads as zero.
+function span_fields(ms: number): Array<{ value: number; unit: 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)
+
+	return [
+		{ value: hours, unit: SPAN_UNITS.hours },
+		{ value: minutes % MINUTES_PER_HOUR, unit: SPAN_UNITS.minutes },
+		{ value: seconds % SECONDS_PER_MINUTE, unit: SPAN_UNITS.seconds },
+	]
+}
+
+// **Every length the board draws**, in degree-minute-second style (`26″`, `3′27″`, `1°15′57″`): the
+// leading unit not padded and a zero one dropped down to the seconds, the units after it two digits;
+// a negative span reads as zero.
+function span_of(ms: number): string {
+	const fields = span_fields(ms)
+	const lead = fields.findIndex((field, index) => field.value > 0 || index === fields.length - 1)
+	const [first, ...rest] = fields.slice(lead)
+	const head = first === undefined ? '' : `${String(first.value)}${first.unit}`
+
+	return head + rest.map((field) => `${two_digits(field.value)}${field.unit}`).join('')
+}
+
+// A length rounded up to its minute, in `span_of`'s style without the seconds (`25′`, `1°05′`), never
+// under a minute: an estimate drawn to the second would claim a precision it does not have.
+function minute_span_of(ms: number): string {
+	const minutes = Math.max(1, Math.ceil(ms / MS_PER_MINUTE))
+
+	return span_of(minutes * MS_PER_MINUTE).slice(0, -ZERO_SECONDS.length)
+}
+
+const run_board_length = { minute_span_of, span_of }
+
+export { run_board_length }

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

@@ -1,11 +1,12 @@
 import { machine_capacity, type MachineSample } from '#scripts/gate/machine-capacity'
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { run_board_labels, type Paint } from './run-board-labels'
 
 // The machine line of `run:board`: whether a quiet run is stuck or only slow on a machine that has
 // run out of room.
 //
 // **The reading is the gate's own** (`machine-capacity.ts`), so the board shows what the core budget
-// admits against. 🔥 is the busy share of the CPU between two samples; 🧠 the kernel's memory pressure,
+// admits against. 💪 is the busy share of the CPU between two samples; 🧠 the kernel's memory pressure,
 // never a GB figure that would disagree with Activity Monitor's "memory used"; 💾 how fast pages are
 // swapped, never how much swap is held — macOS grows its swap files, so a usage share reads near 100%
 // and the amount itself does no harm. A figure that needs two samples is not drawn on the first, and a
@@ -18,7 +19,6 @@ import { run_board_labels, type Paint } from './run-board-labels'
 
 const { GAUGE_SHADES, HEADER_ICONS, bar_of, painted } = run_board_labels
 const PERCENT = 100
-const MS_PER_SECOND = 1000
 const PERCENT_WIDTH = '100%'.length
 const RATE_WIDTH = '3.1M/s'.length
 // Below this a rate keeps one decimal, so `0.4M/s` is not drawn as `0M/s`.
@@ -33,6 +33,7 @@ const CPU_RED = 90
 const MEMORY_YELLOW = 70
 const MEMORY_RED = 85
 const SWAP_FULL_MB_PER_S = 20
+const SWAP_YELLOW_MB_PER_S = 1
 const SWAP_RED_MB_PER_S = 10
 
 type Alert = 'normal' | 'yellow' | 'red'
@@ -101,7 +102,7 @@ const SPECS = {
 		icon: HEADER_ICONS.swap,
 		normal: undefined,
 		full: SWAP_FULL_MB_PER_S,
-		yellow: 1,
+		yellow: SWAP_YELLOW_MB_PER_S,
 		red: SWAP_RED_MB_PER_S,
 		format: rate_text,
 	},
@@ -199,12 +200,15 @@ function line_of(gauges: MachineGauges | undefined, width = 0): string | undefin
 const run_board_machine = {
 	CPU_YELLOW,
 	GAP,
+	MEMORY_RED,
 	MEMORY_YELLOW,
 	PERCENT_WIDTH,
+	SWAP_RED_MB_PER_S,
+	SWAP_YELLOW_MB_PER_S,
 	gauges_of,
 	line_of,
 	percent_text,
-	threshold_alert,
+	rate_text,
 }
 
 export { run_board_machine }

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { run_board_cli } from './run-board-cli'
+
+// The `josh run:board` entry, kept apart from `run-board-cli.ts` because other modules import that
+// one: a bundle is one file, so a main guard there would fire for every command that carries it
+// (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await run_board_cli.run(process.argv.slice(ARGV_OFFSET))
+}