@joshuafolkken/kit 1.1387.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

@@ -1,21 +1,29 @@
 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 a run is at before
-// its first child launches, whether it is preparing a launch now, and which lanes are not children yet.
-// The events carry it all — nothing here infers a stage from which records exist.
+// 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 newest stage's own words while the run is starting; `undefined` from the first launch — or a
-	// drain before one — on, when the plan's counts say more than a stage does.
+	// 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
-	// The run is getting a child ready: any stage while it is starting, a lane opening after that.
-	is_preparing: boolean
+	// 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, is_preparing: false }
+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
@@ -43,13 +51,20 @@ function is_opening(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
 	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) return NO_SETUP
-	if (!has_started(events)) return { setup: stage.text, is_preparing: true }
+	if (stage === undefined || !is_standing(events, stage)) return NO_SETUP
 
-	return { setup: undefined, is_preparing: is_opening(events, stage) }
+	return { setup: stage.text, setup_ms: Date.parse(stage.at) }
 }
 
 function names(event: RunEvent, issue: number): boolean {
@@ -67,7 +82,40 @@ function is_lane_pending(events: ReadonlyArray<RunEvent>, issue: number): boolea
 	return !has_launched(events) || stages.some((stage) => names(stage, issue))
 }
 
-const run_board_setup = { is_lane_pending, read }
+// 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 { SetupRead }
+export type { LaneStage, SetupRead }

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 {

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

@@ -3,9 +3,12 @@ import {
 	IN_PROGRESS_LABEL,
 	NEEDS_DECISION_LABEL,
 } from '#scripts/issue/issue-labels'
+import type { PrChecks } from '#scripts/run/event/run-event-checks'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_board_checks } from './run-board-checks'
 import type { ClosedIssue } from './run-board-closed'
+import { run_board_lane_event, type LaneEvent } from './run-board-lane-event'
 import { run_board_phase, type Phase } from './run-board-phase'
 import { run_board_setup, type SetupRead } from './run-board-setup'
 
@@ -25,12 +28,29 @@ interface ItemStatus {
 	lane?: string | undefined
 	// Every phase the child passed while running, in order (`run-board-phase.ts`) — kept once it settles.
 	track?: ReadonlyArray<Phase> | undefined
+	// When a running child entered the phase its track ends on — the event that moved it there.
+	phase_ms?: number | undefined
+}
+
+interface LatestEvent {
+	text: string
+	at_ms: number
 }
 
 // The run as a whole, read off the same stream. The setup half is `run-board-setup.ts`'s, absent
 // where a stream carries no stage.
 interface RunActivity extends Partial<SetupRead> {
 	last_event_ms: number | undefined
+	// The newest thing the run did — its newest position, or its newest event where it has none yet —
+	// in the event's own words, and when.
+	latest?: LatestEvent | undefined
+	// When the run last did anything of its own — its newest position or stage, whichever is newer. A
+	// stage that has ended still counts: what follows it is counted from its end, not from before it.
+	idle_ms?: number | undefined
+	// Each child's newest `lane-phase` or `ship-stage`, by issue (`run-board-lane-event.ts`).
+	lane_events?: ReadonlyMap<number, LaneEvent> | undefined
+	// Each child's newest `pr-checks`, by issue (`run-board-checks.ts`).
+	pr_checks?: ReadonlyMap<number, PrChecks> | undefined
 	// The run's last position is a `stop` that names no child — the run itself ended.
 	is_stopped: boolean
 }
@@ -44,13 +64,30 @@ const ENDING_STATES: Readonly<Partial<Record<string, ItemState>>> = {
 }
 // A cut or a resume says the child is still running, on whatever phase it had reached.
 const CONTINUING_KINDS: ReadonlySet<string> = new Set([KIND.CUT, KIND.RESUME])
+// A person's restart starts the child over in a fresh session, so its track starts over too.
+const LAUNCH_KINDS: ReadonlySet<string> = new Set([KIND.CHILD_LAUNCH, KIND.RESTART])
 
 function moment(event: RunEvent): number {
 	return Date.parse(event.at)
 }
 
 function launched(event: RunEvent): ItemStatus {
-	return { state: 'running', started_ms: moment(event), track: [run_board_phase.LAUNCHED_PHASE] }
+	const at_ms = moment(event)
+
+	return {
+		state: 'running',
+		started_ms: at_ms,
+		track: [run_board_phase.LAUNCHED_PHASE],
+		phase_ms: at_ms,
+	}
+}
+
+// The status with its track moved on by `event`. The phase's start moves only where the phase the
+// track ends on changes, so a second session's first edit does not restart the time of its phase.
+function moved(previous: ItemStatus, track: ReadonlyArray<Phase>, event: RunEvent): ItemStatus {
+	const is_same = previous.phase_ms !== undefined && track.at(-1) === previous.track?.at(-1)
+
+	return { ...previous, track, phase_ms: is_same ? previous.phase_ms : moment(event) }
 }
 
 // The status a child settles into: its start and the track it had reached, so a settled row still
@@ -66,7 +103,9 @@ function ended(previous: ItemStatus | undefined, state: ItemState, event: RunEve
 }
 
 function continued(previous: ItemStatus | undefined): ItemStatus {
-	return { state: 'running', started_ms: previous?.started_ms, track: previous?.track }
+	const { started_ms, track, phase_ms } = previous ?? {}
+
+	return { state: 'running', started_ms, track, phase_ms }
 }
 
 // A stage line carrying its attempt redraws the track of any child launched on this stream — a settled
@@ -75,11 +114,12 @@ function continued(previous: ItemStatus | undefined): ItemStatus {
 function replayed(
 	previous: ItemStatus | undefined,
 	attempt: ReadonlyArray<Phase>,
+	event: RunEvent,
 ): ItemStatus | undefined {
 	if (previous === undefined) return previous
 	if (previous.track === undefined && previous.state !== 'running') return previous
 
-	return { ...previous, track: run_board_phase.replayed(previous.track ?? [], attempt) }
+	return moved(previous, run_board_phase.replayed(previous.track ?? [], attempt), event)
 }
 
 // A phase moves only a running child, so a three-word `report` stage after its merge — or a `plan`
@@ -89,18 +129,18 @@ function phased(previous: ItemStatus | undefined, event: RunEvent): ItemStatus |
 
 	if (phase === undefined || previous?.state !== 'running') return previous
 
-	return { ...previous, track: run_board_phase.history_after(previous.track ?? [], phase) }
+	return moved(previous, run_board_phase.history_after(previous.track ?? [], phase), event)
 }
 
 function advanced(previous: ItemStatus | undefined, event: RunEvent): ItemStatus | undefined {
 	const attempt = run_board_phase.attempt_of(event)
 
-	return attempt === undefined ? phased(previous, event) : replayed(previous, attempt)
+	return attempt === undefined ? phased(previous, event) : replayed(previous, attempt, event)
 }
 
 // One event folded into the status of the child it names; an event the board does not track keeps it.
 function next_status(previous: ItemStatus | undefined, event: RunEvent): ItemStatus | undefined {
-	if (event.kind === KIND.CHILD_LAUNCH) return launched(event)
+	if (LAUNCH_KINDS.has(event.kind)) return launched(event)
 
 	const ending = ENDING_STATES[event.kind]
 
@@ -247,6 +287,21 @@ function is_run_stop(event: RunEvent | undefined): boolean {
 	return event?.kind === KIND.STOP && run_event_scope.issue_named(event) === undefined
 }
 
+function latest_of(event: RunEvent | undefined): LatestEvent | undefined {
+	return event === undefined ? undefined : { text: event.text, at_ms: moment(event) }
+}
+
+function is_own(event: RunEvent): boolean {
+	return event.kind === KIND.SETUP || !run_event_stream.TRACE_KINDS.has(event.kind)
+}
+
+// A stream of traces alone has done nothing of its own yet, so its newest event stands in.
+function idle_of(events: ReadonlyArray<RunEvent>): number | undefined {
+	const own = events.findLast((event) => is_own(event)) ?? events.at(-1)
+
+	return own === undefined ? undefined : moment(own)
+}
+
 // `is_ended` is a run `run:carry --end` closed: its record says it stopped, whatever its last event
 // was.
 function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActivity {
@@ -256,6 +311,10 @@ function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActi
 	return {
 		...run_board_setup.read(events),
 		last_event_ms: last === undefined ? undefined : moment(last),
+		latest: latest_of(position ?? last),
+		idle_ms: idle_of(events),
+		lane_events: run_board_lane_event.newest_of(events),
+		pr_checks: run_board_checks.newest_of(events),
 		is_stopped: is_ended || is_run_stop(position),
 	}
 }
@@ -263,4 +322,4 @@ function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActi
 const run_board_status = { activity_of, settle_closed, statuses_of }
 
 export { run_board_status }
-export type { ItemState, ItemStatus, OpenRead, RunActivity }
+export type { ItemState, ItemStatus, LatestEvent, OpenRead, RunActivity }