@joshuafolkken/kit 1.1383.0 → 1.1435.0

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

@@ -4,10 +4,9 @@ import {
 	type NotesPart,
 	type PlanLine,
 	type PlanSection,
-	type RowYield,
 	type TerminalSize,
-	type YieldStage,
 } from './run-board-fit'
+import { run_board_fresh } from './run-board-fresh'
 import { run_board_header, type BoardHeader } from './run-board-header'
 import { run_board_labels } from './run-board-labels'
 import {
@@ -16,13 +15,17 @@ import {
 	type BoardRow,
 	type WaveEntry,
 } from './run-board-layout'
+import type { Link } from './run-board-link'
 import type { BoardNote } from './run-board-notes'
-import type { Phase } from './run-board-phase'
+import { run_board_render_checks } from './run-board-render-checks'
 import { run_board_render_legend } from './run-board-render-legend'
 import { run_board_render_notes } from './run-board-render-notes'
 import { run_board_render_slot, type UsageSlot } from './run-board-render-slot'
-import type { ItemState } from './run-board-status'
-import { run_board_track } from './run-board-track'
+import { run_board_render_tail } from './run-board-render-tail'
+import { run_board_render_thanks } from './run-board-render-thanks'
+import { run_board_render_title } from './run-board-render-title'
+import { run_board_row_yield } from './run-board-row-yield'
+import type { Thanks } from './run-board-thanks-csv'
 
 // The whole `run:board` screen as lines — pure, so what a person sees is tested apart from the
 // terminal. The header says where the run is; the sections below it follow the plan's order; the
@@ -31,14 +34,14 @@ import { run_board_track } from './run-board-track'
 // what differs between rows. Every word is English whatever the session language: one set of words
 // reads the same on every board.
 
-const { FILED_KIND_ICONS, KIND_BLANK, NOTES_ICON, PHASE_ICONS, STATE_ICONS, WAITS_ICON, WORDS } =
+const { FILED_KIND_ICONS, KIND_BLANK, NOTES_ICON, NOW_ICONS, PHASE_ICONS, STATE_ICONS } =
 	run_board_labels
+const { WAITS_ICON, WORDS } = run_board_labels
 const { clock_of, elapsed_of } = run_board_labels
 const { NOTE_LIMIT } = run_board_render_notes
 const { cell_of, column_width, slot_of, usage_slot } = run_board_render_slot
-// The columns a terminal row gives its title: a longer one is cut to an ellipsis.
-const TITLE_LIMIT = 48
-const ELLIPSIS = '…'
+const { ELLIPSIS, TITLE_LIMIT, fitted, reason_text, title_of } = run_board_render_title
+const { padded } = run_board_fresh
 const GAP = '  '
 const INDENT = '  '
 const BRANCH = '     ├ '
@@ -59,6 +62,9 @@ interface BoardView extends FrameBounds {
 	notes: ReadonlyArray<BoardNote>
 	// The session a stopped run resumes from.
 	resume?: string | undefined
+	// The reviewers thanked above the legend, and the link a name with a page is wrapped in.
+	thanks?: Thanks | undefined
+	link?: Link | undefined
 }
 
 // What every row of one frame is drawn with: the header, how wide the time column is, so a three-digit
@@ -69,11 +75,10 @@ interface RowFrame {
 	time_width: number
 	usage: UsageSlot | undefined
 	slot_width: number
-}
-
-// A title cut to the title column, so every time after it starts in one column.
-function title_of(title = ''): string {
-	return title.length > TITLE_LIMIT ? `${title.slice(0, TITLE_LIMIT - 1)}${ELLIPSIS}` : title
+	// The columns a row's title is cut to: the title column's, or fewer where a row gives some up.
+	title_limit: number
+	// The pane's width where the frame is kept within one.
+	columns: number | undefined
 }
 
 // A row drawn before the plan is read has no title yet, and says so.
@@ -105,45 +110,37 @@ function time_of(row: BoardRow, now_ms: number): string | undefined {
 	return elapsed === undefined ? undefined : elapsed_of(elapsed)
 }
 
-// The phases a row's track draws — every one the child passed while running, kept once it settles.
-function drawn_phases(row: BoardRow): ReadonlyArray<Phase> {
-	return row.status?.track ?? []
-}
-
-// A row's phases as its track, drawn last: it grows with every round, so the
-// columns before it stay where they are whatever its length. A settled row's ends on its state icon.
-function track_text(row: BoardRow): string | undefined {
-	const phases = drawn_phases(row)
-
-	return phases.length === 0 ? undefined : run_board_track.track_of(phases, row.state)
-}
-
 function waits_of(row: BoardRow, header: BoardHeader): string | undefined {
 	if (row.waits.length === 0) return undefined
 
 	return `${WAITS_ICON} ${row.waits.map((reference) => header.link(reference)).join(', ')}`
 }
 
-// The title is padded to the title column where a time or the usage column follows it, so the times
-// form one column; a row with no time draws blanks in its place before the usage column.
-function timed_parts(
+// A running row's part that changed at `at_ms`, emphasized while fresh (`run-board-fresh.ts`) — its
+// start and its phase; a settled row's are long past.
+function running_fresh(
 	row: BoardRow,
-	frame: RowFrame,
-	is_slotted: boolean,
-): Array<string | undefined> {
-	const time = time_of(row, frame.header.now_ms)
-
-	const title = title_of(row_title(row, frame.header))
+	text: string,
+	at_ms: number | undefined,
+	header: BoardHeader,
+): string {
+	return row.state === 'running' ? run_board_fresh.since(text, at_ms, header) : text
+}
 
-	if (time === undefined && !is_slotted) return [title]
+// The title padded to the title column and the time to the time column — blanks where a row has none —
+// so the times form one column, and what follows them starts in one column on every row.
+function timed_parts(row: BoardRow, frame: RowFrame): Array<string> {
+	const time = time_of(row, frame.header.now_ms) ?? ''
+	const title = title_of(row_title(row, frame.header), frame.title_limit)
+	const fresh = running_fresh(row, time, row.status?.started_ms, frame.header)
 
-	return [title.padEnd(TITLE_LIMIT), (time ?? '').padStart(frame.time_width)]
+	return [title.padEnd(frame.title_limit), padded(time, frame.time_width, fresh)]
 }
 
-// A running row leads with the icon of the phase it is in now — the rightmost
-// icon of its track — and with 🔄 while its track draws none yet.
+// A running row leads with the icon of the phase it is in now — the last its track reached — and
+// with 🔄 while it has reached none yet.
 function state_icon(row: BoardRow): string {
-	const current = row.state === 'running' ? drawn_phases(row).at(-1) : undefined
+	const current = row.state === 'running' ? row.status?.track?.at(-1) : undefined
 
 	return current === undefined ? STATE_ICONS[row.state] : PHASE_ICONS[current]
 }
@@ -156,15 +153,24 @@ function indent_of(prefix: string, row: BoardRow, header: BoardHeader): string {
 	return `${header.spinner}${prefix.slice(1)}`
 }
 
-// A row's usage column where the frame draws one, padded to one width on every row so every track
-// starts in one column. A plan row the run has not touched has no time, usage or track to align, so it
-// draws none and what it waits on stays beside its title.
+// A row's usage column as drawn: a settled row's finish time emphasized while it is fresh.
+function slot_text(row: BoardRow, usage: UsageSlot, header: BoardHeader): string | undefined {
+	const slot = slot_of(row, usage, header.now_ms)
+	const ended = row.state === 'running' ? undefined : row.status?.ended_ms
+
+	return slot === undefined ? slot : run_board_fresh.since(slot, ended, header)
+}
+
+// A row's usage column where the frame draws one, padded to one width on every row so every tail
+// starts in one column. A plan row the run has not touched draws blanks in its place, so what it waits
+// on starts in the tail's column.
 function cell_text(row: BoardRow, frame: RowFrame): string | undefined {
 	const { usage, slot_width } = frame
 
-	if (usage === undefined || slot_width === 0 || row.status === undefined) return undefined
+	if (usage === undefined || slot_width === 0) return undefined
+	if (row.status === undefined) return ' '.repeat(slot_width)
 
-	return cell_of(slot_of(row, usage, frame.header.now_ms), slot_width)
+	return cell_of(slot_text(row, usage, frame.header), slot_width)
 }
 
 function joined(parts: ReadonlyArray<string | undefined>): string {
@@ -175,52 +181,39 @@ function joined(parts: ReadonlyArray<string | undefined>): string {
 // ends at its icon, so what follows keeps its usual gap.
 function lead_of(row: BoardRow, header: BoardHeader, title: string): string {
 	const kind = row.kind === undefined ? KIND_BLANK : FILED_KIND_ICONS[row.kind]
-	const lead = `${state_icon(row)} ${header.link(String(row.number))} ${kind}`
+	const icon = running_fresh(row, state_icon(row), row.status?.phase_ms, header)
+	const lead = `${icon} ${header.link(String(row.number))} ${kind}`
 
 	return title === '' ? lead : `${lead} ${title}`
 }
 
-// A row up to its usage column — the columns that stay where they are whatever the track's length.
+// A row up to its usage column — the columns that stay where they are on every row.
 function head_text(row: BoardRow, frame: RowFrame): string {
-	const cell = cell_text(row, frame)
-	const [title = '', ...time] = timed_parts(row, frame, cell !== undefined)
+	const [title = '', time] = timed_parts(row, frame)
 
-	return joined([lead_of(row, frame.header, title), ...time, cell])
+	return joined([lead_of(row, frame.header, title), time, cell_text(row, frame)])
 }
 
-// Every row carries its state's icon, a waiting one ⏳ too; a row with nothing
-// after its padded columns ends where its text does.
+// Every row carries its state's icon, a waiting one ⏳ too; a running row ends on its tail
+// (`run-board-render-tail.ts`), and a row with nothing after its padded columns ends where its text does.
 function row_text(row: BoardRow, frame: RowFrame): string {
-	return joined([head_text(row, frame), track_text(row), waits_of(row, frame.header)]).trimEnd()
-}
-
-// The stage each state's row gives way in when the pane is short.
-const YIELD_STAGES: Readonly<Record<ItemState, YieldStage>> = {
-	merged: 'finished',
-	done: 'finished',
-	waiting: 'pending',
-	human: 'pending',
-	parked: 'parked',
-	stopped: 'parked',
-	running: 'running',
-}
-
-// A running row is as old as its start; a settled one as its end, or its start where it has none.
-function aged_ms(row: BoardRow): number | undefined {
-	const started = row.status?.started_ms
-
-	return row.state === 'running' ? started : (row.status?.ended_ms ?? started)
-}
+	const { header } = frame
+	const tail = run_board_render_tail.tail_of(row, header)
+	const notes = [waits_of(row, header), reason_text(row, header.now_ms)]
 
-function yield_of(row: BoardRow): RowYield {
-	return { stage: YIELD_STAGES[row.state], at_ms: aged_ms(row) }
+	return joined([head_text(row, frame), ...tail, ...notes]).trimEnd()
 }
 
 // A plan line that draws one issue row, and one that draws none — a blank, a rule, an epic's own line.
 function row_line(prefix: string, row: BoardRow, frame: RowFrame): PlanLine {
-	const text = `${indent_of(prefix, row, frame.header)}${row_text(row, frame)}`
+	const indent = indent_of(prefix, row, frame.header)
+	const text = fitted(
+		row,
+		frame.columns,
+		(title_limit) => `${indent}${row_text(row, { ...frame, title_limit })}`,
+	)
 
-	return { text, row: yield_of(row) }
+	return { text, row: run_board_row_yield.yield_of(row) }
 }
 
 function bare(text: string): PlanLine {
@@ -281,8 +274,8 @@ function time_width(header: BoardHeader): number {
 }
 
 // Whether every row's usage column still fits one terminal line — measured as the deepest, an epic's
-// child — where a frame is kept within a terminal. The track after it is left out: it grows without
-// bound, so one long history would otherwise take the usage column off every row.
+// child — where a frame is kept within a terminal. The tail and the notes after it are left out: a
+// row's reason makes room for itself, so one long reason would otherwise take the column off every row.
 function is_usage_fitting(
 	rows: ReadonlyArray<BoardRow>,
 	frame: RowFrame,
@@ -309,6 +302,8 @@ function frame_of(
 		time_width: time_width(header),
 		usage,
 		slot_width: usage === undefined ? 0 : column_width(rows, usage, header.now_ms),
+		title_limit: TITLE_LIMIT,
+		columns: size?.columns,
 	}
 
 	return is_usage_fitting(rows, frame, size) ? frame : { ...frame, usage: undefined }
@@ -352,6 +347,18 @@ function resume_lines(resume: string | undefined): Array<string> {
 	return ['', `${STATE_ICONS.human} ${WORDS.resume}${GAP}claude --resume ${resume}`]
 }
 
+// The activity kinds the legend names: the header's third line's, 🔧 where a row's tail draws it, and
+// a followup row's checks (joshuafolkken/kit#3770).
+function activity_named(header: BoardHeader, rows: ReadonlyArray<BoardRow>): Array<string> {
+	const now = run_board_header.now_legend(header)
+	const is_drawn = rows.some((row) => run_board_render_tail.is_operation_drawn(row, header))
+	const operation = is_drawn ? [`${NOW_ICONS.operation} ${WORDS.operation}`] : []
+	const is_checks = rows.some((row) => run_board_render_tail.is_checks_drawn(row, header))
+	const checks = is_checks ? run_board_render_checks.LEGEND : []
+
+	return [...(now === undefined ? [] : [now]), ...operation, ...checks]
+}
+
 // No legend is drawn before a plan is read: there are no rows whose symbols it would name.
 function legend_lines(header: BoardHeader, notes: ReadonlyArray<BoardNote>): Array<string> {
 	const { layout } = header
@@ -360,8 +367,16 @@ function legend_lines(header: BoardHeader, notes: ReadonlyArray<BoardNote>): Arr
 
 	const rows = run_board_layout.rows_of(layout)
 	const drawn = new Set(rows.map((row) => state_icon(row)))
+	const named = activity_named(header, rows)
+
+	return ['', ...run_board_render_legend.legend_of(rows, drawn, notes, named)]
+}
+
+// Names with no link where no terminal opens one: a frame with no `link` draws them plain.
+function thanks_part(view: BoardView): Array<string> {
+	const link = view.link ?? ((text: string): string => text)
 
-	return ['', ...run_board_render_legend.legend_of(rows, drawn, notes)]
+	return run_board_render_thanks.thanks_lines(view.thanks ?? [], link, view.size?.columns)
 }
 
 // A live frame is kept within its terminal; any other is drawn whole.
@@ -378,6 +393,7 @@ function render(view: BoardView): Array<string> {
 		above,
 		plan: plan_sections(header, view.size),
 		notes: notes_part(notes, header),
+		thanks: thanks_part(view),
 		legend: legend_lines(header, notes),
 		footer: view.footer ?? [],
 	}

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

@@ -0,0 +1,32 @@
+import type { RowYield, YieldStage } from './run-board-fit'
+import type { BoardRow } from './run-board-layout'
+import type { ItemState } from './run-board-status'
+
+// When an issue row gives way to a short pane (`run-board-fit.ts`): the stage its state yields in,
+// and how old it is within that stage.
+
+// The stage each state's row gives way in when the pane is short.
+const YIELD_STAGES: Readonly<Record<ItemState, YieldStage>> = {
+	merged: 'finished',
+	done: 'finished',
+	waiting: 'pending',
+	human: 'pending',
+	parked: 'parked',
+	stopped: 'parked',
+	running: 'running',
+}
+
+// A running row is as old as its start; a settled one as its end, or its start where it has none.
+function aged_ms(row: BoardRow): number | undefined {
+	const started = row.status?.started_ms
+
+	return row.state === 'running' ? started : (row.status?.ended_ms ?? started)
+}
+
+function yield_of(row: BoardRow): RowYield {
+	return { stage: YIELD_STAGES[row.state], at_ms: aged_ms(row) }
+}
+
+const run_board_row_yield = { yield_of }
+
+export { run_board_row_yield }

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

@@ -0,0 +1,121 @@
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
+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 the run is at 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
+const { STAGE } = run_event_setup
+
+interface SetupRead {
+	// The stage the run itself is working at, in the stage's own words: any stage while the run is
+	// starting; from the first launch — or a drain before one — on, a lane opening or a judgment session.
+	// `undefined` where the run is at none.
+	setup: string | undefined
+	// When the run entered that stage — its event's own time, so how long the run has stood there is
+	// counted from a record; `undefined` wherever `setup` is.
+	setup_ms: number | undefined
+}
+
+const NO_SETUP: SetupRead = { setup: undefined, setup_ms: undefined }
+
+// The stages of a hand-back to a session. Only the supervisor's next hand-off ends one, whatever the
+// session writes to the stream meanwhile.
+const JUDGMENT_STAGES: ReadonlySet<string> = new Set([STAGE.JUDGING, STAGE.SESSION])
+
+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
+}
+
+// Whether the run is at `stage` now: at any stage while it is starting; after that only at one it is
+// itself working through.
+function is_standing(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
+	if (!has_started(events) || JUDGMENT_STAGES.has(stage.text)) return true
+
+	return is_opening(events, stage)
+}
+
+function read(events: ReadonlyArray<RunEvent>): SetupRead {
+	const stage = events.findLast((event) => is_setup(event))
+
+	if (stage === undefined || !is_standing(events, stage)) return NO_SETUP
+
+	return { setup: stage.text, setup_ms: Date.parse(stage.at) }
+}
+
+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))
+}
+
+// A stage of one lane's launch, as its event wrote it, and when the lane entered it.
+interface LaneStage {
+	text: string
+	at_ms: number
+}
+
+// What the run did for `issue`: a stage of its lane's launch, or a position naming it.
+function is_step_for(event: RunEvent, issue: number): boolean {
+	if (!names(event, issue)) return false
+
+	return is_setup(event) || !run_event_stream.TRACE_KINDS.has(event.kind)
+}
+
+// A stage that names no issue: a hand-off to the driver, a hand-back to a session, or a launch that
+// returned without a child. A lane's launch runs inside one driver pass, so a newer one of these says
+// that launch has returned.
+function is_run_stage(event: RunEvent): boolean {
+	return is_setup(event) && run_event_scope.issue_named(event) === undefined
+}
+
+// The stage `issue`'s own lane is at: the newest stage naming it, until the run does anything else for
+// that issue — its launch, or whatever ended the attempt — or writes a stage naming none, which is all
+// a launch that left no child puts on the stream: the driver says so itself, since a refusal it waits
+// out is followed by no hand-off. Read per issue, so two lanes opened side by side each stand at their
+// own stage whatever the other has reached.
+function lane_stage(events: ReadonlyArray<RunEvent>, issue: number): LaneStage | undefined {
+	const step = events.findLast((event) => is_run_stage(event) || is_step_for(event, issue))
+
+	if (step === undefined || !is_setup(step) || !names(step, issue)) return undefined
+
+	return { text: step.text, at_ms: Date.parse(step.at) }
+}
+
+const run_board_setup = { is_lane_pending, lane_stage, read }
+
+export { run_board_setup }
+export type { LaneStage, SetupRead }

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

@@ -1,3 +1,4 @@
+import type { PendingLaunch } from '#scripts/backlog/backlogrun-launch'
 import type { CarryRead } from '#scripts/run/carry/run-carry'
 import type { EndedRun } from '#scripts/run/carry/run-carry-ended'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
@@ -27,9 +28,40 @@ function ended_span(ended: EndedRun | undefined): BoardSpan | undefined {
 	return { invocation: ended.invocation, started_ms, ended_ms }
 }
 
+// A run `josh backlogrun` launched and its parent has not claimed yet: it has no carry record, so the
+// launch record is the only one that says a run is here and since when.
+function launch_span(launch: PendingLaunch | undefined): BoardSpan | undefined {
+	const started_ms = launch === undefined ? undefined : moment_of(launch.started_at)
+
+	if (launch === undefined || started_ms === undefined) return undefined
+
+	return { invocation: launch.invocation, started_ms, ended_ms: undefined }
+}
+
+// With no carry record: the run on its way, else the one that last ended. **A launch older than that
+// end is the ended run's own** — its parent outlives `run:carry --end` for a moment — so it never
+// redraws a finished run as one starting.
+function idle_span(
+	ended: EndedRun | undefined,
+	launch: PendingLaunch | undefined,
+): BoardSpan | undefined {
+	const last = ended_span(ended)
+	const coming = launch_span(launch)
+
+	if (coming === undefined) return last
+
+	return (last?.ended_ms ?? 0) >= coming.started_ms ? last : coming
+}
+
 // The running run wins over the ended one, so a run that begins replaces the finished board at once.
-function span_of(read: CarryRead, ended: EndedRun | undefined): BoardSpan | undefined {
-	if (read.kind !== 'carried') return read.kind === 'none' ? ended_span(ended) : undefined
+// **The launch's start is the carry's**: `run:carry --begin` inherits it for the parent the launch
+// started, so the clock does not restart when the record appears.
+function span_of(
+	read: CarryRead,
+	ended: EndedRun | undefined,
+	launch?: PendingLaunch,
+): BoardSpan | undefined {
+	if (read.kind !== 'carried') return read.kind === 'none' ? idle_span(ended, launch) : undefined
 
 	const started_ms = moment_of(read.carry.started_at)
 
@@ -38,12 +70,22 @@ function span_of(read: CarryRead, ended: EndedRun | undefined): BoardSpan | unde
 	return { invocation: read.carry.invocation, started_ms, ended_ms: undefined }
 }
 
-// The session a person resumes a stopped run from: only while the ended run is
-// the one drawn, and only when it stopped rather than finished. A run that begins hides it at once.
-function resume_of(read: CarryRead, ended: EndedRun | undefined): string | undefined {
-	if (read.kind !== 'none' || ended?.stopped === undefined) return undefined
+// Whether the span drawn with no carry record is the ended run's, rather than a launch's.
+function is_ended_drawn(ended: EndedRun | undefined, launch: PendingLaunch | undefined): boolean {
+	return idle_span(ended, launch)?.ended_ms !== undefined
+}
 
-	return ended.session
+// The session a person resumes a stopped run from: only while the ended run is
+// the one drawn, and only when it stopped rather than finished. A run that begins — or is on its way —
+// hides it at once.
+function resume_of(
+	read: CarryRead,
+	ended: EndedRun | undefined,
+	launch?: PendingLaunch,
+): string | undefined {
+	if (read.kind !== 'none' || !is_ended_drawn(ended, launch)) return undefined
+
+	return ended?.stopped === undefined ? undefined : ended.session
 }
 
 function is_within(event: RunEvent, span: BoardSpan): boolean {

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

@@ -9,6 +9,7 @@ import type { Link } from './run-board-link'
 import type { MachineGauges, MachineMark } from './run-board-machine'
 import type { LocalRead } from './run-board-read'
 import type { Spot } from './run-board-spin'
+import type { Thanks } from './run-board-thanks-csv'
 import type { LaneUsages, UsageMark } from './run-board-usage'
 
 // What a `run:board` redraw reads through and folds forward, shared by the
@@ -38,6 +39,8 @@ interface BoardPorts {
 	// Records that a progress report was just given, as `run:progress --mark` does, so the next scheduled
 	// one waits a full interval from here.
 	mark: () => Promise<void>
+	// The reviewers' roster (`run-board-thanks-read.ts`); none where the frame thanks nobody — the chat.
+	read_thanks?: (() => Promise<Thanks>) | undefined
 	// Sends one chat frame off-screen, for `--every` alone.
 	push: (frame: string) => Promise<void>
 	// Runs `leave` however the process ends: a normal exit, Ctrl+C or SIGTERM.
@@ -79,6 +82,10 @@ interface BoardState {
 	// them.
 	usage: UsageMark | undefined
 	usages: LaneUsages | undefined
+	// The reviewers drawn above the legend, the read of them in flight, and when it was last launched.
+	thanks: Thanks
+	thanks_fetch: Fetch<Thanks> | undefined
+	thanks_attempted_ms: number | undefined
 }
 
 const FRESH_STATE: BoardState = {
@@ -101,6 +108,9 @@ const FRESH_STATE: BoardState = {
 	spots: [],
 	usage: undefined,
 	usages: undefined,
+	thanks: [],
+	thanks_fetch: undefined,
+	thanks_attempted_ms: undefined,
 }
 
 function is_due(last_ms: number | undefined, interval_ms: number, now_ms: number): boolean {