@joshuafolkken/kit 1.3092.0 → 1.3101.0

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

@@ -109,6 +109,8 @@ interface BoardLayout {
 	// 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
+	// The root checkout's single run beside the run, drawn above its lanes and no row the header counts.
+	root?: { name: string; row: BoardRow } | undefined
 }
 
 // What an active row is named and classified by — each issue's title and labels.
@@ -382,9 +384,10 @@ function rows_of(layout: BoardLayout): Array<BoardRow> {
 	return [...layout.active, ...queued_rows(layout), ...layout.people, ...layout.unreached]
 }
 
-// Every row the frame draws — the counted ones and the earlier run's lanes — what the legend reads.
+// Every row the frame draws — the root checkout's single run's, 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 ?? [])]
+	return [layout.root?.row ?? [], rows_of(layout), layout.earlier ?? []].flat()
 }
 
 // Every row waiting on a person's decision: the touched children parked on one, then the untouched
@@ -395,11 +398,12 @@ function people_of(layout: BoardLayout): Array<BoardRow> {
 	return [...asked, ...layout.people]
 }
 
-// The run's own rows `apart` does not name, then the earlier run's lanes still holding a place.
+// The root checkout's single run's row, 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 ?? [])]
+	return [layout.root?.row ?? [], own, layout.earlier ?? []].flat()
 }
 
 // The lanes section's rows: those neither finished nor waiting on a person's decision.
@@ -420,6 +424,7 @@ function listed_parks(layout: BoardLayout): ReadonlySet<number> {
 
 const run_board_layout = {
 	EMPTY_LAYOUT,
+	active_order,
 	drawn_rows,
 	is_blocked,
 	is_decision: run_board_human.is_decision,

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

@@ -1,20 +1,17 @@
 import { backlog_drive_memory } from '#scripts/backlog/backlog-drive-memory'
 import type { NamedPlan } from '#scripts/backlog/backlog-plan'
 import { backlog_ready } from '#scripts/backlog/backlog-ready'
-import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
 import { lane_held_stats } from '#scripts/lane/lane-held-stats'
 import { lane_ledger } from '#scripts/lane/lane-ledger'
 import type { TableRead } from '#scripts/lane/lane-process-table'
 import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
 import { lane_state, type LaneStateRecord } from '#scripts/lane/lane-state'
 import { stamped_memo } from '#scripts/lib/stamped-memo'
-import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
-import { run_carry_ended } from '#scripts/run/carry/run-carry-ended'
+import { run_carry, type RunCarry } from '#scripts/run/carry/run-carry'
 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_event_tail } from '#scripts/run/event/run-event-tail'
 import { run_merge_usage_limit } from '#scripts/run/merge/run-merge-usage-limit'
-import { run_stranded_detect } from '#scripts/run/run-stranded-detect'
 import { run_wake } from '#scripts/run/wake/run-wake'
 import { run_board_found, type FoundOf } from './run-board-found'
 import { run_board_lane_result } from './run-board-lane-result'
@@ -26,10 +23,10 @@ import {
 } from './run-board-operation-read'
 import type { ProcessRoots } from './run-board-process-groups'
 import type { QuotaProvider } from './run-board-quota-read'
-import { run_board_roots } from './run-board-roots'
 import { run_board_scope } from './run-board-scope'
-import { run_board_single } from './run-board-single'
+import { run_board_single, type EndedRoot, type RootRun } from './run-board-single'
 import { run_board_span, type BoardSpan } from './run-board-span'
+import { run_board_span_read } from './run-board-span-read'
 import { run_board_throughput, type ThroughputRow } from './run-board-throughput'
 import { run_board_usual, type UsualTimes } from './run-board-usual'
 
@@ -42,6 +39,10 @@ interface LocalRead {
 	ended_ms: number | undefined
 	// The single run's name the header draws; `undefined` for a `backlogrun` (`run-board-single.ts`).
 	run_name?: string | undefined
+	// The root checkout's single run beside a carried run, drawn above its lanes.
+	root?: RootRun | undefined
+	// The root checkout's single runs a merge ended inside the run, drawn in `✅ done`.
+	ended_roots?: ReadonlyArray<EndedRoot> | undefined
 	// What the run was asked to do, from its invocation.
 	scope: NamedPlan
 	events: ReadonlyArray<RunEvent>
@@ -103,27 +104,6 @@ interface LocalRead {
 	found?: FoundOf | undefined
 }
 
-const NO_SPAN: SpanHere = {
-	span: undefined,
-	resume: undefined,
-	transcript: undefined,
-	roots: {},
-	carry: undefined,
-	is_stranded: false,
-	is_session_active: false,
-}
-
-interface SpanHere {
-	span: BoardSpan | undefined
-	resume: string | undefined
-	// The parent session's transcript, where the run's record names one.
-	transcript: string | undefined
-	roots: ProcessRoots
-	carry: RunCarry | undefined
-	is_stranded: boolean
-	is_session_active: boolean
-}
-
 // The main work tree, resolved once: it does not move while the board is open, and resolving it runs a
 // `git` subprocess the redraw would wait on (joshuafolkken/kit#4263). A failed resolve is forgotten,
 // so a `git` that timed out once is asked again on the next redraw rather than failing every one.
@@ -142,44 +122,6 @@ async function main_root(): Promise<string> {
 	}
 }
 
-// Every process the run's record names is asked of `table`, the redraw's own `ps` snapshot — only once
-// a run is found, so a repository with no run waits on no `ps`.
-async function recorded_span_here(
-	repository: string,
-	table: TableRead | undefined,
-	read: CarryRead,
-): Promise<SpanHere> {
-	const ended = run_carry_ended.read_ended(run_carry_ended.ended_path(repository))
-	const launch = backlogrun_launch.pending_launch(repository)
-	const span = run_board_span.span_of(read, ended, launch)
-
-	if (span === undefined) return NO_SPAN
-
-	const same_process = await run_board_roots.same_in(table)
-	const stranded_ports = run_stranded_detect.ports_with(same_process)
-
-	return {
-		span,
-		resume: run_board_span.resume_of(read, ended, launch),
-		transcript: read.kind === 'carried' ? read.carry.owner_transcript : undefined,
-		roots: run_board_roots.roots_of(repository, read, same_process),
-		is_session_active: run_board_roots.session_is_active(repository, read, same_process),
-		carry: read.kind === 'carried' ? read.carry : undefined,
-		is_stranded: run_stranded_detect.is_stranded_at(repository, stranded_ports),
-	}
-}
-
-// A single run this checkout holds is the one drawn (`run-board-single.ts`), before the ended run and,
-// outside a lane, before the carried one; it names no process.
-async function span_here(repository: string, table: TableRead | undefined): Promise<SpanHere> {
-	const read = run_carry.read_carry(run_carry.carry_path(repository))
-	const single = await run_board_single.span_here(read.kind !== 'none')
-
-	return single === undefined
-		? await recorded_span_here(repository, table, read)
-		: { ...NO_SPAN, span: single }
-}
-
 // 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(
@@ -327,11 +269,16 @@ async function span_events_here(
 	}
 }
 
+type RootFields = Pick<LocalRead, 'root' | 'ended_roots'>
+
+// The span's own fields, with the root checkout's single runs beside it.
 function span_fields(
 	span: BoardSpan,
-): Pick<LocalRead, 'started_ms' | 'ended_ms' | 'scheduler_provider' | 'run_name'> {
+	root: RootFields,
+): Pick<LocalRead, 'started_ms' | 'ended_ms' | 'scheduler_provider' | 'run_name'> & RootFields {
 	const run_name = run_board_single.name_of(span.invocation)
 	const times = {
+		...root,
 		started_ms: span.started_ms,
 		ended_ms: span.ended_ms,
 		...(run_name !== undefined && { run_name }),
@@ -342,12 +289,25 @@ function span_fields(
 	return { ...times, scheduler_provider: span.scheduler_provider === 'openai' ? 'codex' : 'claude' }
 }
 
+// The root checkout's single run beside the span, and its runs a merge ended inside it.
+async function roots_here(
+	span: BoardSpan,
+	root: BoardSpan | undefined,
+	events: ReadonlyArray<RunEvent>,
+): Promise<RootFields> {
+	const ended_roots = await run_board_single.ended_here(span)
+
+	return root === undefined
+		? { ended_roots }
+		: { root: run_board_single.root_of(root, events), ended_roots }
+}
+
 // `undefined` when no run has started here. The lane count reads `table`, the redraw's process
 // snapshot, so it agrees with the usage columns.
 async function read_local(table?: TableRead): Promise<LocalRead | undefined> {
 	const repository = await run_carry.repository_directory()
-	const { span, resume, transcript, roots, carry, is_stranded, is_session_active } =
-		repository === undefined ? NO_SPAN : await span_here(repository, table)
+	const { span, root, resume, transcript, roots, carry, is_stranded, is_session_active } =
+		await run_board_span_read.span_here(repository, table)
 
 	if (repository === undefined || span === undefined) return undefined
 
@@ -356,7 +316,7 @@ async function read_local(table?: TableRead): Promise<LocalRead | undefined> {
 	const lane_read = await lanes_here(lanes, repository, events, span.started_ms)
 
 	return {
-		...span_fields(span),
+		...span_fields(span, await roots_here(span, root, events)),
 		scope: run_board_scope.scope_of(span.invocation, carry?.added),
 		...(await span_events_here(events, span, table, carry)),
 		throughput: run_board_throughput.rows_of(events, Date.now()),

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

@@ -20,7 +20,8 @@ import { run_board_usage_text, type CellLimits } from './run-board-usage-text'
 const { HEADER_ICONS } = run_board_labels
 const { cell_widths, cells_of, lane_limits } = run_board_usage_text
 const { columns_rule } = run_board_render_section
-const { ELAPSED_START, LANES_LABEL, USAGE_START, column_offset, lane_label } = run_board_render_lead
+const { ELAPSED_START, LANES_LABEL, USAGE_START, column_offset, lane_label, root_label } =
+	run_board_render_lead
 const { width_of } = run_board_fit
 const { columns_cut } = run_board_render_title
 const { reasons_of } = run_board_seat
@@ -150,20 +151,17 @@ function seat_lines(header: BoardHeader, columns: number | undefined): Array<Pla
 	}))
 }
 
-// The run's own rows under the lanes rule, ⏰ over the run's time and the usage labels over their
-// cells where they are drawn, then the empty seats' reasons.
-function lanes_section(
-	rows: ReadonlyArray<PlanLine>,
+// A section of lane rows under `label`'s rule, ⏰ over the run's time and the usage labels over their
+// cells where they are drawn; none without a line.
+function rows_section(
+	lines: Array<PlanLine>,
+	label: string,
 	cells: LaneCells | undefined,
 	header: BoardHeader,
-	columns?: number,
 ): Array<PlanSection> {
-	const lines = [...rows, ...seat_lines(header, columns)]
-
 	if (lines.length === 0) return []
 
 	const offset = column_offset(header)
-	const label = lane_label(header)
 	const elapsed = { label: HEADER_ICONS.elapsed, start: ELAPSED_START + offset }
 	const usage = cells === undefined ? [] : label_columns(USAGE_START + offset, cells.gauge)
 	const rule = columns_rule(label, [elapsed, ...usage])
@@ -171,6 +169,25 @@ function lanes_section(
 	return [{ head: ['', rule], lines, label, key: 'lanes' }]
 }
 
+// The root checkout's single run's row, the first of `rows` (`run_board_layout.lane_rows`), under its
+// own `🏠` rule above the run's lanes (joshuafolkken/kit#7524); then the run's own rows under the lanes
+// rule and the empty seats' reasons.
+function lanes_section(
+	rows: ReadonlyArray<PlanLine>,
+	cells: LaneCells | undefined,
+	header: BoardHeader,
+	columns?: number,
+): Array<PlanSection> {
+	const root = header.layout?.root
+	const root_count = root === undefined ? 0 : 1
+	const lanes = [...rows.slice(root_count), ...seat_lines(header, columns)]
+
+	return [
+		...rows_section(rows.slice(0, root_count), root_label(root?.name ?? ''), cells, header),
+		...rows_section(lanes, lane_label(header), cells, header),
+	]
+}
+
 const run_board_render_lanes = {
 	COLUMN_LABELS,
 	LANES_LABEL,

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

@@ -33,10 +33,18 @@ const ELAPSED_START =
 // The column a lane row's usage cells start at, after the lead and one blank; the processes rows' too.
 const USAGE_START = ELAPSED_START + TIME_WIDTH + SPACE
 const LANES_LABEL = `${run_board_labels.LANES_ICON} lanes`
+// A single run's rule (joshuafolkken/kit#7523): it runs in the root checkout, not in a lane, so its
+// row stands under the command it runs rather than under the lanes.
+const SINGLE_RUN_ICON = '🏠'
 // Two leading rules, a space, and the separator before the first column.
 const RULE_ROOM = 6
 
+function root_label(run_name: string): string {
+	return `${SINGLE_RUN_ICON} ${run_name}`
+}
+
 function lane_label(header: BoardHeader): string {
+	if (header.run_name !== undefined) return root_label(header.run_name)
 	if (header.occupied_count === undefined) return LANES_LABEL
 
 	return `${LANES_LABEL} ${String(header.occupied_count)}/${String(header.lane_limit ?? '—')}`
@@ -102,6 +110,7 @@ const run_board_render_lead = {
 	indent_of,
 	lead_of,
 	lane_label,
+	root_label,
 	running_fresh,
 }
 

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

@@ -0,0 +1,69 @@
+import { run_board_layout, type BoardLayout, type BoardRow, type RowRead } from './run-board-layout'
+import type { LocalRead } from './run-board-read'
+import type { EndedRoot } from './run-board-single'
+import { run_board_status, type ItemStatus } from './run-board-status'
+
+// The root checkout's single runs beside a carried run. A running one is drawn under 🏠 above the lanes
+// (joshuafolkken/kit#7524), its row read off its own span's events and kept out of `active`, so the
+// header counts no lane and no 🔄 for it. One a merge ended inside the run leaves 🏠 and is listed in
+// `✅ done` as a lane's finished row is, in its place by its end (joshuafolkken/kit#7525).
+
+type RootRead = Pick<LocalRead, 'root' | 'ended_roots' | 'lane_states'>
+
+function live_of(local: RootRead, read: RowRead): Pick<BoardLayout, 'root'> {
+	const { root } = local
+
+	if (root === undefined) return {}
+	const status = run_board_status.statuses_of(root.events, local.lane_states).get(root.issue)
+
+	if (status === undefined) return {}
+	const statuses = new Map([[root.issue, status]])
+	const [row] = run_board_layout.local_layout_of(statuses, undefined, read).active
+
+	return row === undefined ? {} : { root: { name: root.command, row } }
+}
+
+// A merge released the run's hold, so it ended merged.
+function ended_status(run: EndedRoot): ItemStatus {
+	return { state: 'merged', started_ms: run.started_ms, ended_ms: run.ended_ms }
+}
+
+// The ended runs' rows among the run's own, any row of the same issue replaced.
+function active_of(
+	active: ReadonlyArray<BoardRow>,
+	ended: ReadonlyArray<EndedRoot>,
+	read: RowRead,
+): ReadonlyArray<BoardRow> {
+	if (ended.length === 0) return active
+
+	const statuses = new Map(ended.map((run) => [run.issue, ended_status(run)]))
+	const rows = run_board_layout.local_layout_of(statuses, undefined, read).active
+	const kept = active.filter((row) => !statuses.has(row.number))
+
+	return [...kept, ...rows].toSorted(run_board_layout.active_order)
+}
+
+function layout_of(layout: BoardLayout, local: RootRead, read: RowRead): BoardLayout {
+	return {
+		...layout,
+		active: active_of(layout.active, local.ended_roots ?? [], read),
+		...live_of(local, read),
+	}
+}
+
+// The baseline the header counts arrivals against: the rows the ended runs add to the run's are no
+// arrival to its plan.
+function baseline_of(
+	baseline_total: number | undefined,
+	run_layout: BoardLayout,
+	layout: BoardLayout,
+): number | undefined {
+	if (baseline_total === undefined) return undefined
+	const { rows_of } = run_board_layout
+
+	return baseline_total + rows_of(layout).length - rows_of(run_layout).length
+}
+
+const run_board_root_layout = { baseline_of, layout_of }
+
+export { run_board_root_layout }

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

@@ -6,7 +6,8 @@ import { stamped_memo } from '#scripts/lib/stamped-memo'
 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_hold, type HoldRead } from '#scripts/run/hold/run-hold'
-import type { BoardSpan } from './run-board-span'
+import { run_hold_ended, type EndedHold } from '#scripts/run/hold/run-hold-ended'
+import { run_board_span, type BoardSpan } from './run-board-span'
 
 // A single `fullrun #N` or `halfrun #N` has no carry record; the only record that says it is running
 // here is this checkout's hold (`run-hold.ts`), so the board draws it from there — no store of its own
@@ -24,6 +25,15 @@ interface SingleRun {
 	issue: number
 }
 
+interface RootRun extends SingleRun {
+	events: ReadonlyArray<RunEvent>
+}
+
+interface EndedRoot extends SingleRun {
+	started_ms: number
+	ended_ms: number
+}
+
 // The checkout's own git directory, resolved once per working directory: resolving it runs a `git`
 // subprocess the redraw would wait on, as `run-board-read.ts`'s main work tree does.
 const directories = stamped_memo.create<Promise<string | undefined>>()
@@ -68,8 +78,8 @@ async function directory_here(): Promise<string | undefined> {
 }
 
 // The single run held in this checkout; `undefined` where none is. A lane's hold is its `backlogrun`
-// child's, drawn as that run's row, so only outside a lane does a hold outrank the carry record — a
-// `fullrun` in another checkout beside a running `backlogrun`.
+// child's, drawn as that run's row, so only outside a lane is a hold read beside the carry record — a
+// `fullrun` in the root checkout beside a running `backlogrun`.
 async function span_here(is_carried: boolean): Promise<BoardSpan | undefined> {
 	if (is_carried && lane_paths.lane_issue_of(process.cwd()) !== undefined) return undefined
 
@@ -80,6 +90,41 @@ async function span_here(is_carried: boolean): Promise<BoardSpan | undefined> {
 	return span_of(run_hold.read_hold(run_hold.hold_path(directory)))
 }
 
+// A run the root checkout's merge released, as `run-hold-ended.ts` kept it; `undefined` where its
+// record names no issue or no moment.
+function ended_of(ended: EndedHold): EndedRoot | undefined {
+	if (!issue_number_shape.is_issue_number(ended.issue)) return undefined
+
+	const started_ms = run_event_scope.moment_of(ended.taken_at)
+	const ended_ms = run_event_scope.moment_of(ended.ended_at)
+
+	if (started_ms === undefined || ended_ms === undefined) return undefined
+
+	const command = ended.is_fullrun === true ? FULLRUN : HALFRUN
+
+	return { command, issue: Number(ended.issue), started_ms, ended_ms }
+}
+
+function is_inside(run: EndedRoot, span: BoardSpan): boolean {
+	return run.ended_ms >= span.started_ms && run.ended_ms <= (span.ended_ms ?? Infinity)
+}
+
+// The released runs that ended inside `span`, which the board lists in `✅ done` (joshuafolkken/kit#7525).
+function ended_in(records: ReadonlyArray<EndedHold>, span: BoardSpan): Array<EndedRoot> {
+	return records
+		.map((record) => ended_of(record))
+		.filter((run): run is EndedRoot => run !== undefined && is_inside(run, span))
+}
+
+// This checkout's released single runs inside `span`; none in a lane, where no merge records one.
+async function ended_here(span: BoardSpan): Promise<Array<EndedRoot>> {
+	const directory = await directory_here()
+
+	if (directory === undefined) return []
+
+	return ended_in(run_hold_ended.read_ended(run_hold_ended.ended_path(directory)), span)
+}
+
 // The command and issue of a single run's invocation; `undefined` for any other run's.
 function single_of(invocation: string): SingleRun | undefined {
 	const { command, issue } = SINGLE_INVOCATION.exec(invocation)?.groups ?? {}
@@ -118,6 +163,26 @@ function name_of(invocation: string): string | undefined {
 	return single_of(invocation)?.command
 }
 
-const run_board_single = { events_of, name_of, scope_of, span_here, span_of }
+// The root checkout's single run beside a carried run, with its own span's events its row's phase is
+// read from (joshuafolkken/kit#7524).
+function root_of(span: BoardSpan, events: ReadonlyArray<RunEvent>): RootRun | undefined {
+	const single = single_of(span.invocation)
+
+	if (single === undefined) return undefined
+
+	return { ...single, events: events_of(span, run_board_span.events_of(events, span)) }
+}
+
+const run_board_single = {
+	ended_here,
+	ended_in,
+	events_of,
+	name_of,
+	root_of,
+	scope_of,
+	span_here,
+	span_of,
+}
 
 export { run_board_single }
+export type { EndedRoot, RootRun }

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

@@ -0,0 +1,85 @@
+import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
+import type { TableRead } from '#scripts/lane/lane-process-table'
+import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
+import { run_carry_ended } from '#scripts/run/carry/run-carry-ended'
+import { run_stranded_detect } from '#scripts/run/run-stranded-detect'
+import type { ProcessRoots } from './run-board-process-groups'
+import { run_board_roots } from './run-board-roots'
+import { run_board_single } from './run-board-single'
+import { run_board_span, type BoardSpan } from './run-board-span'
+
+// What `run:board` reads of the run drawn here: its span, the session it resumes from and the
+// processes its record names.
+interface SpanHere {
+	span: BoardSpan | undefined
+	resume: string | undefined
+	// The parent session's transcript, where the run's record names one.
+	transcript: string | undefined
+	roots: ProcessRoots
+	carry: RunCarry | undefined
+	is_stranded: boolean
+	is_session_active: boolean
+	// The root checkout's single run beside the carried one.
+	root?: BoardSpan | undefined
+}
+
+const NO_SPAN: SpanHere = {
+	span: undefined,
+	resume: undefined,
+	transcript: undefined,
+	roots: {},
+	carry: undefined,
+	is_stranded: false,
+	is_session_active: false,
+}
+
+// Every process the run's record names is asked of `table`, the redraw's own `ps` snapshot — only once
+// a run is found, so a repository with no run waits on no `ps`.
+async function recorded_span_here(
+	repository: string,
+	table: TableRead | undefined,
+	read: CarryRead,
+): Promise<SpanHere> {
+	const ended = run_carry_ended.read_ended(run_carry_ended.ended_path(repository))
+	const launch = backlogrun_launch.pending_launch(repository)
+	const span = run_board_span.span_of(read, ended, launch)
+
+	if (span === undefined) return NO_SPAN
+
+	const same_process = await run_board_roots.same_in(table)
+	const stranded_ports = run_stranded_detect.ports_with(same_process)
+
+	return {
+		span,
+		resume: run_board_span.resume_of(read, ended, launch),
+		transcript: read.kind === 'carried' ? read.carry.owner_transcript : undefined,
+		roots: run_board_roots.roots_of(repository, read, same_process),
+		is_session_active: run_board_roots.session_is_active(repository, read, same_process),
+		carry: read.kind === 'carried' ? read.carry : undefined,
+		is_stranded: run_stranded_detect.is_stranded_at(repository, stranded_ports),
+	}
+}
+
+// A single run this checkout holds is the one drawn (`run-board-single.ts`) before the ended run; it
+// names no process. Beside a carried run it is the root checkout's, drawn as a row above the carried
+// run's lanes, which stays the frame (joshuafolkken/kit#7524). No repository, no run.
+async function span_here(
+	repository: string | undefined,
+	table: TableRead | undefined,
+): Promise<SpanHere> {
+	if (repository === undefined) return NO_SPAN
+	const read = run_carry.read_carry(run_carry.carry_path(repository))
+	const is_carried = read.kind !== 'none'
+	const single = await run_board_single.span_here(is_carried)
+
+	if (single === undefined) return await recorded_span_here(repository, table, read)
+	const recorded = is_carried ? await recorded_span_here(repository, table, read) : NO_SPAN
+
+	// A carried record that reads no span leaves the single run the one drawn.
+	return recorded.span === undefined ? { ...NO_SPAN, span: single } : { ...recorded, root: single }
+}
+
+const run_board_span_read = { span_here }
+
+export { run_board_span_read }
+export type { SpanHere }

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

@@ -13,6 +13,7 @@ import type { LocalRead } from './run-board-read'
 import { run_board_reason, type ReasonRead } from './run-board-reason'
 import { run_board_released } from './run-board-released'
 import { run_board_render } from './run-board-render'
+import { run_board_root_layout } from './run-board-root-layout'
 import { run_board_seat, type SeatRead } from './run-board-seat'
 import { run_board_setup } from './run-board-setup'
 import type { Known } from './run-board-snapshot'
@@ -321,13 +322,20 @@ function draw(ports: BoardPorts, lines: ReadonlyArray<string>): void {
 }
 
 // The first total the plan gives is the baseline every later arrival is counted against; the run's own
-// children before it are no total.
+// children before it are no total. The root checkout's single runs are laid over the run's.
 function draw_run(state: BoardState, local: LocalRead, redraw: Redraw): BoardState {
-	const layout = layout_for(state, local, redraw.now_ms)
+	const read = closed_under(known_of(state), state.closed)
+	const run_layout = layout_for(state, local, redraw.now_ms)
+	const layout = run_board_root_layout.layout_of(run_layout, local, read)
 	const first_total =
-		state.plan === undefined ? undefined : run_board_header.counts_of(layout).total
+		state.plan === undefined ? undefined : run_board_header.counts_of(run_layout).total
 	const settled = { ...state, baseline_total: state.baseline_total ?? first_total }
-	const { lines, spots } = frame_of(settled, local, layout, redraw)
+	const baseline_total = run_board_root_layout.baseline_of(
+		settled.baseline_total,
+		run_layout,
+		layout,
+	)
+	const { lines, spots } = frame_of({ ...settled, baseline_total }, local, layout, redraw)
 
 	draw(redraw.ports, lines)
 

package/scripts/run/hold/run-hold-ended.ts

@@ -0,0 +1,50 @@
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+import type { HoldRead } from './run-hold'
+
+// The runs whose hold a merge released here. A single `fullrun` or `halfrun` in the root checkout has
+// no record but its hold (`run-board-single.ts`), and the release removes it, so without this
+// `run:board` would lose the run the moment it merged; this keeps when each began and ended for the
+// board's `✅ done` (joshuafolkken/kit#7525). The newest few only: the board reads the ones that ended
+// inside the run on screen.
+
+const ENDED_PREFIX = 'josh-run-hold-ended-'
+const KEPT_RUNS = 20
+
+const ended_hold_schema = z.object({
+	issue: z.string(),
+	is_fullrun: z.boolean().optional(),
+	taken_at: z.string(),
+	ended_at: z.string(),
+})
+
+type EndedHold = z.infer<typeof ended_hold_schema>
+
+// Keyed like the hold, on the work tree's own git directory.
+function ended_path(git_directory: string): string {
+	return stamp_file.stamp_path(ENDED_PREFIX, git_directory)
+}
+
+// None where no run has ended here, or the record does not read.
+function read_ended(target: string): ReadonlyArray<EndedHold> {
+	const raw = stamp_file.read_stamp_text(target)
+
+	return raw === undefined ? [] : (json_value.parse_with(raw, z.array(ended_hold_schema)) ?? [])
+}
+
+// Records the hold a merge is about to release; a read with no live hold names no run.
+function record_ended(target: string, read: HoldRead, now: Date = new Date()): void {
+	if (read.kind !== 'held') return
+
+	const { issue, is_fullrun, taken_at } = read.hold
+	const ended: EndedHold = { issue, taken_at, ended_at: now.toISOString() }
+
+	if (is_fullrun === true) ended.is_fullrun = true
+	stamp_file.replace_stamp(target, [...read_ended(target), ended].slice(-KEPT_RUNS))
+}
+
+const run_hold_ended = { KEPT_RUNS, ended_path, read_ended, record_ended }
+
+export { run_hold_ended }
+export type { EndedHold }