@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/scripts/review/review-record-cli.ts

@@ -295,7 +295,6 @@ interface AppendedRound {
 	lines: ReadonlyArray<string>
 	root: string
 	kind: LineKind
-	findings: ReadonlyArray<Finding>
 	date: string
 }
 
@@ -308,25 +307,28 @@ function ledger_lines({ issue, lines, kind, date }: AppendedRound): ReadonlyArra
 
 // A code round goes on to what its tree means for the ship (`review-record-code-round.ts`).
 async function append_round(round: AppendedRound): Promise<number> {
-	const { issue, lines, root, kind, findings } = round
+	const { issue, lines, root } = round
 	const ledger_path = observation_ledger_home.issue_path(issue, root)
 
 	await observation_ledger_home.append(ledger_path, ledger_lines(round))
 	console.info(confirmation(lines.length, ledger_path))
 	await review_comment_carry.carry_from_record(root)
 
-	if (kind === 'code') await review_record_code_round.follow(issue, root, findings)
-
 	return 0
 }
 
+interface WrittenRound {
+	code: number
+	is_ledger: boolean
+}
+
 // A code round recorded after the push goes to the issue unasked (`review-record-comment.ts`).
 async function write_round(
 	parsed: Parsed,
 	request: Request,
 	now: Date,
 	root: string,
-): Promise<number> {
+): Promise<WrittenRound> {
 	const kind = kind_of(parsed)
 	const date = observation_ledger_home.ledger_date(now)
 	const lines = [
@@ -335,13 +337,23 @@ async function write_round(
 	]
 	const { issue, findings } = request
 
-	if (parsed.comment) return await review_record_comment.post(issue, lines)
+	if (parsed.comment) {
+		return { code: await review_record_comment.post(issue, lines), is_ledger: false }
+	}
 
 	if (kind === 'code' && (await review_record_comment.is_after_push())) {
-		return await review_record_comment.post_after_push({ issue, lines, root, findings })
+		const code = await review_record_comment.post_after_push({ issue, lines, root, findings })
+
+		return { code, is_ledger: false }
 	}
 
-	return await append_round({ issue, lines, root, kind, findings, date })
+	return { code: await append_round({ issue, lines, root, kind, date }), is_ledger: true }
+}
+
+function finish_record(request: Request, is_interaction: boolean, root: string): void {
+	if (!is_interaction) review_final_record.record(request.issue, request.findings, root)
+	review_fix_round.record_reasons(request.issue, request.findings)
+	if (request.round !== undefined) review_fix_round.save(request.round, root)
 }
 
 async function record_prepared(
@@ -353,15 +365,17 @@ async function record_prepared(
 	request.round = parsed.interaction
 		? undefined
 		: review_fix_round.prepare(request.issue, request.findings, root)
-	const code = await write_round(parsed, request, now, root)
+	const { code, is_ledger } = await write_round(parsed, request, now, root)
 
 	if (code !== 0) return code
 
-	if (!parsed.interaction) review_final_record.record(request.issue, request.findings, root)
-	review_fix_round.record_reasons(request.issue, request.findings)
-	if (request.round !== undefined) review_fix_round.save(request.round, root)
+	finish_record(request, parsed.interaction, root)
+
+	if (is_ledger && !parsed.interaction) {
+		await review_record_code_round.follow(request.issue, root, request.findings)
+	}
 
-	return code
+	return 0
 }
 
 async function run_record(parsed: Parsed, now: Date, root: string): Promise<number> {

package/scripts/review/review-record-pinned.ts

@@ -5,6 +5,7 @@ import { error_text } from '#scripts/lib/error-message'
 import { observation_ledger_home } from '#scripts/observations/observation-ledger-home'
 import { run_review_join_read, type JoinVerdict } from '#scripts/run/review/run-review-join-read'
 import { run_review_pinned_join } from '#scripts/run/review/run-review-pinned-join'
+import { run_review_pinned_steps } from '#scripts/run/review/run-review-pinned-steps'
 import { run_ship_detach } from '#scripts/run/ship/run-ship-detach'
 import { test_pinned_logic } from '#scripts/test/test-pinned-logic'
 import { review_finding_ledger } from './review-finding-ledger'
@@ -15,7 +16,7 @@ import { review_finding_ledger } from './review-finding-ledger'
 // tree, and its join closed before the fix. The ship's pre-detach was then the first to name the fixed
 // tree's unpinned places, and stopped on them. A recorded code round compares the fixed tree with the
 // launch's and, where they differ, starts the check again with the launch's `--unpinned-ok` reason and
-// says who reads its answer. **Nothing waits on it in the foreground** (joshuafolkken/kit#4895): the
+// says who reads its answer. **The fresh round-1 check is not waited on** (joshuafolkken/kit#4895): the
 // ship's pre-detach reads that same check's answer on that tree rather than running its own
 // (`run-review-pinned-join.ts`). A foreground read stalled the lane for minutes, and pinning what it
 // named moved the tree again under the next probe.
@@ -49,19 +50,27 @@ async function restart_if_moved(root: string = PROJECT_ROOT): Promise<boolean> {
 
 // **A join the lane skipped is read here** (joshuafolkken/kit#5212): `josh run:review --join` was never
 // run, so the unpinned places would surface only as the ship's pre-detach failure. It reads only an
-// answer already left on this tree, so nothing waits on it either. A read that stops nothing prints
-// nothing, and a join already read changes nothing.
+// answer already left on this tree. A cut collects the existing continuation; a ship's remaining
+// probe is collected even when the original join was read. Incomplete results remain explicit.
 const CHOICE_LINE =
 	'Unpinned before the ship: pin each place above with a test that turns red without it, or ship with `--unpinned-ok "<reason>"`.\n'
 
 function show_stop(joined: JoinVerdict | undefined): void {
-	if (joined?.is_stop !== true) return
-	console.info(test_pinned_logic.report_text(joined.summary, CHOICE_LINE).trimEnd())
+	if (joined === undefined) return
+	const text = joined.is_stop
+		? test_pinned_logic.report_text(joined.summary, CHOICE_LINE)
+		: joined.text
+
+	if (joined.is_stop || [joined.summary.is_unchecked, joined.summary.is_partial].includes(true)) {
+		console.info(text.trimEnd())
+	}
 }
 
 async function read_skipped_join(root: string = PROJECT_ROOT): Promise<void> {
 	try {
-		if (run_review_join_read.is_due(root)) show_stop(await run_review_join_read.read_finished(root))
+		if (run_review_join_read.is_due(root) || run_review_pinned_steps.is_remaining(root)) {
+			show_stop(await run_review_join_read.read_finished(root))
+		}
 	} catch (error) {
 		error_text.trace_swallowed('review_record_pinned.read_skipped_join', error)
 	}

package/scripts/run/add/run-add-cli.ts

@@ -11,6 +11,7 @@ import { run_event_retry } from '#scripts/run/event/run-event-retry'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_invocation } from '#scripts/run/run-invocation'
+import { run_repair_attempt } from '#scripts/run/run-repair-attempt'
 import { run_add, type AddContext, type AddOutcome, type AddPorts, type IssueView } from './run-add'
 import { run_add_epic } from './run-add-epic'
 import { run_add_issue } from './run-add-issue'
@@ -136,6 +137,17 @@ async function announce(
 	await announce(rest, roots, is_retry)
 }
 
+async function prepare_repairs(request: AddRequest): Promise<ReadonlySet<number>> {
+	if (!request.is_retry) return new Set()
+	const prepared = await Promise.all(
+		request.issues.map(async (issue) =>
+			(await run_repair_attempt.prepare(String(issue))) ? issue : undefined,
+		),
+	)
+
+	return new Set(prepared.filter((issue) => issue !== undefined))
+}
+
 // The blockers still open. A blocker whose state did not come back counts as open, so an issue is
 // never reported free to run on a read that did not say so.
 function view_of(issue: EpicIssue): IssueView {
@@ -166,7 +178,11 @@ async function clear_label(issue: number, label: string): Promise<boolean> {
 
 const GH_PORTS: AddPorts = { read_issue, apply_label, clear_label }
 
-async function context_of(live: LiveRun, is_retry: boolean): Promise<AddContext> {
+async function context_of(
+	live: LiveRun,
+	is_retry: boolean,
+	repairs: ReadonlySet<number>,
+): Promise<AddContext> {
 	const lanes = await lane_spent.lanes_in_use()
 	const events = await run_event_stream_emit.current_events(is_retry)
 	const active = backlog_drive_restore.active_issues(events)
@@ -174,6 +190,7 @@ async function context_of(live: LiveRun, is_retry: boolean): Promise<AddContext>
 
 	return {
 		is_retry,
+		repairs,
 		done: live.carry.done ?? [],
 		active: new Set([...active, ...lanes.working, ...lanes.unread]),
 		settled: new Set([
@@ -191,11 +208,12 @@ function report(outcomes: ReadonlyArray<AddOutcome>, is_priority: boolean): numb
 }
 
 async function add(request: AddRequest, live: LiveRun, ports: AddPorts): Promise<number> {
+	const repairs = await prepare_repairs(request)
 	const outcomes: ReadonlyArray<AddOutcome> = await run_add.add_all(
 		request.issues,
 		request.is_priority,
 		ports,
-		await context_of(live, request.is_retry),
+		await context_of(live, request.is_retry, repairs),
 	)
 	const additions = run_add.additions_of(outcomes, request.is_priority)
 	const roots = run_add.roots_of(outcomes)
@@ -203,7 +221,7 @@ async function add(request: AddRequest, live: LiveRun, ports: AddPorts): Promise
 	if (additions.length === 0) return report(outcomes, request.is_priority)
 
 	await announce(
-		additions.map((addition) => addition.issue),
+		additions.map((addition) => addition.issue).filter((issue) => !repairs.has(issue)),
 		roots,
 		request.is_retry,
 	)

package/scripts/run/add/run-add.ts

@@ -4,6 +4,7 @@ import {
 	has_label_name,
 	IN_PROGRESS_LABEL,
 	NEEDS_DECISION_LABEL,
+	NEEDS_HUMAN_MERGE_LABEL,
 	NEEDS_HUMAN_REVIEW_LABEL,
 	PRIORITY_HIGH_LABEL,
 	RUN_LANE_LABEL,
@@ -44,6 +45,8 @@ interface AddContext {
 	settled?: ReadonlySet<number>
 	// What the run already tracks, so an epic root is never recorded twice (`run_add_epic.tracked_of`).
 	tracked?: ReadonlySet<number>
+	// The issues whose repair attempt this call recorded (`run_repair_attempt.prepare`).
+	repairs?: ReadonlySet<number>
 }
 
 const DEFAULT_CONTEXT: AddContext = { is_retry: false, done: [], active: new Set() }
@@ -73,20 +76,34 @@ function labels_for(
 		: opted_in
 }
 
-// The first label that would not apply, or `undefined` once every one landed. Sequential, so a
+// The first label whose write failed, or `undefined` once every one landed. Sequential, so a
 // refused write stops the rest rather than leaving a half-labelled issue the pool reads differently.
-async function first_unapplied(
+async function first_failed(
 	issue: number,
 	labels: ReadonlyArray<string>,
-	ports: AddPorts,
+	write: AddPorts['apply_label'],
 ): Promise<string | undefined> {
 	const [label, ...rest] = labels
 
 	if (label === undefined) return undefined
 
-	if (!(await ports.apply_label(issue, label))) return label
+	if (!(await write(issue, label))) return label
+
+	return await first_failed(issue, rest, write)
+}
 
-	return await first_unapplied(issue, rest, ports)
+// The stops a retry clears: `run:stalled` always, and `needs-human-merge` only for an issue whose
+// repair attempt was recorded — a merge wait with no repair stays a person's (joshuafolkken/kit#7487).
+// The ship re-parks it while the diff still needs a person's merge (`followup-human-merge.ts`).
+// A recorded repair also clears the ended lane's `in-progress`, which the offer otherwise reads as
+// another session's work (joshuafolkken/kit#7493): the record is made only once no process holds
+// the issue and its lane tree is clean (`run-repair-attempt.ts`).
+function stops_of(issue: number, context: AddContext): ReadonlyArray<string> {
+	if (!context.is_retry) return []
+
+	return context.repairs?.has(issue) === true
+		? [RUN_STALLED_LABEL, NEEDS_HUMAN_MERGE_LABEL, IN_PROGRESS_LABEL]
+		: [RUN_STALLED_LABEL]
 }
 
 function retry_required(
@@ -131,13 +148,13 @@ async function label_one(
 	ports: AddPorts,
 	context: AddContext,
 ): Promise<AddOutcome> {
-	const label = await first_unapplied(issue, labels, ports)
+	const label = await first_failed(issue, labels, ports.apply_label)
 
 	if (label !== undefined) return { kind: 'unlabeled', issue, label }
 
-	if (context.is_retry && !(await ports.clear_label(issue, RUN_STALLED_LABEL))) {
-		return { kind: 'refused', issue, reason: 'could not clear run:stalled' }
-	}
+	const stop = await first_failed(issue, stops_of(issue, context), ports.clear_label)
+
+	if (stop !== undefined) return { kind: 'refused', issue, reason: `could not clear ${stop}` }
 
 	return { kind: 'queued', issue, blockers: [] }
 }

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

@@ -13,9 +13,9 @@ import { run_board_decision } from './run-board-decision'
 import { run_board_earlier, type EarlierLanes } from './run-board-earlier'
 import { run_board_ending_reason } from './run-board-ending-reason'
 import { run_board_human } from './run-board-human'
-import { run_board_human_merge } from './run-board-human-merge'
 import { run_board_kind, type BoardPriority } from './run-board-kind'
 import type { PauseRead } from './run-board-pause'
+import { run_board_retry_wait } from './run-board-retry-wait'
 import { run_board_standing_waits } from './run-board-standing-waits'
 import type { ItemState, ItemStatus } from './run-board-status'
 
@@ -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.
@@ -327,7 +329,7 @@ function layout_of(
 	reason_of?: ReasonOf,
 	earlier: EarlierLanes = run_board_earlier.NO_EARLIER,
 ): BoardLayout {
-	const current = run_board_human_merge.overlay_of(input_plan, input_statuses)
+	const current = run_board_retry_wait.overlay_of(input_plan, input_statuses)
 	const { plan, statuses } = current
 	const overlay = { plan, statuses, reason_of }
 	const queue = plan.waves.waves.flat().filter((child) => is_untouched(child, overlay))
@@ -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-reason.ts

@@ -5,6 +5,7 @@ import { epic_solo, type Labelled, type SoloQueue } from '#scripts/epic/epic-sol
 import { epic_triage } from '#scripts/epic/epic-triage'
 import { has_label_name, has_parked_label, IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
 import { issue_not_before } from '#scripts/issue/issue-not-before'
+import { issue_observation_gate } from '#scripts/issue/issue-observation-gate'
 import { issue_sample_gate } from '#scripts/issue/issue-sample-gate'
 import { lane_state } from '#scripts/lane/lane-state'
 import type { RunCarry } from '#scripts/run/carry/run-carry'
@@ -266,6 +267,17 @@ function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): RowReason |
 // waits on; `📅 4313` while that pull request has not merged or its merge is unread — the cited issue
 // for a condition waiting on the pull request that closes it.
 function sample_wait_of(child: EpicChild): RowReason | undefined {
+	const observation = issue_observation_gate.wait_of(child.body)
+
+	if (observation !== undefined) {
+		return {
+			icon: WAIT_ICONS.not_before,
+			value: 'evidence',
+			tail: observation.reason,
+			evidence_url: observation.url,
+		}
+	}
+
 	const wait = issue_sample_gate.wait_of(child.body)
 
 	if (wait === undefined) return undefined

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,
 }