@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -1,34 +1,45 @@
+import { backlog_drive_named } from '#scripts/backlog/backlog-drive-named'
 import { backlog_overlap } from '#scripts/backlog/backlog-overlap'
 import type { EpicChild } from '#scripts/epic/epic-graph'
+import { epic_solo, type Labelled, type SoloQueue } from '#scripts/epic/epic-solo'
 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_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'
 import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import type { RunEvent } from '#scripts/run/event/run-event-stream'
+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'
+import { run_board_planning, type Planning } from './run-board-planning'
 import { run_board_setup } from './run-board-setup'
 import type { ItemStatus } from './run-board-status'
 
-// Why each waiting row waits — pure, so the words are tested apart from the screen. A row whose lane is
-// being opened says the stage that lane is at; any other says what `backlog:next` would answer for it,
-// read off the same rules: `epic_triage` for an untriaged issue, `backlog_overlap` for a declared path a
-// running issue holds, the lane limit for a full pool. A blocker stays the row's `🔗`; only a row that
-// nobody has judged says so beside it, since judging it is what a person can do meanwhile.
-// Every word is English whatever the session language, as every other word on the board is.
+// Why each waiting row waits — pure, so the reasons are tested apart from the screen. Each is one
+// `RowReason` its row only draws (joshuafolkken/kit#4288): an icon, the condition column's value and
+// what follows the title. A row whose lane is being opened leads with the stage that lane is at; any
+// other with what `backlog:next` would answer for it, read off the same rules — after the row a
+// planning run is for, which says so (`run-board-planning.ts`): the driver's declared order for a named
+// run's issue, `epic_triage` for an untriaged issue, `epic_solo` for a running `run:solo` issue, a
+// waiting one and the rows behind it, `backlog_overlap` for a declared path a running issue holds,
+// the lane limit for a full pool. A start time the body declares and the clock has not reached
+// (`issue-not-before.ts`) comes before the pool's reasons, since the pickup never offers the row
+// until then; it reads in the local time every other time on the board does (#4017). A blocker
+// leads its row with `🔗`; a row that nobody has judged leads with ❓ even where it is blocked, since
+// judging it is what a person can do meanwhile.
 
 const { LANE_STAGE } = run_event_setup
+const { HEADER_ICONS, STAGE_ICONS, STATE_ICONS, WAIT_ICONS } = run_board_labels
 const NO_FREE_LANES = 0
+const FIRST_ONLY = 1
 
-const WORDS = {
-	untriaged: 'untriaged',
-	held: 'held by triage',
-	no_lane: 'no free lane',
-	overlaps: 'overlaps',
-} as const
-
-// A lane's stage as its row says it: the event's own words, cut to what fits beside a title.
-const STAGE_WORDS: ReadonlyArray<readonly [stage: string, word: string]> = [
-	[LANE_STAGE.OPENING, 'opening lane'],
-	[LANE_STAGE.INSTALLING, 'installing'],
-	[LANE_STAGE.DISPATCHING, 'dispatching'],
+// The stages a lane's launch passes, each leading its row with its own icon.
+const LANE_STAGES: ReadonlyArray<string> = [
+	LANE_STAGE.OPENING,
+	LANE_STAGE.INSTALLING,
+	LANE_STAGE.DISPATCHING,
 ]
 
 // What the reasons are read from, beside the plan and the statuses a layout is drawn from.
@@ -36,31 +47,52 @@ interface ReasonRead extends Overlay {
 	events: ReadonlyArray<RunEvent>
 	// How many more lanes the limit allows; `undefined` where it could not be read.
 	free_lanes: number | undefined
-	// The issues whose lanes fill the limit, named after `no free lane` so a lane an earlier run left
-	// behind shows on the row it holds back.
-	occupied_lanes?: ReadonlyArray<string> | undefined
+	// How many lanes hold a place under the limit, counted after `🧵`.
+	occupied_count?: number | undefined
+	// The limit those lanes fill; `undefined` where it could not be read.
+	lane_limit?: number | undefined
+	// The reset a Claude usage limit holds launches until (`run-merge-usage-limit.ts`), if one does.
+	usage_reset_ms?: number | undefined
+	// The driver holds its offered issue for memory (`backlog-drive-memory.ts`).
+	is_memory_held?: boolean | undefined
+	// The machine's latest gauges, the figures a memory hold names.
+	gauges?: MachineGauges | undefined
+	// The run's record, whose declared order holds the issues declared after one in flight.
+	carry?: RunCarry | undefined
 	// A stopped run opens no lane, so a stage its stream ends on is not one any lane is at.
 	is_stopped: boolean
+	// The board's clock, which a declared start time is weighed against.
+	now_ms: number
 }
 
 // What every row of one layout is weighed against, read once.
 interface Pool {
-	// An untriaged issue nothing blocks withholds every candidate (`epic-triage.ts`).
-	is_held: boolean
+	// 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>
+	// The row the run's planning is for, while the run plans (`run-board-planning.ts`).
+	planning: Planning | undefined
+	// The first `run:solo` candidate and the candidates behind it (`epic-solo.ts`), if any.
+	solo: SoloQueue | undefined
+	// The running `run:solo` issue that lets nothing new start (`epic_solo.holder_of`), if any.
+	solo_holder: number | undefined
 }
 
-function stage_word(text: string): string | undefined {
-	return STAGE_WORDS.find(([stage]) => text.startsWith(stage))?.[1]
+function stage_icon(text: string): string | undefined {
+	const stage = LANE_STAGES.find((name) => text.startsWith(name))
+
+	return stage === undefined ? undefined : STAGE_ICONS[stage]
 }
 
 function stage_of(child: EpicChild, read: ReasonRead): RowReason | undefined {
 	const stage = read.is_stopped ? undefined : run_board_setup.lane_stage(read.events, child.number)
-	const text = stage === undefined ? undefined : stage_word(stage.text)
+	const icon = stage === undefined ? undefined : stage_icon(stage.text)
 
-	if (stage === undefined || text === undefined) return undefined
+	if (stage === undefined || icon === undefined) return undefined
 
-	return { text, since_ms: stage.at_ms }
+	return { icon, since_ms: stage.at_ms }
 }
 
 function is_untriaged_candidate(child: EpicChild, read: ReasonRead): boolean {
@@ -76,58 +108,222 @@ function running_of(read: ReasonRead): Array<number> {
 	return [...read.statuses].filter(([, status]) => holds_paths(status)).map(([issue]) => issue)
 }
 
+// A waiting row the pool could offer: judged, due, and with no blocker standing — a start time not yet
+// reached keeps a row out of `backlog:next`'s candidates, so it holds nothing behind it.
+function is_candidate(child: EpicChild, read: ReasonRead): boolean {
+	return (
+		epic_triage.is_triaged(child) &&
+		issue_not_before.is_due(child.body, read.now_ms) &&
+		!run_board_layout.is_blocked(child, read)
+	)
+}
+
+// Every open issue holding a lane as `backlog:next` reads it (`epic-busy.ts`): `in-progress` and no
+// park label — a paused lane, or one another run or a person works, holds as this run's lanes do.
+function running_labelled(read: ReasonRead): Array<Labelled> {
+	return [...read.plan.labels]
+		.filter(([, labels]) => has_label_name(labels, IN_PROGRESS_LABEL) && !has_parked_label(labels))
+		.map(([number, labels]) => ({ number, labels }))
+}
+
 function pool_of(read: ReasonRead): Pool {
 	const waiting = run_board_layout.waiting_children(read)
+	const running = running_of(read)
+	const candidates = waiting.filter((child) => is_candidate(child, read))
 
 	return {
-		is_held: waiting.some((child) => is_untriaged_candidate(child, read)),
-		running: running_of(read),
+		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),
+		solo: epic_solo.queue_of(candidates),
+		solo_holder: epic_solo.holder_of(running_labelled(read)),
 	}
 }
 
-function overlap_of(child: EpicChild, read: ReasonRead, pool: Pool): string | undefined {
+function planned_of(child: EpicChild, pool: Pool): RowReason | undefined {
+	return pool.planning?.issue === child.number ? pool.planning.reason : undefined
+}
+
+// ` — paused since 01:28 by lane:pause` for a holder whose lane is paused (joshuafolkken/kit#4270):
+// only a paused lane's status carries who paused it, and its end is when.
+function paused_tail(status: ItemStatus | undefined): string {
+	const { ended_ms, paused_by } = status ?? {}
+
+	if (paused_by === undefined || ended_ms === undefined) return ''
+
+	return ` — ${lane_state.paused_text(ended_ms, paused_by)}`
+}
+
+// `📂 4238 … scripts/gate/machine-capacity.ts`: the running issue holding a path this row declares,
+// and the path after the title — with when and by what the holder was paused, where it is.
+function overlap_of(child: EpicChild, read: ReasonRead, pool: Pool): RowReason | undefined {
 	const { declared = new Map(), context } = read.plan
 	const holding = { holders: pool.running, repo: context.repo }
 	const clash = backlog_overlap.running_clash(child, declared, holding)
 
-	return clash === undefined
-		? undefined
-		: `${WORDS.overlaps} ${String(clash.holder)} (${clash.path})`
+	if (clash === undefined) return undefined
+
+	const tail = `${clash.path}${paused_tail(read.statuses.get(clash.holder))}`
+
+	return { icon: WAIT_ICONS.path, issues: [String(clash.holder)], tail }
 }
 
-function no_lane_of(occupied: ReadonlyArray<string> = []): string {
-	if (occupied.length === 0) return WORDS.no_lane
+// `🧵 4/4`: how many lanes hold a place against the limit the row starts after a free one of. Every
+// waiting row repeated the same breakdown of them, so the row counts them and names none (#4111).
+function no_lane_of(read: ReasonRead): RowReason {
+	const { occupied_count = 0, lane_limit } = read
 
-	return `${WORDS.no_lane} — ${occupied.join(' ')}`
+	if (lane_limit === undefined) return { icon: WAIT_ICONS.lane }
+
+	return { icon: WAIT_ICONS.lane, value: `${String(occupied_count)}/${String(lane_limit)}` }
 }
 
-// A candidate nothing blocks, in the order `backlog:next` answers: the pool held for a judgment, then
-// a path a running issue declares, then a pool with no lane left.
-function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): string | undefined {
-	if (pool.is_held) return WORDS.held
+// `🧠 88% … 💾 12M/s`: run:board's own latest 🧠 / 💾, not the driver's reading, so a hold the kernel's
+// verdict alone raised may show both green. Each is drawn only where it was read (#4084); the 💾 follows
+// the title, so the row draws 🧠 once.
+function no_memory_of(gauges: MachineGauges | undefined): RowReason {
+	const { percent_text, rate_text } = run_board_machine
+	const memory = gauges?.memory_percent
+	const swap = gauges?.swap_mb_per_s
 
-	const overlap = overlap_of(child, read, pool)
+	return {
+		icon: WAIT_ICONS.memory,
+		value: memory === undefined ? undefined : percent_text(memory).trim(),
+		tail: swap === undefined ? undefined : `${HEADER_ICONS.swap} ${rate_text(swap).trim()}`,
+	}
+}
 
-	if (overlap !== undefined) return overlap
+// `🪫 10-25 16:30`: the reset a usage limit holds every launch until, in the board's local time.
+function usage_limit_of(reset_ms: number): RowReason {
+	return { icon: WAIT_ICONS.usage_limit, value: run_board_labels.day_minute_of(reset_ms) }
+}
+
+// The machine's room: no lane left under the limit, else a usage limit not yet reset, else no memory
+// for one more — the order `backlog:drive` asks them in.
+function room_wait(read: ReasonRead): RowReason | undefined {
+	if (read.free_lanes === NO_FREE_LANES) return no_lane_of(read)
+	if (read.usage_reset_ms !== undefined) return usage_limit_of(read.usage_reset_ms)
 
-	return read.free_lanes === NO_FREE_LANES ? no_lane_of(read.occupied_lanes) : undefined
+	return read.is_memory_held === true ? no_memory_of(read.gauges) : undefined
 }
 
-function wait_of(child: EpicChild, read: ReasonRead, pool: Pool): RowReason | undefined {
-	if (!epic_triage.is_triaged(child)) return { text: WORDS.untriaged }
-	if (run_board_layout.is_blocked(child, read)) return undefined
+// `📋 4198`: the declared issue a named run starts this one after — the driver's own reading
+// (`backlog-drive-named.ts`), asked before it offers anything.
+function named_of(child: EpicChild, read: ReasonRead, pool: Pool): RowReason | undefined {
+	if (read.carry === undefined) return undefined
+	const in_flight = pool.running.map(String)
+	const holder = backlog_drive_named.held_after(read.carry, in_flight, child.number)
+
+	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
+
+	return { icon: WAIT_ICONS.solo_running, issues: [String(pool.solo_holder)] }
+}
+
+// `🧍 4288+1 … 4268`: a `run:solo` issue starts only into an idle repository, so it names the running
+// lanes it waits for — the first in the condition column, the rest after the title.
+function alone_of(running: ReadonlyArray<number>): RowReason | undefined {
+	return running.length === 0 ? undefined : { icon: WAIT_ICONS.solo, issues: running.map(String) }
+}
+
+// `🙅 4287`: nothing ranked behind a waiting `run:solo` issue is offered past it.
+function solo_of(child: EpicChild, pool: Pool): RowReason | undefined {
+	const { solo } = pool
+
+	if (solo === undefined) return undefined
+	if (solo.solo.number === child.number) return alone_of(pool.running)
+	const is_behind = solo.behind.some((item) => item.number === child.number)
+
+	return is_behind ? { icon: WAIT_ICONS.solo_ahead, issues: [String(solo.solo.number)] } : undefined
+}
+
+// The `run:solo` gate as `epic_solo.select` reads it: a running `run:solo` issue first, then a waiting
+// one's wait.
+function solo_wait(child: EpicChild, pool: Pool): RowReason | undefined {
+	return held_solo_of(pool) ?? solo_of(child, pool)
+}
+
+// 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
+// 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)
+	)
+}
+
+// `📅 3/10`: the merges the ledger recorded after the declared pull request merged, of those the body
+// 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 wait = issue_sample_gate.wait_of(child.body)
+
+	if (wait === undefined) return undefined
+	if (wait.kind !== 'short') return { icon: WAIT_ICONS.not_before, issues: [String(wait.cited)] }
+
+	return { icon: WAIT_ICONS.not_before, value: `${String(wait.counted)}/${String(wait.needed)}` }
+}
+
+// `📅 10-20 16:30`: the start time the body declares and the clock has not reached, in the board's
+// local time.
+function not_before_of(child: EpicChild, now_ms: number): RowReason | undefined {
+	const ms = issue_not_before.waiting_ms(child.body, now_ms)
+
+	if (ms === undefined) return sample_wait_of(child)
+
+	return {
+		icon: WAIT_ICONS.not_before,
+		value: run_board_labels.day_minute_of(ms),
+		not_before_ms: ms,
+	}
+}
+
+// `🔗 4183` for a blocker the run finishes, `🙋 4183` where the classifier withholds the row for a
+// person: the run will not finish a blocker it waits on (joshuafolkken/kit#4292).
+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 {
+	return { icon: WAIT_ICONS.untriaged, issues: waits.slice(0, FIRST_ONLY) }
+}
 
-	const text = offer_wait(child, read, pool)
+function wait_of(
+	child: EpicChild,
+	waits: ReadonlyArray<string>,
+	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 }
 
-	return text === undefined ? undefined : { text }
+	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)
 
-	return function reason_of(child: EpicChild): RowReason | undefined {
-		return stage_of(child, read) ?? wait_of(child, read, pool)
+	return function reason_of(child, waits) {
+		return stage_of(child, read) ?? planned_of(child, pool) ?? wait_of(child, waits, read, pool)
 	}
 }
 

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

@@ -0,0 +1,35 @@
+import { has_parked_label } from '#scripts/issue/issue-labels'
+import type { ItemStatus, OpenRead } from './run-board-status'
+
+// A parked child a person has released by removing `needs-decision` is no longer the run's: the
+// listing, read after the park, holds it open without the label. Its status is dropped, so the board
+// lays it where the plan places it, as it does any issue the run has not touched.
+
+type ReleaseRead = Pick<OpenRead, 'read_ms' | 'labels'>
+
+function is_read_after_park(status: ItemStatus, read_ms: number | undefined): boolean {
+	return read_ms !== undefined && (status.ended_ms ?? 0) <= read_ms
+}
+
+// A person still owns a parked child while any park label (`PARKED_LABELS`) is on it. An issue the
+// listing did not hold has no labels to read, and stays parked.
+function is_undecided(labels: ReadonlyArray<string> | undefined): boolean {
+	return labels !== undefined && !has_parked_label(labels)
+}
+
+function is_released(issue: number, status: ItemStatus, read: ReleaseRead): boolean {
+	if (status.state !== 'parked') return false
+
+	return is_read_after_park(status, read.read_ms) && is_undecided(read.labels.get(issue))
+}
+
+function without_released(
+	statuses: ReadonlyMap<number, ItemStatus>,
+	read: ReleaseRead,
+): ReadonlyMap<number, ItemStatus> {
+	return new Map([...statuses].filter(([issue, status]) => !is_released(issue, status, read)))
+}
+
+const run_board_released = { without_released }
+
+export { run_board_released }

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

@@ -20,11 +20,13 @@ const CODERABBIT_COLORS: Readonly<Partial<Record<CodeRabbitState, TextColor>>> =
 	'rate-limited': 'yellow',
 	failed: 'red',
 }
-// What the legend says of the part, once some row draws it.
-const LEGEND = [
-	`${CHECK_ICONS.pass} ${CHECK_ICONS.pending} ${CHECK_ICONS.fail} checks passed · pending · failed`,
-	`${CODERABBIT_ICON} CodeRabbit (${CODERABBIT_MARKS['rate-limited'] ?? ''} rate-limited)`,
+// Each mark the legend can name, in its order, with its word.
+const CHECK_WORDS: ReadonlyArray<readonly [string, string]> = [
+	[CHECK_ICONS.pass, 'passed'],
+	[CHECK_ICONS.pending, 'pending'],
+	[CHECK_ICONS.fail, 'failed'],
 ]
+const RATE_LIMITED_MARK = CODERABBIT_MARKS['rate-limited'] ?? ''
 
 function tinted(text: string, color: TextColor | undefined): string {
 	return color === undefined ? text : styleText(color, text)
@@ -40,9 +42,10 @@ function coderabbit_part(state: CodeRabbitState): Array<string> {
 	return mark === undefined ? [] : [tinted(`${CODERABBIT_ICON} ${mark}`, CODERABBIT_COLORS[state])]
 }
 
-function checks_part(checks: PrChecks): string {
+// `link` makes the number a link to the pull request (joshuafolkken/kit#4625); `PR` stays plain.
+function checks_part(checks: PrChecks, link: (number: number) => string): string {
 	return [
-		`PR ${String(checks.pr)}`,
+		`PR ${link(checks.pr)}`,
 		...count_part(CHECK_ICONS.pass, checks.pass),
 		...count_part(CHECK_ICONS.pending, checks.pending),
 		...count_part(CHECK_ICONS.fail, checks.fail, 'red'),
@@ -50,6 +53,38 @@ function checks_part(checks: PrChecks): string {
 	].join(GAP)
 }
 
-const run_board_render_checks = { LEGEND, checks_part }
+// The marks one row's part draws: each count it leaves in and CodeRabbit's mark.
+function marks_of(checks: PrChecks): Array<string> {
+	const counts: ReadonlyArray<readonly [string, number]> = [
+		[CHECK_ICONS.pass, checks.pass],
+		[CHECK_ICONS.pending, checks.pending],
+		[CHECK_ICONS.fail, checks.fail],
+	]
+	const drawn = counts.filter(([, count]) => count > 0).map(([icon]) => icon)
+
+	return [...drawn, CODERABBIT_MARKS[checks.coderabbit] ?? '']
+}
+
+function coderabbit_legend(drawn: ReadonlyArray<PrChecks>): Array<string> {
+	const states = new Set(drawn.map((checks) => checks.coderabbit))
+	const limited = states.has('rate-limited') ? ` (${RATE_LIMITED_MARK} rate-limited)` : ''
+
+	states.delete('none')
+
+	return states.size === 0 ? [] : [`${CODERABBIT_ICON} CodeRabbit${limited}`]
+}
+
+// What the legend says of the parts the rows draw (`drawn`): only the marks some part draws.
+function legend_of(drawn: ReadonlyArray<PrChecks>): Array<string> {
+	const marks = new Set(drawn.flatMap((checks) => marks_of(checks)))
+	const shown = CHECK_WORDS.filter(([icon]) => marks.has(icon))
+	const icons = shown.map(([icon]) => icon).join(' ')
+	const words = shown.map(([, word]) => word).join(' · ')
+	const checks = shown.length === 0 ? [] : [`${icons} checks ${words}`]
+
+	return [...checks, ...coderabbit_legend(drawn)]
+}
+
+const run_board_render_checks = { checks_part, legend_of }
 
 export { run_board_render_checks }

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

@@ -0,0 +1,96 @@
+import { run_board_fit } from './run-board-fit'
+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'
+
+// 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
+// — a 📅 row's or a done row's `MM-DD HH:MM` — so every row's number starts in one column. A value is
+// padded on its drawn width: a linked issue's escape draws nothing.
+
+const CONDITION_WIDTH = run_board_labels.day_minute_of(0).length
+const ISSUE_SEPARATOR = ', '
+const FIRST = 1
+
+// `+1` for each issue after the first, which follow the title.
+function more_of(issues: ReadonlyArray<string>): string {
+	return issues.length > FIRST ? `+${String(issues.length - FIRST)}` : ''
+}
+
+// How many of the wait's issues the column draws: the first, where it fits with its `+N` — a
+// cross-repo `owner/repo#N` reference overruns the column, so it and the rest follow the title.
+function column_count_of(issues: ReadonlyArray<string>): number {
+	const [first] = issues
+
+	if (first === undefined) return 0
+
+	return run_board_fit.width_of(`${first}${more_of(issues)}`) <= CONDITION_WIDTH ? FIRST : 0
+}
+
+// The first issue with its `+N` where the column draws it, else blank.
+function issue_value_of(issues: ReadonlyArray<string>, header: BoardHeader): string {
+	const [first = ''] = issues.slice(0, column_count_of(issues))
+
+	return first === '' ? '' : `${header.link(first)}${more_of(issues)}`
+}
+
+// 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
+
+	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 ?? ''
+}
+
+// A finished row's end, `MM-DD HH:MM`, emphasized while fresh (joshuafolkken/kit#4292); blank where
+// the row is not finished or recorded no end.
+function ended_of(row: BoardRow, header: BoardHeader): string {
+	const ended_ms = row.status?.ended_ms
+
+	if (ended_ms === undefined || !run_board_layout.is_finished(row.state)) return ''
+
+	return run_board_fresh.since(run_board_labels.day_minute_of(ended_ms), ended_ms, header)
+}
+
+// The column as drawn: what the row waits on, else when it finished, else blank.
+function condition_of(row: BoardRow, header: BoardHeader): string {
+	const reason_value = row.reason === undefined ? '' : value_of(row.reason, header)
+	const value = reason_value === '' ? ended_of(row, header) : reason_value
+	const blank = Math.max(0, CONDITION_WIDTH - run_board_fit.width_of(value))
+
+	return `${value}${' '.repeat(blank)}`
+}
+
+// The issues the wait names that the column does not draw, which follow the title; `undefined` where
+// it names none.
+function rest_of(reason: RowReason | undefined): ReadonlyArray<string> | undefined {
+	const issues = reason?.issues
+
+	return issues?.slice(column_count_of(issues))
+}
+
+function linked(issues: ReadonlyArray<string>, header: BoardHeader): string | undefined {
+	if (issues.length === 0) return undefined
+
+	return issues.map((reference) => header.link(reference)).join(ISSUE_SEPARATOR)
+}
+
+// What a row waits on after its title: in a section that draws the condition column, the issues its
+// wait names after the first; any other row — a 🙋 one, or a stalled one whose wait names no issue
+// even there — `🔗` and every blocker still standing.
+function waits_of(row: BoardRow, header: BoardHeader, is_conditioned = false): string | undefined {
+	const rest = is_conditioned ? rest_of(row.reason) : undefined
+
+	if (rest !== undefined) return linked(rest, header)
+
+	const blockers = linked(row.waits, header)
+
+	return blockers === undefined ? undefined : `${run_board_labels.WAITS_ICON} ${blockers}`
+}
+
+const run_board_render_condition = { CONDITION_WIDTH, condition_of, waits_of }
+
+export { run_board_render_condition }

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

@@ -0,0 +1,78 @@
+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_tail } from './run-board-render-tail'
+import { run_board_render_waits } from './run-board-render-waits'
+
+// What a `run:board` frame draws, read for its legend (joshuafolkken/kit#4047): every icon a phase may be
+// drawn with — the rows' leads, the header's third line and the rows' ends — the activity kinds their
+// words leave unnamed, the header's estimated finish (joshuafolkken/kit#4044), and a followup row's checks
+// (joshuafolkken/kit#3770).
+
+const { HEADER_ICONS, NOW_ICONS, WORDS } = run_board_labels
+
+function present(icons: ReadonlyArray<string | undefined>): Set<string> {
+	return new Set(icons.filter((icon) => icon !== undefined))
+}
+
+// The lanes rule stands ⏰ over the lanes' times wherever a lanes section is drawn.
+function has_lanes(header: BoardHeader): boolean {
+	const { layout } = header
+
+	return layout !== undefined && run_board_layout.lanes_drawn(layout).length > 0
+}
+
+// A lane row draws 🧍 in its indent (joshuafolkken/kit#4625).
+function has_solo_lane(header: BoardHeader): boolean {
+	const { layout } = header
+	const lanes = layout === undefined ? [] : run_board_layout.lanes_drawn(layout)
+
+	return lanes.some((row) => row.is_solo === true)
+}
+
+// The third line's kinds, ⏰ where the lanes rule stands it over the lanes' times, then the estimated
+// finish.
+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
+	const elapsed = has_lanes(header) ? `${HEADER_ICONS.elapsed} ${WORDS.elapsed}` : undefined
+	const legends = [
+		run_board_header.now_legend(header),
+		operation,
+		elapsed,
+		run_board_header.estimate_legend(header),
+	]
+
+	return legends.filter((legend) => legend !== undefined)
+}
+
+// `leads` is the icons the rows lead with, which the frame's rows already know.
+function drawn_of(
+	header: BoardHeader,
+	rows: ReadonlyArray<BoardRow>,
+	leads: ReadonlySet<string>,
+): LegendDrawn {
+	const ends = rows.flatMap((row) => [
+		run_board_render_tail.phase_icon(row),
+		run_board_render_tail.activity_icon(row, header),
+	])
+	const icons = present([...leads, run_board_header.now_icon(header), ...ends])
+	const checks = rows.flatMap((row) => run_board_render_tail.checks_of(row, header) ?? [])
+
+	return {
+		leads,
+		icons,
+		named: named_of(header, icons),
+		checks: run_board_render_checks.legend_of(checks),
+		held: run_board_render_waits.legend_of(header),
+		solo: has_solo_lane(header),
+		overrun: rows.some((row) => run_board_render_found.is_still(row, header)),
+	}
+}
+
+const run_board_render_drawn = { drawn_of }
+
+export { run_board_render_drawn }