@joshuafolkken/kit 1.2114.0 → 1.3000.0

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

@@ -10,12 +10,15 @@ import {
 import { run_board_render_section } from './run-board-render-section'
 
 // A live `run:board`'s sections folded and unfolded by one key each (joshuafolkken/kit#4172): every
-// section starts unfolded, and what a person folds holds until the board closes — it is never saved.
+// section starts as the last board left it, and what a person folds is saved to `~/.claude/josh/board.json`
+// (`$CLAUDE_CONFIG_DIR` in its place) on every fold (`run-board-fold-store.ts`, joshuafolkken/kit#7213).
 // A folded section is its heading alone, led by ▸ and saying what it holds, and the rows it gave up go
 // to the other sections before `run-board-fit.ts` cuts anything; an unfolded one's heading is led by ▾.
 
-const { folded_head, open_head } = run_board_render_section
+const { folded_head, open_head, row_count, widened } = run_board_render_section
 const SECTION_KEYS: ReadonlyMap<string, SectionKey> = new Map([
+	['t', 'throughput'],
+	['u', 'usage'],
 	['l', 'lanes'],
 	['p', 'processes'],
 	['f', 'findings'],
@@ -70,7 +73,7 @@ function fold_section(section: PlanSection, folded: ReadonlySet<SectionKey>): Pl
 	if (key === undefined || label === undefined) return section
 	if (!folded.has(key)) return headed(section, label, undefined)
 
-	const count = section.lines.filter((line) => line.row !== undefined).length
+	const count = row_count(section.lines)
 
 	return { ...headed(section, label, String(count)), lines: [] }
 }
@@ -88,13 +91,15 @@ function fold_notes(notes: NotesPart, folded: ReadonlySet<SectionKey>): NotesPar
 	return { ...headed(notes, label, count), lines: [], hidden: 0 }
 }
 
-// The processes say each group's totals.
-function fold_processes(
+// A folded detail part says its summary: the processes each group's totals, the usage gauges each
+// provider's percents, the throughput each row's closes per hour.
+function fold_detail(
 	part: DetailPart | undefined,
 	folded: ReadonlySet<SectionKey>,
+	key: SectionKey,
 ): DetailPart | undefined {
 	if (part?.label === undefined) return part
-	if (!folded.has('processes')) return headed(part, part.label, undefined)
+	if (!folded.has(key)) return headed(part, part.label, undefined)
 
 	return { ...headed(part, part.label, part.summary ?? ''), lines: [] }
 }
@@ -102,22 +107,49 @@ function fold_processes(
 function fold_parts(parts: FrameParts, folded: ReadonlySet<SectionKey>): FrameParts {
 	return {
 		...parts,
+		throughput: fold_detail(parts.throughput, folded, 'throughput'),
+		usage: fold_detail(parts.usage, folded, 'usage'),
 		plan: parts.plan.map((section) => fold_section(section, folded)),
 		below: parts.below?.map((section) => fold_section(section, folded)),
-		processes: fold_processes(parts.processes, folded),
+		processes: fold_detail(parts.processes, folded, 'processes'),
 		notes: fold_notes(parts.notes, folded),
 	}
 }
 
+function widened_part<Part extends Headed>(part: Part, width: number): Part {
+	return { ...part, head: widened(part.head, width) }
+}
+
+function widened_detail(part: DetailPart | undefined, width: number): DetailPart | undefined {
+	return part === undefined ? undefined : widened_part(part, width)
+}
+
+// Every rule run on to the lane rows' title column, folded or open (joshuafolkken/kit#5520).
+function widened_parts(parts: FrameParts): FrameParts {
+	const { rule_width: width } = parts
+
+	if (width === undefined) return parts
+
+	return {
+		...parts,
+		throughput: widened_detail(parts.throughput, width),
+		usage: widened_detail(parts.usage, width),
+		plan: parts.plan.map((section) => widened_part(section, width)),
+		below: parts.below?.map((section) => widened_part(section, width)),
+		processes: widened_detail(parts.processes, width),
+		notes: widened_part(parts.notes, width),
+	}
+}
+
 // A live frame is kept within its terminal, folded as a person folded it; any other is drawn whole.
 function bounded(parts: FrameParts, bounds: FrameBounds): Array<string> {
 	const { size, folded } = bounds
-	const shown = folded === undefined ? parts : fold_parts(parts, folded)
+	const shown = widened_parts(folded === undefined ? parts : fold_parts(parts, folded))
 
 	return size === undefined ? run_board_fit.whole(shown) : run_board_fit.fit(shown, size)
 }
 
-const run_board_fold = { KEYS_LINE, bounded, fold_parts, toggled }
+const run_board_fold = { KEYS_LINE, SECTIONS, bounded, fold_parts, toggled }
 
 export { run_board_fold }
 export type { FrameBounds }

package/scripts/run/board/run-board-gather-live.ts

@@ -3,6 +3,7 @@ import { core_budget } from '#scripts/gate/core-budget'
 import { machine_capacity } from '#scripts/gate/machine-capacity'
 import { lane_process_table } from '#scripts/lane/lane-process-table'
 import type { GatherPorts } from './run-board-gather'
+import { run_board_quota_held } from './run-board-quota-held'
 import { run_board_read } from './run-board-read'
 import { run_board_usage_read } from './run-board-usage-read'
 
@@ -16,6 +17,7 @@ function ports_of(is_live: boolean): GatherPorts {
 		read_machine: machine_capacity.read_sample,
 		read_waits: () => core_budget.budget_waits(),
 		read_usage: run_board_usage_read.usage_reader(),
+		read_quotas: run_board_quota_held.live_quota_reader(),
 		is_live,
 		now: () => Date.now(),
 		sleep: async (ms) => {

package/scripts/run/board/run-board-gather-thread.ts

@@ -1,5 +1,6 @@
 import { isDeepStrictEqual } from 'node:util'
-import { Worker } from 'node:worker_threads'
+import { Worker, type WorkerOptions } from 'node:worker_threads'
+import { ts_entry_loader } from '#scripts/run/ts-entry-loader'
 import {
 	run_board_gather,
 	type Gatherer,
@@ -168,8 +169,12 @@ async function latest_of(thread: Thread): Promise<GatherRead> {
 	})
 }
 
+function worker_options(exec_argv: ReadonlyArray<string>): WorkerOptions {
+	return { execArgv: ts_entry_loader.loader_argv(exec_argv) }
+}
+
 function spawn_worker(): GatherWorker {
-	return new Worker(WORKER_URL)
+	return new Worker(WORKER_URL, worker_options(process.execArgv))
 }
 
 // The first redraw waits for the worker's first round; every later one draws the last round handed.
@@ -183,7 +188,13 @@ function worker_gatherer(spawn: Spawn = spawn_worker, now: () => number = Date.n
 	}
 }
 
-const run_board_gather_thread = { WORKER_URL, gather_round, post_of, worker_gatherer }
+const run_board_gather_thread = {
+	WORKER_URL,
+	gather_round,
+	post_of,
+	worker_gatherer,
+	worker_options,
+}
 
 export { run_board_gather_thread }
 export type { FailedPost, GatherPost, GatherWorker }

package/scripts/run/board/run-board-gather-worker.ts

@@ -1,5 +1,6 @@
 import { setTimeout as sleep } from 'node:timers/promises'
 import { parentPort, type MessagePort } from 'node:worker_threads'
+import { poll } from '#scripts/lib/poll'
 import { run_board_gather } from './run-board-gather'
 import { run_board_gather_live } from './run-board-gather-live'
 import { run_board_gather_thread } from './run-board-gather-thread'
@@ -16,14 +17,15 @@ async function gather_forever(port: MessagePort): Promise<void> {
 	const ports = run_board_gather_live.ports_of(true)
 	let state = FRESH_GATHER
 
-	for (;;) {
-		// eslint-disable-next-line no-await-in-loop -- polling: each round folds the state the last one left
-		state = await gather_round(state, ports, (value) => {
-			port.postMessage(value)
-		})
-		// eslint-disable-next-line no-await-in-loop -- polling: each round waits a redraw
-		await sleep(run_board_spin.REDRAW_MS)
-	}
+	await poll.wait_for(
+		async () => {
+			// eslint-disable-next-line require-atomic-updates -- poll awaits each callback before starting the next gather
+			state = await gather_round(state, ports, (value) => {
+				port.postMessage(value)
+			})
+		},
+		{ interval_ms: run_board_spin.REDRAW_MS, sleeper: sleep },
+	)
 }
 
 if (parentPort !== null) await gather_forever(parentPort)

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

@@ -6,6 +6,7 @@ import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import type { BoardUsage } from './run-board-header'
 import { run_board_idle, type IdleSince } from './run-board-idle'
 import { run_board_machine, type MachineGauges, type MachineMark } from './run-board-machine'
+import type { Quotas } from './run-board-quota-read'
 import type { LocalRead } from './run-board-read'
 import { run_board_state, type Pace } from './run-board-state'
 import type { UsageMark } from './run-board-usage'
@@ -35,6 +36,8 @@ interface GatherPorts {
 	read_waits?: (() => Array<BudgetWait>) | undefined
 	// Every process and its lane, the last reading's lanes reused (`run-board-usage-read.ts`).
 	read_usage: (before: UsageMark | undefined, table: TableRead) => Promise<UsageMark | undefined>
+	// The usage-limit windows' held readings (`run-board-quota-held.ts`); none where it is not given.
+	read_quotas?: (() => Promise<Quotas>) | undefined
 	// Whether the reads go on — a live board — so a usage reading has the last one to compare against.
 	is_live: boolean
 	now: () => number
@@ -52,6 +55,8 @@ interface GatherRead {
 	// Each lane's and each process group's usage, `undefined` where none could be read.
 	usages: BoardUsage | undefined
 	budget_waits: ReadonlyArray<BudgetWait>
+	// Claude's and Codex's usage-limit windows; `undefined` where no reader is given.
+	quotas?: Quotas | undefined
 	// When the reads last failed; `undefined` once a read has answered since.
 	read_failed_ms?: number | undefined
 	// Why they failed, the first line of the error; cleared with `read_failed_ms`.
@@ -149,8 +154,9 @@ async function resample(
 	const gauges = run_board_machine.gauges_of(state.machine, machine)
 	const budget_waits = ports.read_waits?.() ?? []
 	const usages = await run_board_usage_board.read_usages(state, ports, at.table)
+	const quotas = await ports.read_quotas?.()
 
-	return { ...state, ...usages, machine, gauges, budget_waits, sampled_ms: at.now_ms }
+	return { ...state, ...usages, machine, gauges, budget_waits, quotas, sampled_ms: at.now_ms }
 }
 
 // One round of the reads. The process snapshot is read once, by whichever of the lane read and the
@@ -163,10 +169,11 @@ async function gather(state: GatherState, ports: GatherPorts, pace: Pace): Promi
 
 // What a frame draws, without the marks the next reads compare against.
 function read_of(state: GatherState): GatherRead {
-	const { local, read_ms, idle_since, gauges, usages, budget_waits } = state
+	const { local, read_ms, idle_since, gauges, usages, budget_waits, quotas } = state
 	const { read_failed_ms, read_error } = state
+	const marks = { read_failed_ms, read_error }
 
-	return { local, read_ms, idle_since, gauges, usages, budget_waits, read_failed_ms, read_error }
+	return { local, read_ms, idle_since, gauges, usages, budget_waits, quotas, ...marks }
 }
 
 // A single frame's reads, taken afresh each time it is drawn.

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

@@ -1,5 +1,5 @@
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
-import { run_progress_cli } from '#scripts/run/progress/run-progress-cli'
+import { run_progress } from '#scripts/run/progress/run-progress'
 import type { ClosedAnswer } from './run-board-closed'
 import { run_board_fetch, type Fetch } from './run-board-fetch'
 import { run_board_idle } from './run-board-idle'
@@ -21,12 +21,15 @@ import {
 // keeps the previous plan on screen and says when it failed. A run that ended keeps its plan as it
 // last read.
 
-const PLAN_RETRY_MS = run_progress_cli.DECLINE_RETRY_SECONDS * MS_PER_SECOND
+const PLAN_RETRY_MS = run_progress.DECLINE_RETRY_SECONDS * MS_PER_SECOND
 // A rejected closed read answers nothing closed and not whole, so it is asked again.
 const UNANSWERED: ClosedAnswer = { closed: new Map(), is_whole: false }
 const { is_due } = run_board_state
 const STOPPED_STATE: ItemState = 'stopped'
 const RUNNING_STATE: ItemState = 'running'
+// A child waiting on a person, drawn in 🙋 decision until a closed read settles it.
+const { WAITING_STATES } = run_board_status
+const ALWAYS_ASKED_STATES: ReadonlySet<ItemState> = new Set([STOPPED_STATE, ...WAITING_STATES])
 
 // What a step of the GitHub reads works against.
 interface Gather {
@@ -102,7 +105,7 @@ function fold_plan(state: BoardState): BoardState {
 }
 
 function statuses_for(state: BoardState, local: LocalRead): ReadonlyMap<number, ItemStatus> {
-	const stopped = run_board_idle.stopped_of(state.idle_since, state.read_ms)
+	const stopped = run_board_idle.stopped_since(state.idle_since, state.read_ms)
 
 	return run_board_status.statuses_of(local.events, local.lane_states, stopped)
 }
@@ -126,48 +129,56 @@ function is_unlisted(issue: number, read: OpenRead): boolean {
 // A child still drawn stopped or running holds no closed read of this launch — any it holds closed
 // before it relaunched — so it is asked again. A running child is asked too while the plan read fails:
 // the kept plan still lists it, and an empty listing — failed, or a repository whose last open issue
-// was this child — would otherwise leave it running forever (joshuafolkken/kit#4537).
+// was this child — would otherwise leave it running forever (joshuafolkken/kit#4537). A child waiting
+// on a person is asked whatever the listing says: the listing is held once the run ends, so a close
+// it never saw kept the child in 🙋 decision (joshuafolkken/kit#6535).
 function is_closed_candidate(
 	issue: number,
 	status: ItemStatus,
 	read: OpenRead,
 	is_plan_failed: boolean,
 ): boolean {
-	if (status.state === STOPPED_STATE) return true
+	if (ALWAYS_ASKED_STATES.has(status.state)) return true
 	if (status.state === RUNNING_STATE) return is_plan_failed || is_unlisted(issue, read)
 
 	return is_unlisted(issue, read) && !read.closed.has(issue)
 }
 
+// An ended run asks until one ask after it ended has answered whole, then holds what it has, as its
+// plan is held: the board is left open between runs, so a child that never answers closed would
+// otherwise be asked about every retry interval while no run is going. A child waiting on a person
+// is the exception — the person closing it is what the board waits to draw.
+function has_asked_since_end(state: BoardState, local: LocalRead): boolean {
+	const { closed_answered_ms } = state
+	if (closed_answered_ms === undefined || local.ended_ms === undefined) return false
+
+	return closed_answered_ms >= local.ended_ms
+}
+
 // The children the board has not read closed yet that the open listing no longer holds, or that it
-// draws stopped: a child that merged itself and left its lane is drawn stopped until GitHub says it
-// merged (joshuafolkken/kit#4401), and a listing cut short proves nothing missing.
+// draws stopped or waiting: a child that merged itself and left its lane is drawn stopped until GitHub
+// says it merged (joshuafolkken/kit#4401), and a listing cut short proves nothing missing.
 function unread_closed(state: BoardState, local: LocalRead): Array<number> {
 	const read = open_read_of(state, state.plan)
 	const drawn = run_board_status.settle_closed(statuses_for(state, local), read)
 	const is_plan_failed = state.failed_ms !== undefined
+	const is_ended = has_asked_since_end(state, local)
 
 	return [...drawn]
-		.filter(([issue, status]) => is_closed_candidate(issue, status, read, is_plan_failed))
+		.filter(([issue, status]) =>
+			is_ended
+				? WAITING_STATES.has(status.state)
+				: is_closed_candidate(issue, status, read, is_plan_failed),
+		)
 		.map(([issue]) => issue)
 }
 
-// An ended run asks until one ask after it ended has answered whole, then holds what it has, as its
-// plan is held: the board is left open between runs, so a child that never answers closed would
-// otherwise be asked about every retry interval while no run is going.
-function has_asked_since_end(state: BoardState, local: LocalRead): boolean {
-	const { closed_answered_ms } = state
-	if (closed_answered_ms === undefined || local.ended_ms === undefined) return false
-
-	return closed_answered_ms >= local.ended_ms
-}
-
 function has_new_child(state: BoardState, unread: ReadonlyArray<number>): boolean {
 	return unread.some((issue) => !state.closed_asked.has(issue))
 }
 
 function is_closed_due(state: BoardState, gather: Gather, unread: ReadonlyArray<number>): boolean {
-	if (state.closed_fetch !== undefined || has_asked_since_end(state, gather.local)) return false
+	if (state.closed_fetch !== undefined) return false
 
 	return (
 		has_new_child(state, unread) || is_due(state.closed_attempted_ms, PLAN_RETRY_MS, gather.now_ms)
@@ -213,6 +224,70 @@ function fold_closed(state: BoardState): BoardState {
 	}
 }
 
+// The core rate limit is asked as often as the plan; a read in flight is not launched again.
+function launch_rate_limit(state: BoardState, gather: Gather): BoardState {
+	const { read_rate_limit } = gather.ports
+
+	if (
+		read_rate_limit === undefined ||
+		state.rate_limit_fetch !== undefined ||
+		!is_due(state.rate_limit_attempted_ms, PLAN_RETRY_MS, gather.now_ms)
+	) {
+		return state
+	}
+
+	const rate_limit_fetch = run_board_fetch.launch(read_rate_limit, undefined)
+
+	return { ...state, rate_limit_fetch, rate_limit_attempted_ms: gather.now_ms }
+}
+
+// A failed read answers `undefined`, which clears the last allowance rather than drawing a stale one.
+function fold_rate_limit(state: BoardState): BoardState {
+	const answer = state.rate_limit_fetch?.answer()
+
+	if (answer === undefined) return state
+
+	return { ...state, rate_limit: answer.value, rate_limit_fetch: undefined }
+}
+
+// The repository's issue count is asked as often as the plan, once the plan has named the repository;
+// a read in flight is not launched again, and an ended run holds the count it has, as it holds its plan.
+function is_issue_count_due(state: BoardState, gather: Gather): boolean {
+	if (state.issue_count_fetch !== undefined) return false
+	if (gather.local.ended_ms !== undefined && state.issue_count !== undefined) return false
+
+	return is_due(state.issue_count_attempted_ms, PLAN_RETRY_MS, gather.now_ms)
+}
+
+function repo_of(state: BoardState): string | undefined {
+	return state.plan?.context.repo
+}
+
+function launch_issue_count(state: BoardState, gather: Gather): BoardState {
+	const { read_issue_count } = gather.ports
+	const repo = repo_of(state)
+
+	if (repo === undefined || read_issue_count === undefined || !is_issue_count_due(state, gather)) {
+		return state
+	}
+
+	const issue_count_fetch = run_board_fetch.launch(
+		read_issue_count.bind(undefined, repo),
+		undefined,
+	)
+
+	return { ...state, issue_count_fetch, issue_count_attempted_ms: gather.now_ms }
+}
+
+// A failed read answers `undefined`, which clears the last count rather than drawing a stale one.
+function fold_issue_count(state: BoardState): BoardState {
+	const answer = state.issue_count_fetch?.answer()
+
+	if (answer === undefined) return state
+
+	return { ...state, issue_count: answer.value, issue_count_fetch: undefined }
+}
+
 // At the `settled` pace, waits for a read in flight to land.
 async function settle(pending: Fetch<unknown> | undefined, pace: Pace): Promise<void> {
 	if (pending !== undefined && pace === 'settled') await pending.landed
@@ -227,25 +302,38 @@ function known_of(state: BoardState): Known {
 
 // Each read that landed rewrites the snapshot whole, for the board opened next on this run.
 function keep_snapshot(before: BoardState, after: BoardState, gather: Gather): void {
-	if (after.plan === before.plan && after.closed === before.closed) return
+	const is_same = after.plan === before.plan && after.closed === before.closed
 
+	if (is_same && after.issue_count === before.issue_count) return
+
+	const { closed, issue_count } = after
 	const run_started_ms = gather.local.started_ms
 
-	gather.ports.snapshot?.save({ run_started_ms, ...known_of(after), closed: after.closed })
+	gather.ports.snapshot?.save({ run_started_ms, ...known_of(after), closed, issue_count })
 }
 
-// Folds what landed and launches what is due — the plan first, since the closed children are read off
-// the plan's listing.
-async function gather_github(state: BoardState, gather: Gather): Promise<BoardState> {
-	const planned = launch_plan(fold_plan(state), gather)
+// The reads the plan has to land first: the closed children are read off its listing, and the issue
+// count asks for the repository it names.
+async function gather_after_plan(planned: BoardState, gather: Gather): Promise<BoardState> {
+	const opened = fold_issue_count(fold_closed(fold_plan(planned)))
+	const closing = launch_issue_count(launch_closed(opened, gather), gather)
 
-	await settle(planned.plan_fetch, gather.pace)
+	await settle(closing.closed_fetch, gather.pace)
+	await settle(closing.issue_count_fetch, gather.pace)
 
-	const closing = launch_closed(fold_closed(fold_plan(planned)), gather)
+	return fold_issue_count(fold_rate_limit(fold_closed(closing)))
+}
 
-	await settle(closing.closed_fetch, gather.pace)
+// Folds what landed and launches what is due — the plan first, since the reads after it need it; the
+// rate limit beside the plan, since nothing waits on it.
+async function gather_github(state: BoardState, gather: Gather): Promise<BoardState> {
+	const folded = fold_plan(fold_rate_limit(state))
+	const planned = launch_rate_limit(launch_plan(folded, gather), gather)
+
+	await settle(planned.plan_fetch, gather.pace)
+	await settle(planned.rate_limit_fetch, gather.pace)
 
-	const gathered = fold_closed(closing)
+	const gathered = await gather_after_plan(planned, gather)
 
 	keep_snapshot(state, gathered, gather)
 

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

@@ -2,18 +2,23 @@ import { styleText } from 'node:util'
 import type { BudgetWait } from '#scripts/gate/core-wait'
 import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 import { run_board_estimate } from './run-board-estimate'
+import { run_board_first_lane } from './run-board-first-lane'
 import { run_board_fit } from './run-board-fit'
 import type { FoundOf } from './run-board-found'
 import { run_board_fresh } from './run-board-fresh'
+import { run_board_issue_count, type IssueCount } from './run-board-issue-count'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type BoardLayout, type BoardRow } from './run-board-layout'
+import type { BoardLinks } from './run-board-link'
 import { run_board_machine, type MachineGauges } from './run-board-machine'
 import { run_board_now, type NowLine } from './run-board-now'
 import type { SessionOperations } from './run-board-operation-read'
 import { run_board_priority } from './run-board-priority'
 import type { ProcessGroups } from './run-board-process-groups'
+import type { QuotaHold, QuotaView } from './run-board-render-quota'
 import { run_board_render_slot } from './run-board-render-slot'
 import { run_board_render_title } from './run-board-render-title'
+import type { SeatRead } from './run-board-seat'
 import type { RunActivity } from './run-board-status'
 import type { LaneUsages, UsageScale } from './run-board-usage'
 import type { UsualTimes } from './run-board-usual'
@@ -64,8 +69,13 @@ interface BoardUsage {
 	scale: UsageScale
 }
 
-interface BoardHeader {
+// Claude's and Codex's usage-limit windows and GitHub's core rate limit are the usage row's
+// (`run-board-render-quota.ts`). Its links are made where the terminal opens one (`run-board-link.ts`).
+interface BoardHeader
+	extends Pick<QuotaView, 'quotas' | 'scheduler_provider' | 'rate_limit'>, BoardLinks {
 	now_ms: number
+	// A single run's name (`run-board-single.ts`); `undefined` draws `backlogrun`.
+	run_name?: string | undefined
 	started_ms: number
 	// Set once the run has ended: the title then says when, and how long it took.
 	ended_ms: number | undefined
@@ -89,10 +99,16 @@ interface BoardHeader {
 	usages?: BoardUsage | undefined
 	// The claims waiting in the machine-wide core budget (`run-board-render-waits.ts`).
 	budget_waits?: ReadonlyArray<BudgetWait> | undefined
+	// The usage limit holding the run's launches; `undefined` where none holds.
+	quota_hold?: QuotaHold | undefined
 	// How long each phase usually takes; a running row's phase time is colored against it.
 	usual?: UsualTimes | undefined
 	// How many lanes the run may hold at once, which the estimated finish stacks the waiting children on.
 	lane_limit?: number | undefined
+	// The slots occupied according to the same capacity read that supplies the limit.
+	occupied_count?: number | undefined
+	// What explains the seats no lane holds (`run-board-seat.ts`).
+	seats?: SeatRead | undefined
 	// What each done row says after its time (`run-board-found.ts`); none where nothing was read.
 	found?: FoundOf | undefined
 	// Whether `JOSH_LANE_INVESTIGATION` is on; off, a merged row hides its minutes and investigation
@@ -104,11 +120,8 @@ interface BoardHeader {
 	form: BoardForm
 	// The repository the plan was read for, as `owner/repo`; `undefined` before a plan is read.
 	repo: string | undefined
-	// An issue reference as the board draws it — `3450` or `owner/repo#12` — made a link where the
-	// terminal opens one.
-	link: (reference: string) => string
-	// A pull request's number, made a link to it where the terminal opens one (joshuafolkken/kit#4625).
-	pull_link: (number: number) => string
+	// The repository's open and closed issues, `undefined` where none was read.
+	issue_count?: IssueCount | undefined
 }
 
 interface BoardCounts {
@@ -169,10 +182,10 @@ function mark_of(header: BoardHeader, running: number): RunMark {
 }
 
 // The mark stands still in every state: the spinner turns on the third line.
-function run_part(mark: RunMark): string {
+function run_part(mark: RunMark, name = RUN_NAME): string {
 	const { glyph, color } = RUN_MARKS[mark]
 
-	return styleText(color, `${glyph} ${RUN_NAME}`)
+	return styleText(color, `${glyph} ${name}`)
 }
 
 // The repository's own name — `kit` of `owner/kit` — under the run's, past the mark's columns, so a
@@ -181,7 +194,7 @@ function repo_part(header: BoardHeader, mark: RunMark): string {
 	const name = header.repo?.split(REPO_SEPARATOR).at(-1) ?? ''
 	const indent = run_board_fit.width_of(RUN_MARKS[mark].glyph) + BLANK.length
 
-	return `${BLANK.repeat(indent)}${name}`
+	return `${BLANK.repeat(indent)}${header.repo_link(name, 'home')}`
 }
 
 // A part aged as the `💓` is: yellow once stale, red once alarming — a row's newest activity too
@@ -224,10 +237,9 @@ function beat_part(header: BoardHeader, mark: RunMark, width: number): string {
 	return WORKING_MARKS.has(mark) ? aged(part, age) : part
 }
 
-// How long ago what the third line says happened, blank where no event gave it a time.
-function now_age(now: NowLine | undefined): string {
-	const age = now?.age_ms
-
+// An age in the `⏰`'s format, blank where there is none to draw — no event gave it a time, or the
+// `💓` draws none.
+function span_or_blank(age: number | undefined): string {
 	return age === undefined ? '' : span_of(age)
 }
 
@@ -239,13 +251,6 @@ function fresh_age(now: NowLine | undefined, header: BoardHeader): number | unde
 	return age === undefined ? undefined : age + header.now_ms - (header.ended_ms ?? header.now_ms)
 }
 
-// The `💓`'s digits, blank where it draws none.
-function beat_span(header: BoardHeader): string {
-	const age = age_of(header)
-
-	return age === undefined ? '' : span_of(age)
-}
-
 // The third line's time: the spinner in the `⏰`'s and `💓`'s column — turning only while the run
 // works, so a watch or an end stands blank — then its age, digits under theirs, emphasized while what
 // the line says is fresh.
@@ -257,7 +262,7 @@ function now_time(
 ): string {
 	const spinner = WORKING_MARKS.has(mark) ? header.spinner : undefined
 	const icon = cell_of(spinner, run_board_fit.width_of(HEADER_ICONS.heartbeat))
-	const age = now_age(now)
+	const age = span_or_blank(now?.age_ms)
 
 	return `${icon} ${padded(age, width, aged_fresh(age, fresh_age(now, header), header))}`
 }
@@ -272,8 +277,10 @@ function now_text(now: NowLine, header: BoardHeader): string {
 // passed ten hours.
 function time_parts(header: BoardHeader, mark: RunMark, now: NowLine | undefined): Array<string> {
 	const elapsed = span_of((header.ended_ms ?? header.now_ms) - header.started_ms)
-	const age = now_age(now)
-	const width = Math.max(...[elapsed, beat_span(header), age].map((span) => span.length))
+	const age = span_or_blank(now?.age_ms)
+	const width = Math.max(
+		...[elapsed, span_or_blank(age_of(header)), age].map((span) => span.length),
+	)
 
 	return [
 		`${HEADER_ICONS.elapsed} ${elapsed.padStart(width)}`,
@@ -368,9 +375,11 @@ function progress_parts(counts: BoardCounts, header: BoardHeader): Array<string
 function progress_part(counts: BoardCounts, header: BoardHeader): string {
 	const parts = [
 		...progress_parts(counts, header),
+		run_board_first_lane.part(header.activity),
 		loading_part(header),
 		warning_of(WORDS.plan, header.plan_failed_ms),
 		warning_of(WORDS.read, header.read_failed_ms, header.read_error),
+		run_board_issue_count.part_of(header.repo, header.issue_count, header.repo_link),
 	]
 
 	return parts.filter((part) => part !== undefined).join(GAP)
@@ -432,7 +441,7 @@ function header_lines(header: BoardHeader): Array<string> {
 	const counts = counts_of(layout_of(header))
 	const mark = mark_of(header, counts.running)
 	const now = now_line(counts, header)
-	const names = column_of([run_part(mark), repo_part(header, mark), ''])
+	const names = column_of([run_part(mark, header.run_name), repo_part(header, mark), ''])
 	const times = column_of(time_parts(header, mark, now))
 	const lasts = [progress_part(counts, header), machine_part(counts, header)]
 	const third =