@joshuafolkken/kit 1.2116.0 → 1.3041.0

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

@@ -6,16 +6,18 @@ 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 } from '#scripts/lane/lane-state'
+import { lane_state, type LaneStateRecord } from '#scripts/lane/lane-state'
 import { stamped_memo } from '#scripts/lib/stamped-memo'
-import { run_carry, type RunCarry } from '#scripts/run/carry/run-carry'
+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_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'
 import { run_board_lane_state, type BoardLanes } from './run-board-lane-state'
 import {
 	run_board_operation_read,
@@ -23,20 +25,29 @@ import {
 	type SessionOperations,
 } 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_span, type BoardSpan } from './run-board-span'
+import { run_board_throughput, type ThroughputRow } from './run-board-throughput'
 import { run_board_usual, type UsualTimes } from './run-board-usual'
 
 // What `run:board` reads locally each tick: the run's span and scope, its events and its open lanes.
 // The run is the running one, or the one that last ended until the next run begins.
 interface LocalRead {
+	scheduler_provider?: QuotaProvider | undefined
 	started_ms: number
 	// Set only once the run has ended; the board then draws its end-of-run screen.
 	ended_ms: number | undefined
+	// The single run's name the header draws; `undefined` for a `backlogrun` (`run-board-single.ts`).
+	run_name?: string | undefined
 	// What the run was asked to do, from its invocation.
 	scope: NamedPlan
 	events: ReadonlyArray<RunEvent>
+	// The 📈 throughput rows, read off the whole stream, every run's, before it is narrowed to this run;
+	// derived here so the redraw thread is never handed the stream itself.
+	throughput?: ReadonlyArray<ThroughputRow> | undefined
 	lanes: ReadonlyArray<string>
 	// The open lanes as their lane state records sort them — this run's, an earlier run's and the ones
 	// with no record — with what each is doing (`run-board-lane-state.ts`).
@@ -62,14 +73,21 @@ interface LocalRead {
 	// How many lanes hold a place under the limit (`backlog-occupied.ts`), counted beside a row that
 	// waits for a free lane.
 	occupied_count?: number | undefined
+	// The same snapshot's occupied identities, so row selection can use the heading's exact lanes.
+	occupied_lanes?: ReadonlyArray<string> | undefined
 	// How long each phase usually takes, from the repository's lane ledger.
 	usual?: UsualTimes | undefined
 	// The reset a Claude usage limit holds the running run's launches until (`run-merge-usage-limit.ts`);
 	// `undefined` once it has passed, where none was recorded, or where no run is carried.
 	usage_reset_ms?: number | undefined
+	// How many children that limit stopped and still holds (joshuafolkken/kit#5395).
+	usage_parked?: number | undefined
 	// The driver holds its offered issue until the machine has memory for one more lane — the ledger's
 	// open hold is `backlog-drive-memory.ts`'s.
 	is_memory_held?: boolean | undefined
+	// The ledger's open hold the driver launches nothing under, in its own words; `undefined` once it
+	// is released (joshuafolkken/kit#6538).
+	launch_hold?: string | undefined
 	// The run's supervisor and parent session, named in the 💻 section (`run-board-roots.ts`).
 	roots?: ProcessRoots | undefined
 	// The processes a lane's close could not end, by pid, each with why (`lane-reap-settle.ts`).
@@ -122,8 +140,11 @@ 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 span_here(repository: string, table: TableRead | undefined): Promise<SpanHere> {
-	const read = run_carry.read_carry(run_carry.carry_path(repository))
+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)
@@ -143,6 +164,17 @@ async function span_here(repository: string, table: TableRead | undefined): Prom
 	}
 }
 
+// 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(
@@ -160,23 +192,27 @@ function sources_of(
 }
 
 // The open lanes sorted by their records, each folded from the whole stream, not the run's span: an
-// earlier run's lane launched before the span began.
-async function lanes_here(
+// earlier run's lane launched before the span began. A closed lane's record is read too, for its end.
+function sorted_here(
 	lanes: ReadonlyArray<LaneInfo>,
-	repository: string,
+	records: ReadonlyArray<LaneStateRecord>,
 	events: ReadonlyArray<RunEvent>,
 	started_ms: number,
-): Promise<BoardLanes> {
-	const issues = lanes.map((lane) => lane.issue)
-	const records = await lane_state.read_states(issues, repository)
-
-	return run_board_lane_state.lanes_of({ events, lanes: issues, records, started_ms })
+): BoardLanes {
+	return run_board_lane_state.lanes_of({
+		events,
+		lanes: lanes.map((lane) => lane.issue),
+		records: new Map(records.map((record) => [record.issue, record])),
+		started_ms,
+		results: run_board_lane_result.results_of(lanes),
+	})
 }
 
 // The lanes not yet ended and the processes their closes could not end, off their records — once a
 // retried close ends the lane, its survivors are gone.
-async function unfinished_here(repository: string): Promise<Pick<LocalRead, 'closing' | 'stuck'>> {
-	const records = await lane_state.read_records(repository)
+function unfinished_here(
+	records: ReadonlyArray<LaneStateRecord>,
+): Pick<LocalRead, 'closing' | 'stuck'> {
 	const unfinished = records.filter((record) => record.state !== 'ended')
 
 	return {
@@ -187,9 +223,29 @@ async function unfinished_here(repository: string): Promise<Pick<LocalRead, 'clo
 	}
 }
 
+// Every lane record, read once for the lanes' states and the closes still unfinished.
+async function lanes_here(
+	lanes: ReadonlyArray<LaneInfo>,
+	repository: string,
+	events: ReadonlyArray<RunEvent>,
+	started_ms: number,
+): Promise<Pick<LocalRead, 'lane_states' | 'closing' | 'stuck'>> {
+	const records = await lane_state.read_records(repository)
+
+	return {
+		lane_states: sorted_here(lanes, records, events, started_ms),
+		...unfinished_here(records),
+	}
+}
+
 type LaneRoomRead = Pick<
 	LocalRead,
-	'free_lanes' | 'lane_limit' | 'occupied_count' | 'earlier_occupied' | 'idle_lanes'
+	| 'free_lanes'
+	| 'lane_limit'
+	| 'occupied_count'
+	| 'occupied_lanes'
+	| 'earlier_occupied'
+	| 'idle_lanes'
 >
 
 // The lanes against the limit, read once so the free count, the lanes it counts, the earlier run's
@@ -207,37 +263,43 @@ async function lane_room_of(
 		free_lanes: count?.free,
 		lane_limit: count?.limit,
 		occupied_count: occupied.length,
+		occupied_lanes: occupied,
 		earlier_occupied: run_board_lane_state.earlier_occupied(occupied, sorted),
 		idle_lanes: room.idle,
 	}
 }
 
 // The repository's lane ledger, read once for the usual times and the driver's open hold.
-function ledger_here(repository: string): Pick<LocalRead, 'usual' | 'is_memory_held'> {
+function ledger_here(
+	repository: string,
+): Pick<LocalRead, 'usual' | 'is_memory_held' | 'launch_hold'> {
 	const entries = lane_ledger.read_entries(lane_ledger.target_of(repository))
 	const now_ms = Date.now()
+	const launch_hold = lane_held_stats.open_reason(entries, now_ms)
 
 	return {
 		usual: run_board_usual.usual_of(entries, now_ms),
-		is_memory_held:
-			lane_held_stats.open_reason(entries, now_ms) === backlog_drive_memory.HOLD_REASON,
+		is_memory_held: launch_hold === backlog_drive_memory.HOLD_REASON,
+		launch_hold,
 	}
 }
 
 // The reset a usage limit holds the running run's launches until, read off the events `backlog:drive`
 // reads it off (`run_event_stream_emit.current_events`): the carried invocation's, so an ended run's
-// stop holds no row the driver would launch.
+// stop holds no row the driver would launch — and how many children it stopped.
 function usage_reset_here(
 	events: ReadonlyArray<RunEvent>,
 	carry: RunCarry | undefined,
-): number | undefined {
-	if (carry === undefined) return undefined
+): Pick<LocalRead, 'usage_reset_ms' | 'usage_parked'> {
+	if (carry === undefined) return { usage_reset_ms: undefined }
 	const scope = run_event_scope.scope_of({ kind: 'carried', carry })
+	const scoped = run_event_scope.scoped_events(events, scope) ?? []
+	const now_ms = Date.now()
 
-	return run_merge_usage_limit.held_until(
-		run_event_scope.scoped_events(events, scope) ?? [],
-		Date.now(),
-	)
+	return {
+		usage_reset_ms: run_merge_usage_limit.held_until(scoped, now_ms),
+		usage_parked: run_merge_usage_limit.held_count(scoped, now_ms),
+	}
 }
 
 // The run's own events, what its done rows say after their time with each open investigation's
@@ -247,8 +309,8 @@ async function span_events_here(
 	span: BoardSpan,
 	table: TableRead | undefined,
 	carry: RunCarry | undefined,
-): Promise<Pick<LocalRead, 'events' | 'found' | 'usage_reset_ms'>> {
-	const spanned = run_board_span.events_of(events, span)
+): Promise<Pick<LocalRead, 'events' | 'found' | 'usage_reset_ms' | 'usage_parked'>> {
+	const spanned = run_board_single.events_of(span, run_board_span.events_of(events, span))
 	// An overrun session outlives the run that launched it, so its notes and filings are read past the
 	// run's end too (joshuafolkken/kit#4818); the next run starts a span of its own.
 	const since = run_board_span.events_of(events, { ...span, ended_ms: undefined })
@@ -256,10 +318,25 @@ async function span_events_here(
 	return {
 		events: spanned,
 		found: run_board_found.found_of(since, await run_board_found.live_in(table)),
-		usage_reset_ms: usage_reset_here(events, carry),
+		...usage_reset_here(events, carry),
 	}
 }
 
+function span_fields(
+	span: BoardSpan,
+): Pick<LocalRead, 'started_ms' | 'ended_ms' | 'scheduler_provider' | 'run_name'> {
+	const run_name = run_board_single.name_of(span.invocation)
+	const times = {
+		started_ms: span.started_ms,
+		ended_ms: span.ended_ms,
+		...(run_name !== undefined && { run_name }),
+	}
+
+	if (span.scheduler_provider === undefined) return times
+
+	return { ...times, scheduler_provider: span.scheduler_provider === 'openai' ? 'codex' : 'claude' }
+}
+
 // `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> {
@@ -269,24 +346,23 @@ async function read_local(table?: TableRead): Promise<LocalRead | undefined> {
 
 	if (repository === undefined || span === undefined) return undefined
 
-	const events = run_event_stream.read_events(run_event_stream.target_of(repository))
+	const events = run_event_tail.read_events(run_event_stream.target_of(repository))
 	const lanes = await lane_registry.list_lanes(await main_root())
-	const lane_states = await lanes_here(lanes, repository, events, span.started_ms)
+	const lane_read = await lanes_here(lanes, repository, events, span.started_ms)
 
 	return {
-		started_ms: span.started_ms,
-		ended_ms: span.ended_ms,
-		scope: run_board_scope.scope_of(span.invocation),
+		...span_fields(span),
+		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()),
 		lanes: lanes.map((lane) => lane.issue),
-		lane_states,
+		...lane_read,
 		resume,
 		roots,
-		...(await unfinished_here(repository)),
 		carry,
 		is_stranded,
 		operations: run_board_operation_read.read(sources_of(repository, lanes, transcript)),
-		...(await lane_room_of(lanes, lane_states, table)),
+		...(await lane_room_of(lanes, lane_read.lane_states, table)),
 		...ledger_here(repository),
 	}
 }

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

@@ -10,6 +10,7 @@ import { lane_state } from '#scripts/lane/lane-state'
 import type { RunCarry } from '#scripts/run/carry/run-carry'
 import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import type { RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_board_human_merge } from './run-board-human-merge'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type Overlay, type ReasonOf, type RowReason } from './run-board-layout'
 import { run_board_machine, type MachineGauges } from './run-board-machine'
@@ -67,8 +68,6 @@ interface ReasonRead extends Overlay {
 
 // What every row of one layout is weighed against, read once.
 interface Pool {
-	// The untriaged issue nothing blocks that withholds every candidate (`epic-triage.ts`), if any.
-	held_by: number | undefined
 	running: ReadonlyArray<number>
 	// The issues the classifier withholds for a person (`epic-outside-blocker.ts`'s `human`).
 	withheld: ReadonlySet<number>
@@ -96,7 +95,11 @@ function stage_of(child: EpicChild, read: ReasonRead): RowReason | undefined {
 }
 
 function is_untriaged_candidate(child: EpicChild, read: ReasonRead): boolean {
-	return !epic_triage.is_triaged(child) && !run_board_layout.is_blocked(child, read)
+	return (
+		!epic_triage.is_triaged(child) &&
+		issue_not_before.is_due(child.body, read.now_ms) &&
+		!run_board_layout.is_blocked(child, read)
+	)
 }
 
 // A child whose lane stands with no one in it still holds the paths it declared, as its open lane does.
@@ -132,7 +135,6 @@ function pool_of(read: ReasonRead): Pool {
 	const candidates = waiting.filter((child) => is_candidate(child, read))
 
 	return {
-		held_by: waiting.find((child) => is_untriaged_candidate(child, read))?.number,
 		running,
 		withheld: read.plan.withheld ?? new Set(),
 		planning: run_board_planning.planning_of(read, running),
@@ -218,13 +220,6 @@ function named_of(child: EpicChild, read: ReasonRead, pool: Pool): RowReason | u
 	return holder === undefined ? undefined : { icon: WAIT_ICONS.named, issues: [String(holder)] }
 }
 
-// `✋ 4301`: the untriaged issue the pool is held for a judgment of.
-function held_of(pool: Pool): RowReason | undefined {
-	if (pool.held_by === undefined) return undefined
-
-	return { icon: WAIT_ICONS.held, issues: [String(pool.held_by)] }
-}
-
 // `🔒 4374`: the running `run:solo` issue nothing new starts beside until it merges or is parked.
 function held_solo_of(pool: Pool): RowReason | undefined {
 	if (pool.solo_holder === undefined) return undefined
@@ -256,13 +251,11 @@ function solo_wait(child: EpicChild, pool: Pool): RowReason | undefined {
 }
 
 // A candidate nothing blocks, in the order the driver answers: the declared order, then what
-// `backlog:next` answers — the pool held for a judgment, then a running `run:solo` issue, then a
-// waiting `run:solo` issue's wait, then a path a running issue declares, then a pool with no lane
+// `backlog:next` answers — a running `run:solo` issue, then a waiting `run:solo` issue's wait, then a path a running issue declares, then a pool with no lane
 // left, then a usage limit not yet reset, then a machine with no memory.
 function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): RowReason | undefined {
 	return (
 		named_of(child, read, pool) ??
-		held_of(pool) ??
 		solo_wait(child, pool) ??
 		overlap_of(child, read, pool) ??
 		room_wait(read)
@@ -301,8 +294,27 @@ function blocker_icon(child: EpicChild, pool: Pool): string {
 	return pool.withheld.has(child.number) ? STATE_ICONS.human : WAIT_ICONS.blocker
 }
 
-// `❓ 4183`: an issue nobody has judged, naming its first standing blocker where it has one.
-function untriaged_of(waits: ReadonlyArray<string>): RowReason {
+// The decision a withheld row waits on, followed through its blockers as the plan was read — kept even
+// where no blocker still stands at this frame, so the row itself says what a person decides.
+function decision_tail(child: EpicChild, read: ReasonRead, pool: Pool): string | undefined {
+	return pool.withheld.has(child.number) ? read.plan.decision_waits?.get(child.number) : undefined
+}
+
+function blocker_reason(
+	child: EpicChild,
+	waits: ReadonlyArray<string>,
+	tail: string | undefined,
+	pool: Pool,
+): RowReason {
+	return { icon: blocker_icon(child, pool), issues: waits, ...(tail !== undefined && { tail }) }
+}
+
+// `✋`: an issue nobody has judged, due and unblocked, held alone for its judgment while `backlog:next`
+// offers the triaged candidates (`epic-triage.ts`); `❓ 4183` where a blocker still stands, naming the
+// first, or `❓` alone where its start time is ahead.
+function untriaged_of(child: EpicChild, waits: ReadonlyArray<string>, read: ReasonRead): RowReason {
+	if (is_untriaged_candidate(child, read)) return { icon: WAIT_ICONS.held }
+
 	return { icon: WAIT_ICONS.untriaged, issues: waits.slice(0, FIRST_ONLY) }
 }
 
@@ -312,18 +324,26 @@ function wait_of(
 	read: ReasonRead,
 	pool: Pool,
 ): RowReason | undefined {
-	if (!epic_triage.is_triaged(child)) return untriaged_of(waits)
-	if (waits.length > 0) return { icon: blocker_icon(child, pool), issues: waits }
+	if (!epic_triage.is_triaged(child)) return untriaged_of(child, waits, read)
+	const tail = decision_tail(child, read, pool)
+
+	if (tail !== undefined || waits.length > 0) return blocker_reason(child, waits, tail, pool)
 
 	return not_before_of(child, read.now_ms) ?? offer_wait(child, read, pool)
 }
 
 // What each waiting row of one layout says, the pool-wide facts read once for all of them.
 function reader(read: ReasonRead): ReasonOf {
-	const pool = pool_of(read)
+	const current = { ...read, ...run_board_human_merge.overlay_of(read.plan, read.statuses) }
+	const pool = pool_of(current)
 
 	return function reason_of(child, waits) {
-		return stage_of(child, read) ?? planned_of(child, pool) ?? wait_of(child, waits, read, pool)
+		return (
+			run_board_human_merge.reason_of(child, current.plan) ??
+			stage_of(child, current) ??
+			planned_of(child, pool) ??
+			wait_of(child, waits, current, pool)
+		)
 	}
 }
 

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

@@ -3,6 +3,7 @@ import { run_board_fresh } from './run-board-fresh'
 import type { BoardHeader } from './run-board-header'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type BoardRow, type RowReason } from './run-board-layout'
+import { run_board_render_title } from './run-board-render-title'
 
 // A queued, waiting or done row's condition column, and the issues its wait names after its title
 // (joshuafolkken/kit#4288, #4292) — pure. The column is one width in every section, the widest value's
@@ -35,6 +36,15 @@ function issue_value_of(issues: ReadonlyArray<string>, header: BoardHeader): str
 	return first === '' ? '' : `${header.link(first)}${more_of(issues)}`
 }
 
+// The text with the reason's pull request number at its end linked to it, where the text keeps the
+// number whole — a cut text ends on an ellipsis and stays plain, so no escape is cut and the drawn
+// width stays the plain text's (joshuafolkken/kit#7181).
+function pr_linked(text: string, pr: number | undefined, header: BoardHeader): string {
+	if (pr === undefined || !text.endsWith(String(pr))) return text
+
+	return `${text.slice(0, -String(pr).length)}${header.pull_link(pr)}`
+}
+
 // The wait's issues, else how long a stage has stood, else the wait's own figure.
 function value_of(reason: RowReason, header: BoardHeader): string {
 	const { issues = [], since_ms } = reason
@@ -42,7 +52,22 @@ function value_of(reason: RowReason, header: BoardHeader): string {
 	if (issues.length > 0) return issue_value_of(issues, header)
 	if (since_ms !== undefined) return run_board_labels.span_of(header.now_ms - since_ms)
 
-	return reason.value ?? ''
+	return pr_linked(reason.value ?? '', reason.pr, header)
+}
+
+// The row's reason after its title, `cut` columns given up as `reason_text` gives them, its pull
+// request linked.
+function evidence_linked(text: string, url: string, header: BoardHeader): string {
+	return header.comment_link?.(text, url) ?? text
+}
+
+function tail_of(row: BoardRow, cut: number, header: BoardHeader): string {
+	const text = run_board_render_title.reason_text(row, cut) ?? ''
+	const url = row.reason?.evidence_url
+
+	return url === undefined
+		? pr_linked(text, row.reason?.pr, header)
+		: evidence_linked(text, url, header)
 }
 
 // A finished row's end, `MM-DD HH:MM`, emphasized while fresh (joshuafolkken/kit#4292); blank where
@@ -91,6 +116,6 @@ function waits_of(row: BoardRow, header: BoardHeader, is_conditioned = false): s
 	return blockers === undefined ? undefined : `${run_board_labels.WAITS_ICON} ${blockers}`
 }
 
-const run_board_render_condition = { CONDITION_WIDTH, condition_of, waits_of }
+const run_board_render_condition = { CONDITION_WIDTH, condition_of, tail_of, waits_of }
 
 export { run_board_render_condition }

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

@@ -1,9 +1,11 @@
+import { run_board_first_lane } from './run-board-first-lane'
 import { run_board_header, type BoardHeader } from './run-board-header'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type BoardRow } from './run-board-layout'
 import { run_board_render_checks } from './run-board-render-checks'
 import { run_board_render_found } from './run-board-render-found'
 import type { LegendDrawn } from './run-board-render-legend'
+import { run_board_render_quota } from './run-board-render-quota'
 import { run_board_render_tail } from './run-board-render-tail'
 import { run_board_render_waits } from './run-board-render-waits'
 
@@ -34,7 +36,7 @@ function has_solo_lane(header: BoardHeader): boolean {
 }
 
 // The third line's kinds, ⏰ where the lanes rule stands it over the lanes' times, then the estimated
-// finish.
+// finish and the time to the first lane.
 function named_of(header: BoardHeader, icons: ReadonlySet<string>): Array<string> {
 	const is_operation = icons.has(NOW_ICONS.operation)
 	const operation = is_operation ? `${NOW_ICONS.operation} ${WORDS.operation}` : undefined
@@ -44,6 +46,7 @@ function named_of(header: BoardHeader, icons: ReadonlySet<string>): Array<string
 		operation,
 		elapsed,
 		run_board_header.estimate_legend(header),
+		run_board_first_lane.legend(header.activity),
 	]
 
 	return legends.filter((legend) => legend !== undefined)
@@ -68,6 +71,7 @@ function drawn_of(
 		named: named_of(header, icons),
 		checks: run_board_render_checks.legend_of(checks),
 		held: run_board_render_waits.legend_of(header),
+		quota: header.quotas === undefined ? [] : run_board_render_quota.LEGEND,
 		solo: has_solo_lane(header),
 		overrun: rows.some((row) => run_board_render_found.is_still(row, header)),
 	}

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

@@ -1,3 +1,4 @@
+import { run_board_earlier } from './run-board-earlier'
 import type { BoardHeader } from './run-board-header'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout } from './run-board-layout'
@@ -30,7 +31,10 @@ function legend_of(header: BoardHeader, notes: ReadonlyArray<BoardNote>): Array<
 	if (layout === undefined) return []
 
 	const rows = run_board_layout.drawn_rows(layout)
-	const leads = new Set(rows.map((row) => run_board_render_icon.state_icon(row)))
+	const leads = new Set([
+		...rows.map((row) => run_board_render_icon.state_icon(row)),
+		...run_board_earlier.marks_of(rows),
+	])
 	const drawn = run_board_render_drawn.drawn_of(header, rows, leads)
 
 	return run_board_render_legend.legend_of(rows, drawn, notes)

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

@@ -1,4 +1,5 @@
 import { run_event_overrun, type OverrunNote } from '#scripts/run/event/run-event-overrun'
+import { run_board_fit } from './run-board-fit'
 import type { Found } from './run-board-found'
 import type { BoardHeader } from './run-board-header'
 import { run_board_labels } from './run-board-labels'
@@ -17,7 +18,7 @@ import type { ItemState } from './run-board-status'
 // while the investigation switch is off, says only what was filed during it.
 
 const { OVERRUN_MARK } = run_board_labels
-const DONE_STATES: ReadonlySet<ItemState> = new Set(['merged', 'done'])
+const DONE_STATES: ReadonlySet<ItemState> = new Set(['merged', 'done', 'already_done'])
 const SEPARATOR = ', '
 const GROUP_SEPARATOR = '  '
 const LONGEST_SEPARATOR = ' · '
@@ -152,6 +153,24 @@ function is_still(row: BoardRow, header: BoardHeader): boolean {
 	return row.state === 'merged' && found_text(row, header).includes(OVERRUN_MARK)
 }
 
-const run_board_render_found = { found_text, is_still }
+function same(reference: string): string {
+	return reference
+}
+
+// What was filed during a done row, in `room`: a pane too narrow for it cuts its end on an ellipsis
+// rather than the title, so the time column stays where every other row has it
+// (joshuafolkken/kit#4922). The cut text's references are left unlinked, so no hyperlink escape is cut
+// in two.
+function found_fitted(room: number | undefined, row: BoardRow, header: BoardHeader): string {
+	const found = found_text(row, header)
+
+	if (found === '' || room === undefined || run_board_fit.width_of(found) <= room) return found
+
+	const unlinked = found_text(row, { ...header, link: same })
+
+	return run_board_render_title.columns_cut(unlinked, Math.max(1, room))
+}
+
+const run_board_render_found = { found_fitted, found_text, is_still }
 
 export { run_board_render_found }

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

@@ -1,4 +1,3 @@
-import { run_board_earlier } from './run-board-earlier'
 import { run_board_labels } from './run-board-labels'
 import type { BoardRow } from './run-board-layout'
 
@@ -6,7 +5,6 @@ import type { BoardRow } from './run-board-layout'
 // it, 🚧 standing in the progress column before it (joshuafolkken/kit#4292).
 
 const { PHASE_ICONS, STATE_ICONS } = run_board_labels
-const { EARLIER_ICON } = run_board_earlier
 
 // A row that says what it waits on leads with that wait's icon in place of its state's
 // (joshuafolkken/kit#4288).
@@ -15,7 +13,8 @@ function state_lead(row: BoardRow): string {
 }
 
 // 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; an earlier run's running lane leads with 🧳 in its place.
+// with 🔄 while it has reached none yet — an earlier run's running lane too, its 🧳 drawn after its
+// title (`run-board-earlier.ts`).
 function running_lead(row: BoardRow): string {
 	const current = row.status?.track?.at(-1)
 
@@ -23,9 +22,7 @@ function running_lead(row: BoardRow): string {
 }
 
 function state_icon(row: BoardRow): string {
-	if (row.state !== 'running') return state_lead(row)
-
-	return row.is_earlier === true ? EARLIER_ICON : running_lead(row)
+	return row.state === 'running' ? running_lead(row) : state_lead(row)
 }
 
 const run_board_render_icon = {