@joshuafolkken/kit 1.1387.0 → 1.1435.0

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

@@ -5,7 +5,7 @@ import { backlog_plan_read, type OpenListing, type Plan } from '#scripts/backlog
 import { backlog_waves } from '#scripts/backlog/backlog-waves'
 import type { EpicChild } from '#scripts/epic/epic-graph'
 import type { OpenIssueData } from '#scripts/git/git-schemas'
-import type { BoardPlan } from './run-board-layout'
+import { run_board_layout, type BoardPlan } from './run-board-layout'
 
 // The plan `run:board` lays the run over, scoped to what the run was asked to do.
 // **`--only`** draws the named issues alone — a named epic expanded into its children; **a named prefix
@@ -56,6 +56,7 @@ async function board_of(
 		tracked: plan.tracked,
 		context: backlog_plan_read.context_of(plan, read.listing),
 		labels: labels_of(read.listing.rows),
+		declared: plan.scope.declared,
 	}
 }
 
@@ -75,10 +76,6 @@ async function named_board(named: NamedPlan, read: PlanRead): Promise<BoardPlan
 	return await board_of({ kind: 'read', issues, cutoff: 'none' }, [], read)
 }
 
-function children_of(plan: BoardPlan): Array<EpicChild> {
-	return [...plan.waves.waves.flat(), ...plan.waves.unreached]
-}
-
 function not_held(children: ReadonlyArray<EpicChild>, held: ReadonlySet<number>): Array<EpicChild> {
 	return children.filter((child) => !held.has(child.number))
 }
@@ -86,7 +83,7 @@ function not_held(children: ReadonlyArray<EpicChild>, held: ReadonlySet<number>)
 // The named waves lead and the pool's follow, a child the named plan already holds left out of the pool
 // so a named epic's children are not drawn twice.
 function joined(lead: BoardPlan, pool: BoardPlan): BoardPlan {
-	const held = new Set(children_of(lead).map((child) => child.number))
+	const held = run_board_layout.numbers_of(lead)
 
 	return {
 		waves: {
@@ -96,6 +93,7 @@ function joined(lead: BoardPlan, pool: BoardPlan): BoardPlan {
 		tracked: new Map([...pool.tracked, ...lead.tracked]),
 		context: pool.context,
 		labels: pool.labels,
+		declared: new Map([...(pool.declared ?? []), ...(lead.declared ?? [])]),
 	}
 }
 

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

@@ -1,12 +1,20 @@
 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 { lane_capacity } from '#scripts/lane/lane-capacity'
+import { lane_registry, type LaneInfo } 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_wake } from '#scripts/run/wake/run-wake'
+import {
+	run_board_operation_read,
+	type OperationSources,
+	type SessionOperations,
+} from './run-board-operation-read'
 import { run_board_scope } from './run-board-scope'
 import { run_board_span, type BoardSpan } from './run-board-span'
+import { run_board_usual, type UsualTimes } from './run-board-usual'
 
 // What `run:board` reads locally each tick: the run's span and scope, its events and its open lanes.
 // The run is the running one, or the one that last ended until the next run begins.
@@ -23,11 +31,30 @@ interface LocalRead {
 	// 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
+	// The newest operation of each session of the run, read off the end of its log.
+	operations?: SessionOperations | undefined
+	// How many more lanes the limit allows beside the live ones; `undefined` where the limit could not
+	// be read, so nothing is said about it.
+	free_lanes?: number | undefined
+	// How long each phase usually takes, from the repository's lane ledger.
+	usual?: UsualTimes | undefined
 }
 
+async function free_lanes_of(lanes: ReadonlyArray<LaneInfo>): Promise<number | undefined> {
+	const choice = await lane_capacity.lane_limit()
+
+	if (choice.kind !== 'limit') return undefined
+
+	return lane_capacity.free_lanes(choice.limit, lane_registry.live_count(lanes))
+}
+
+const NO_SPAN: SpanHere = { span: undefined, resume: undefined, transcript: undefined }
+
 interface SpanHere {
 	span: BoardSpan | undefined
 	resume: string | undefined
+	// The parent session's transcript, where the run's record names one.
+	transcript: string | undefined
 }
 
 function span_here(repository: string): SpanHere {
@@ -38,14 +65,30 @@ function span_here(repository: string): SpanHere {
 	return {
 		span: run_board_span.span_of(read, ended, launch),
 		resume: run_board_span.resume_of(read, ended, launch),
+		transcript: read.kind === 'carried' ? read.carry.owner_transcript : undefined,
+	}
+}
+
+// Where each session of the run writes what it does: a lane's child to its dispatch log, in the lane's
+// own checkout; the parent and a judgment session to theirs, in this one.
+function sources_of(
+	repository: string,
+	lanes: ReadonlyArray<LaneInfo>,
+	transcript: string | undefined,
+): OperationSources {
+	const root = process.cwd()
+
+	return {
+		lanes: lanes.map((lane) => ({ issue: lane.issue, log: lane.output, root: lane.directory })),
+		owner: { log: transcript, root },
+		judgment: { log: run_wake.wake_log_path(repository), root },
 	}
 }
 
 // `undefined` when no run has started here.
 async function read_local(): Promise<LocalRead | undefined> {
 	const repository = await run_carry.repository_directory()
-	const { span, resume } =
-		repository === undefined ? { span: undefined, resume: undefined } : span_here(repository)
+	const { span, resume, transcript } = repository === undefined ? NO_SPAN : span_here(repository)
 
 	if (repository === undefined || span === undefined) return undefined
 
@@ -60,6 +103,9 @@ async function read_local(): Promise<LocalRead | undefined> {
 		lanes: lanes.map((lane) => lane.issue),
 		resume,
 		is_stranded: run_stranded_detect.is_stranded_at(repository),
+		operations: run_board_operation_read.read(sources_of(repository, lanes, transcript)),
+		free_lanes: await free_lanes_of(lanes),
+		usual: run_board_usual.read(repository),
 	}
 }
 

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

@@ -0,0 +1,124 @@
+import { backlog_overlap } from '#scripts/backlog/backlog-overlap'
+import type { EpicChild } from '#scripts/epic/epic-graph'
+import { epic_triage } from '#scripts/epic/epic-triage'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
+import type { RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_board_layout, type Overlay, type ReasonOf, type RowReason } from './run-board-layout'
+import { run_board_setup } from './run-board-setup'
+
+// Why each waiting row waits — pure, so the words are tested apart from the screen. A row whose lane is
+// being opened says the stage that lane is at; any other says what `backlog:next` would answer for it,
+// read off the same rules: `epic_triage` for an untriaged issue, `backlog_overlap` for a declared path a
+// running issue holds, the lane limit for a full pool. A blocker stays the row's `🔗`; only a row that
+// nobody has judged says so beside it, since judging it is what a person can do meanwhile.
+// Every word is English whatever the session language, as every other word on the board is.
+
+const { LANE_STAGE } = run_event_setup
+const NO_FREE_LANES = 0
+
+const WORDS = {
+	untriaged: 'untriaged',
+	held: 'held by triage',
+	no_lane: 'no free lane',
+	overlaps: 'overlaps',
+} as const
+
+// A lane's stage as its row says it: the event's own words, cut to what fits beside a title.
+const STAGE_WORDS: ReadonlyArray<readonly [stage: string, word: string]> = [
+	[LANE_STAGE.OPENING, 'opening lane'],
+	[LANE_STAGE.INSTALLING, 'installing'],
+	[LANE_STAGE.DISPATCHING, 'dispatching'],
+]
+
+// What the reasons are read from, beside the plan and the statuses a layout is drawn from.
+interface ReasonRead extends Overlay {
+	events: ReadonlyArray<RunEvent>
+	// How many more lanes the limit allows; `undefined` where it could not be read.
+	free_lanes: number | undefined
+	// A stopped run opens no lane, so a stage its stream ends on is not one any lane is at.
+	is_stopped: boolean
+}
+
+// What every row of one layout is weighed against, read once.
+interface Pool {
+	// An untriaged issue nothing blocks withholds every candidate (`epic-triage.ts`).
+	is_held: boolean
+	running: ReadonlyArray<number>
+}
+
+function stage_word(text: string): string | undefined {
+	return STAGE_WORDS.find(([stage]) => text.startsWith(stage))?.[1]
+}
+
+function stage_of(child: EpicChild, read: ReasonRead): RowReason | undefined {
+	const stage = read.is_stopped ? undefined : run_board_setup.lane_stage(read.events, child.number)
+	const text = stage === undefined ? undefined : stage_word(stage.text)
+
+	if (stage === undefined || text === undefined) return undefined
+
+	return { text, since_ms: stage.at_ms }
+}
+
+function is_untriaged_candidate(child: EpicChild, read: ReasonRead): boolean {
+	return !epic_triage.is_triaged(child) && !run_board_layout.is_blocked(child, read)
+}
+
+function running_of(read: ReasonRead): Array<number> {
+	return [...read.statuses]
+		.filter(([, status]) => status.state === 'running')
+		.map(([issue]) => issue)
+}
+
+function pool_of(read: ReasonRead): Pool {
+	const waiting = run_board_layout.waiting_children(read)
+
+	return {
+		is_held: waiting.some((child) => is_untriaged_candidate(child, read)),
+		running: running_of(read),
+	}
+}
+
+function overlap_of(child: EpicChild, read: ReasonRead, pool: Pool): string | undefined {
+	const { declared = new Map(), context } = read.plan
+	const holding = { holders: pool.running, repo: context.repo }
+	const clash = backlog_overlap.running_clash(child, declared, holding)
+
+	return clash === undefined
+		? undefined
+		: `${WORDS.overlaps} ${String(clash.holder)} (${clash.path})`
+}
+
+// A candidate nothing blocks, in the order `backlog:next` answers: the pool held for a judgment, then
+// a path a running issue declares, then a pool with no lane left.
+function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): string | undefined {
+	if (pool.is_held) return WORDS.held
+
+	const overlap = overlap_of(child, read, pool)
+
+	if (overlap !== undefined) return overlap
+
+	return read.free_lanes === NO_FREE_LANES ? WORDS.no_lane : undefined
+}
+
+function wait_of(child: EpicChild, read: ReasonRead, pool: Pool): RowReason | undefined {
+	if (!epic_triage.is_triaged(child)) return { text: WORDS.untriaged }
+	if (run_board_layout.is_blocked(child, read)) return undefined
+
+	const text = offer_wait(child, read, pool)
+
+	return text === undefined ? undefined : { text }
+}
+
+// What each waiting row of one layout says, the pool-wide facts read once for all of them.
+function reader(read: ReasonRead): ReasonOf {
+	const pool = pool_of(read)
+
+	return function reason_of(child: EpicChild): RowReason | undefined {
+		return stage_of(child, read) ?? wait_of(child, read, pool)
+	}
+}
+
+const run_board_reason = { reader }
+
+export { run_board_reason }
+export type { ReasonRead }

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

@@ -0,0 +1,55 @@
+import { styleText } from 'node:util'
+import type { CodeRabbitState, PrChecks } from '#scripts/run/event/run-event-checks'
+import type { TextColor } from './run-board-labels'
+
+// A followup row's pull request (joshuafolkken/kit#3770): its number, the CI checks counted by how
+// they stand and CodeRabbit's state — `PR 3765  ✓ 6  ⏳ 2  🐰 ⏳`. A count of none is left out, a
+// failure is red and a rate limit yellow, so what needs a person stands out of a row of green.
+
+const GAP = '  '
+const CHECK_ICONS = { pass: '✓', pending: '⏳', fail: '✗' } as const
+const CODERABBIT_ICON = '🐰'
+const CODERABBIT_MARKS: Readonly<Record<CodeRabbitState, string | undefined>> = {
+	running: CHECK_ICONS.pending,
+	done: CHECK_ICONS.pass,
+	'rate-limited': '⛔',
+	failed: CHECK_ICONS.fail,
+	none: undefined,
+}
+const CODERABBIT_COLORS: Readonly<Partial<Record<CodeRabbitState, TextColor>>> = {
+	'rate-limited': 'yellow',
+	failed: 'red',
+}
+// What the legend says of the part, once some row draws it.
+const LEGEND = [
+	`${CHECK_ICONS.pass} ${CHECK_ICONS.pending} ${CHECK_ICONS.fail} checks passed · pending · failed`,
+	`${CODERABBIT_ICON} CodeRabbit (${CODERABBIT_MARKS['rate-limited'] ?? ''} rate-limited)`,
+]
+
+function tinted(text: string, color: TextColor | undefined): string {
+	return color === undefined ? text : styleText(color, text)
+}
+
+function count_part(icon: string, count: number, color?: TextColor): Array<string> {
+	return count === 0 ? [] : [tinted(`${icon} ${String(count)}`, color)]
+}
+
+function coderabbit_part(state: CodeRabbitState): Array<string> {
+	const mark = CODERABBIT_MARKS[state]
+
+	return mark === undefined ? [] : [tinted(`${CODERABBIT_ICON} ${mark}`, CODERABBIT_COLORS[state])]
+}
+
+function checks_part(checks: PrChecks): string {
+	return [
+		`PR ${String(checks.pr)}`,
+		...count_part(CHECK_ICONS.pass, checks.pass),
+		...count_part(CHECK_ICONS.pending, checks.pending),
+		...count_part(CHECK_ICONS.fail, checks.fail, 'red'),
+		...coderabbit_part(checks.coderabbit),
+	].join(GAP)
+}
+
+const run_board_render_checks = { LEGEND, checks_part }
+
+export { run_board_render_checks }

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

@@ -15,7 +15,7 @@ const { FILED_KIND_ICONS, KIND_WORDS, PHASE_ICONS, PHASE_WORDS, STATE_ICONS, WAI
 	run_board_labels
 const GAP = '  '
 
-// Every phase a run passes through, in the track's own order and whatever is on screen: a row's phase
+// Every phase a run passes through, in the order a run passes them and whatever is on screen: a row's phase
 // moves between redraws, so fixed lines keep each icon where the eye last found it — six to a line, so
 // the twelve fit a narrow pane.
 const PHASES_PER_LINE = 6
@@ -59,17 +59,26 @@ function waits_legend(rows: ReadonlyArray<BoardRow>): Array<string> {
 
 // The phases on their lines and what the screen draws on one more, drawn only when it names something.
 // The header's gauges and marks read by their place, so the legend leaves them.
-// `drawn` is the icons the rows lead with.
+// `drawn` is the icons the rows lead with; `named` the activity kinds the header's third line and the
+// rows' tails draw, each named once, where their own words do not name them (joshuafolkken/kit#3767,
+// joshuafolkken/kit#3769).
 function legend_of(
 	rows: ReadonlyArray<BoardRow>,
 	drawn: ReadonlySet<string>,
 	notes: ReadonlyArray<BoardNote>,
+	named: ReadonlyArray<string> = [],
 ): Array<string> {
 	const kinds = kinds_of(rows)
 	const kind_icons = kinds.map((kind) => FILED_KIND_ICONS[kind])
 	const notes_named = run_board_render_notes.notes_legend(notes, new Set([...drawn, ...kind_icons]))
 	const kind_named = kinds.map((kind) => `${FILED_KIND_ICONS[kind]} ${WORDS[KIND_WORDS[kind]]}`)
-	const shown = [...state_legend(drawn), ...kind_named, ...waits_legend(rows), ...notes_named]
+	const shown = [
+		...new Set(named),
+		...state_legend(drawn),
+		...kind_named,
+		...waits_legend(rows),
+		...notes_named,
+	]
 	const lines = shown.length === 0 ? PHASE_LEGEND : [...PHASE_LEGEND, shown.join(GAP)]
 
 	return lines.map((line) => styleText('dim', line))

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

@@ -4,8 +4,8 @@ import type { ItemState } from './run-board-status'
 import type { LaneUsages } from './run-board-usage'
 import { run_board_usage_text } from './run-board-usage-text'
 
-// The column between a row's time and its track, one width on every row it is drawn on, so every
-// track starts in one column: a running row's CPU and memory, a finished row's finish time, and
+// The column between a row's time and its tail, one width on every row it is drawn on, so every
+// tail starts in one column: a running row's CPU and memory, a finished row's finish time, and
 // blanks on any other row.
 
 const { finish_of, text_of } = run_board_usage_text

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

@@ -0,0 +1,128 @@
+import { styleText } from 'node:util'
+import { backlog_budget } from '#scripts/backlog/backlog-budget'
+import type { PrChecks } from '#scripts/run/event/run-event-checks'
+import { run_board_header, type BoardHeader } from './run-board-header'
+import { run_board_labels, type TextColor } from './run-board-labels'
+import type { BoardRow } from './run-board-layout'
+import { run_board_now, type TimedLine } from './run-board-now'
+import type { Phase } from './run-board-phase'
+import { run_board_render_checks } from './run-board-render-checks'
+
+// The end of a running row (joshuafolkken/kit#3769): how long the child has stood at the phase its row
+// leads with, then the kind and the age of the newest thing it did. Both are the row's own `MM:SS`, the
+// minutes never carried into hours (`61:05`). The phase's time is right-aligned to the widest any
+// running row draws, so a three-digit `125:30` and a `00:40` end in one column and the age after them
+// starts in one column whichever row it is on — where the phase track before them grew with every
+// round. A settled or a waiting row draws neither.
+
+const { NOW_ICONS, elapsed_of } = run_board_labels
+// A phase past twice its usual time is drawn as long, past three times as alarming.
+const LONG_FACTOR = 2
+const ALARM_FACTOR = 3
+// The least a usual time counts as: the ledger's median for a stage of seconds (preflight, sync,
+// report) is near zero, and scaled as it is it would draw a healthy few-second stage as alarming.
+const USUAL_FLOOR_MINUTES = 2
+const USUAL_FLOOR_MS = USUAL_FLOOR_MINUTES * backlog_budget.MS_PER_MINUTE
+
+function phase_color(elapsed_ms: number, usual_ms: number | undefined): TextColor | undefined {
+	if (usual_ms === undefined) return undefined
+	const usual = Math.max(usual_ms, USUAL_FLOOR_MS)
+
+	if (elapsed_ms <= usual * LONG_FACTOR) return undefined
+
+	return elapsed_ms > usual * ALARM_FACTOR ? 'red' : 'yellow'
+}
+
+function tinted(text: string, color: TextColor | undefined): string {
+	return color === undefined ? text : styleText(color, text)
+}
+
+// The phase the row leads with and when the child got there, `undefined` where no event said when.
+function current_of(row: BoardRow): { phase: Phase; since_ms: number } | undefined {
+	const { track = [], phase_ms } = row.status ?? {}
+	const phase = track.at(-1)
+
+	return phase === undefined || phase_ms === undefined ? undefined : { phase, since_ms: phase_ms }
+}
+
+// The phase column's width: the widest phase time any running row draws in this frame, and `MM:SS`'s
+// at the least, so a row with none still blanks a column's width.
+function phase_width(header: BoardHeader): number {
+	const spans = (header.layout?.active ?? []).map((row) => {
+		const current = row.state === 'running' ? current_of(row) : undefined
+
+		return current === undefined ? 0 : elapsed_of(header.now_ms - current.since_ms).length
+	})
+
+	return Math.max(elapsed_of(0).length, ...spans)
+}
+
+// How long the child has stood at its phase, colored against the phase's usual time; blanks where no
+// event said when it got there, so the age after it still starts in its column.
+function phase_part(row: BoardRow, header: BoardHeader): string {
+	const current = current_of(row)
+	const width = phase_width(header)
+
+	if (current === undefined) return ' '.repeat(width)
+
+	const elapsed = header.now_ms - current.since_ms
+	const text = elapsed_of(elapsed).padStart(width)
+
+	return tinted(text, phase_color(elapsed, header.usual?.get(current.phase)))
+}
+
+// The newer of the child's newest operation and its newest event, read as the header's third line
+// reads it, so the two never disagree on what is newest.
+function newest_of(row: BoardRow, header: BoardHeader): TimedLine | undefined {
+	return run_board_now.newest_of({
+		operations: header.operations,
+		lane_events: header.activity.lane_events,
+		children: new Set([row.number]),
+	})
+}
+
+// The newest activity as its kind's icon and its age, aged as the `💓` is.
+function activity_part(row: BoardRow, header: BoardHeader): string | undefined {
+	const newest = newest_of(row, header)
+
+	if (newest?.since_ms === undefined) return undefined
+
+	const age = header.now_ms - newest.since_ms
+
+	return run_board_header.aged(`${newest.icon} ${elapsed_of(age)}`, age)
+}
+
+// A row in followup with its pull request's checks on the stream (joshuafolkken/kit#3770), whose end
+// draws them in place of its newest activity.
+function checks_of(row: BoardRow, header: BoardHeader): PrChecks | undefined {
+	if (row.state !== 'running' || current_of(row)?.phase !== 'followup') return undefined
+
+	return header.activity.pr_checks?.get(row.number)
+}
+
+// A running row's end, nothing for any other.
+function tail_of(row: BoardRow, header: BoardHeader): Array<string | undefined> {
+	if (row.state !== 'running') return []
+
+	const checks = checks_of(row, header)
+	const last =
+		checks === undefined ? activity_part(row, header) : run_board_render_checks.checks_part(checks)
+
+	return [phase_part(row, header), last]
+}
+
+// Whether a row draws its pull request's checks, so the legend names them.
+function is_checks_drawn(row: BoardRow, header: BoardHeader): boolean {
+	return checks_of(row, header) !== undefined
+}
+
+// Whether a row draws the operation's icon, so the legend names it.
+function is_operation_drawn(row: BoardRow, header: BoardHeader): boolean {
+	if (row.state !== 'running' || is_checks_drawn(row, header)) return false
+
+	return newest_of(row, header)?.icon === NOW_ICONS.operation
+}
+
+const run_board_render_tail = { is_checks_drawn, is_operation_drawn, tail_of }
+
+export { run_board_render_tail }

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

@@ -0,0 +1,50 @@
+import { run_board_fit } from './run-board-fit'
+import type { Link } from './run-board-link'
+import type { Thanks } from './run-board-thanks-csv'
+
+// The reviewers who helped kit, drawn above the legend as names led by one 🙏 — no label, no dimming. A name
+// with a page opens it on Cmd+click through the same OSC 8 link the issue numbers use; one without
+// is plain text. The names run on one line and wrap onto the next where the pane is too narrow,
+// always between two names; a frame no terminal bounds draws them on one line.
+
+const GAP = '  '
+const INDENT = '  '
+const MARK = '🙏 '
+
+function named(thanker: Thanks[number], link: Link): string {
+	return thanker.url === undefined ? thanker.name : link(thanker.name, thanker.url)
+}
+
+// The lines with `name` added to the last where it still fits, and on a line of its own where it does not.
+function placed(lines: ReadonlyArray<string>, name: string, columns: number): Array<string> {
+	const last = lines.at(-1)
+	const joined = `${last ?? ''}${GAP}${name}`
+
+	if (last !== undefined && run_board_fit.width_of(joined) <= columns) {
+		return [...lines.slice(0, -1), joined]
+	}
+
+	return [...lines, `${INDENT}${name}`]
+}
+
+// The names packed into lines no wider than `columns`; a name wider than the pane alone takes a line.
+function wrapped(names: ReadonlyArray<string>, columns: number): Array<string> {
+	let lines: Array<string> = []
+
+	for (const name of names) lines = placed(lines, name, columns)
+
+	return lines
+}
+
+// The lines under a blank that parts them from what is above; none with no one to thank.
+function thanks_lines(thanks: Thanks, link: Link, columns: number | undefined): Array<string> {
+	if (thanks.length === 0) return []
+
+	const [first = '', ...rest] = thanks.map((thanker) => named(thanker, link))
+
+	return ['', ...wrapped([`${MARK}${first}`, ...rest], columns ?? Infinity)]
+}
+
+const run_board_render_thanks = { thanks_lines }
+
+export { run_board_render_thanks }

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

@@ -0,0 +1,58 @@
+import { run_board_fit } from './run-board-fit'
+import { run_board_labels } from './run-board-labels'
+import type { BoardRow } from './run-board-layout'
+
+// A row's title and the reason it makes room for — pure. A title is cut to the title column; a row
+// that says why it waits keeps saying it on a narrow pane, its title giving up the columns the line
+// runs over, where every other row wraps.
+
+// The columns a terminal row gives its title: a longer one is cut to an ellipsis.
+const TITLE_LIMIT = 48
+// The least a title is cut to where a narrow pane keeps the row's reason: enough to tell rows apart.
+const TITLE_FLOOR = 8
+const ELLIPSIS = '…'
+
+// A title cut to the title column, so every time after it starts in one column.
+function title_of(title = '', limit = TITLE_LIMIT): string {
+	return title.length > limit ? `${title.slice(0, limit - 1)}${ELLIPSIS}` : title
+}
+
+// Why a waiting row waits, after its blockers; a lane's stage with how long the lane has stood at it.
+function reason_text(row: BoardRow, now_ms: number): string | undefined {
+	const { reason } = row
+
+	if (reason?.since_ms === undefined) return reason?.text
+
+	return `${reason.text} ${run_board_labels.stage_span_of(now_ms - reason.since_ms)}`
+}
+
+// The columns a line runs past the pane, for a row that says why it waits; none for any other row, and
+// none for a frame that is not kept within a pane.
+function overrun_of(text: string, row: BoardRow, columns: number | undefined): number {
+	if (columns === undefined || row.reason === undefined) return 0
+
+	return Math.max(0, run_board_fit.width_of(text) - columns)
+}
+
+// The title column once it has given up `overrun` columns, never under the floor: the blanks a short
+// title is padded with go first, so a title that fits keeps whole.
+function narrowed_limit(overrun: number): number {
+	return Math.max(TITLE_FLOOR, TITLE_LIMIT - overrun)
+}
+
+// A row's line as `draw` draws it at a title limit: at the title column's, or at a narrower one where
+// that line would run past the pane and the row has a reason to keep.
+function fitted(
+	row: BoardRow,
+	columns: number | undefined,
+	draw: (title_limit: number) => string,
+): string {
+	const text = draw(TITLE_LIMIT)
+	const overrun = overrun_of(text, row, columns)
+
+	return overrun === 0 ? text : draw(narrowed_limit(overrun))
+}
+
+const run_board_render_title = { ELLIPSIS, TITLE_LIMIT, fitted, reason_text, title_of }
+
+export { run_board_render_title }