@joshuafolkken/kit 1.1379.0 → 1.1383.0

package/scripts/epic/epic-cross-repo.ts

@@ -80,7 +80,7 @@ const NOT_FOUND_STATUS = 404
 //
 // **`absent` is not `unreadable`.** A repository with no
 // manifest, or one whose manifest says `private`, publishes nothing — so a closed blocker there has
-// no release anyone could wait for, and waiting means waiting until the run's own eight-hour timeout
+// no release anyone could wait for, and waiting means waiting until the run's idle wait runs out
 // with nothing an operator can edit to clear it. A read that merely failed says none of that.
 //
 // **It is read from the repository rather than from the registry, and that is the whole design.** The
@@ -123,7 +123,7 @@ type WorkspaceCheck = 'workspace' | 'single' | 'unreadable'
 //
 // **The file's existence proves nothing.** `josh sync` distributes it to every consumer regardless of
 // layout — it carries `allowBuilds`, `overrides` and the like — so probing for its presence would read
-// every private first-party repository as a workspace and wait the eight-hour timeout on each. What
+// every private first-party repository as a workspace and wait the whole idle wait on each. What
 // makes a repository a workspace is a non-empty `packages`
 // key, so that is what is read.
 function declares_packages(yaml: string): boolean {
@@ -271,7 +271,7 @@ function read_default_branch_version(repo: string): string | undefined {
 // would start a dependent before its blocker's release existed. What is asked is only whether the
 // repository *is* a workspace — the members are not enumerated and nothing looks for which of them
 // publishes, so a workspace whose members are all private waits when it need not. That is the safe
-// direction: waiting ends at the run's own timeout, resolving early does not end at all.
+// direction: waiting ends when the run's idle wait runs out, resolving early does not end at all.
 function publishes_nothing(repo: string): boolean {
 	const answer = read_manifest(repo)
 
@@ -285,7 +285,7 @@ function publishes_nothing(repo: string): boolean {
 //
 // **"Ships nothing" is asked first, and it is a different question.** Waiting is right only where
 // something could still arrive; a closed blocker in a repository that publishes no package has no
-// release for `is_published` to ever find, so it would wait until the run's own eight-hour timeout
+// release for `is_published` to ever find, so it would wait until the run's idle wait runs out
 // with nothing an operator could edit to clear it. It is answered from that repository's own manifest and never from
 // the registry, for the reason `ManifestAnswer` records: a registry 404 also means "this token may
 // not see it", and resolving on one would start a consumer child before its blocker's release

package/scripts/epic/epic-next.ts

@@ -194,7 +194,7 @@ function refuse(reason: string): number {
 
 // The verdict as it applies to *this* repository. `run` never reaches a caller here: it means some
 // other repository has work, which for this session is something to wait on rather than a state its
-// loop has a branch for. The whole-run timeout is what bounds that wait.
+// loop has a branch for. The idle wait is what bounds that wait.
 function repo_verdict(verdict: LaneOffer['verdict']): LaneOffer['verdict'] {
 	return verdict === 'run' ? 'wait' : verdict
 }

package/scripts/hooks/stop-guard.ts

@@ -126,20 +126,22 @@ async function outcome_of(raw_payload: string): Promise<StopOutcome> {
 
 // A live carry record is in place — `carried` alone reads as a run. Both report checks below are about
 // a carried run: the strand judge reads this very record and returns on anything but `carried`, and a
-// stall needs a backlog driver, which begins one before its plan. A spent (`expired`) or `unreadable`
-// record a crashed run left behind is no run either, so it does not re-arm the stall's backlog probe
-// on every stop.
+// stall needs a backlog driver, which begins one before its plan. An `unreadable`
+// record a crashed run left behind is no run either.
+// The answer is whether that run's owner is still live, and `undefined` where there is no run at all.
 // A failed git read — outside a repository, `git rev-parse` exits non-zero — reads as no run, since this
 // gate sits ahead of the checks' own swallowing and must not throw into the stop decision either.
-async function has_run_record(): Promise<boolean> {
+async function carried_owner_live(): Promise<boolean | undefined> {
 	try {
 		const directory = await run_carry.repository_directory()
 
-		if (directory === undefined) return false
+		if (directory === undefined) return undefined
 
-		return run_carry.read_carry(run_carry.carry_path(directory)).kind === 'carried'
+		const read = run_carry.read_carry(run_carry.carry_path(directory))
+
+		return read.kind === 'carried' ? run_carry.is_owner_live(read.carry) : undefined
 	} catch {
-		return false
+		return undefined
 	}
 }
 
@@ -149,10 +151,19 @@ async function has_run_record(): Promise<boolean> {
 // — the budget handed off, the owner dead, no supervisor watching. Both only report and swallow their
 // own failures, so neither can change the stop decision. An ordinary stop with no run record skips
 // both, so it pays one directory read rather than their reads and a stale stream's backlog probe.
+//
+// **A stall is a live driver not dispatching, so a record whose owner is gone is not asked.** A record
+// stands until a person carries or discards it, so a crashed run's would otherwise re-arm the stall's
+// `git worktree list` and network backlog probe on every stop in the repository, for a run nobody
+// drives. A gone driver is the strand check's question — handed off or not (`run-stranded.ts` →
+// `had_driver`) — and that one reads local files only.
 async function run_report_checks(): Promise<void> {
-	if (!(await has_run_record())) return
+	const is_owner_live = await carried_owner_live()
+
+	if (is_owner_live === undefined) return
+
+	if (is_owner_live) await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS)
 
-	await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS)
 	await run_stranded_detect.run_stranded_check()
 }
 

package/scripts/josh/josh-commands-ai.ts

@@ -214,7 +214,7 @@ const AI_COMMANDS: Record<string, CommandEntry> = {
 		// credentials, the same reason `run:wake` carries these flags.
 		tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
 		description:
-			'Report whether the run is stranded — budget handed off, owner gone, and no supervisor watching',
+			'Report whether the run is stranded — owner gone, no successor holding the budget, and no supervisor watching',
 		category: 'AI tools',
 		reference: ['', 'automation', ['processes', 'notifications']],
 	},

package/scripts/lane/lane-cli.ts

@@ -62,9 +62,7 @@ async function guard_cut_session(): Promise<string | undefined> {
 
 	const read = run_carry.read_carry(run_carry.carry_path(directory))
 
-	if ((read.kind !== 'carried' && read.kind !== 'expired') || read.carry.is_handed_off !== true) {
-		return undefined
-	}
+	if (read.kind !== 'carried' || read.carry.is_handed_off !== true) return undefined
 
 	return run_carry.count_refused_message(read.carry)
 }

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

@@ -1,33 +1,36 @@
 import { styleText } from 'node:util'
 import { backlog_budget } from '#scripts/backlog/backlog-budget'
-import { backlog_idle, type IdleWindow } from '#scripts/backlog/backlog-idle'
+import { run_board_fit } from './run-board-fit'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type BoardLayout, type BoardRow } from './run-board-layout'
 import { run_board_machine, type MachineGauges } from './run-board-machine'
+import { run_board_render_slot } from './run-board-render-slot'
 import type { RunActivity } from './run-board-status'
 import type { LaneUsages } from './run-board-usage'
 
-// The top of `run:board`: whether the run is moving, how long it has run, how long it has left, how
-// fresh its last event is, and how far through the plan it is — and, while it waits on an empty
-// backlog, until when it waits and what ends the wait. Every time comes from a record (the carry's
-// start, the stream's events, the `idle` window); nothing here guesses one. Lines of symbols rather
-// than sentences: the `⏱` that moves every second is the proof the board is live, so no `updated`
-// line is drawn. Beside the time, the machine the run is on, so a slow run reads apart from a stuck
-// one. **Always two lines**: the run's state with its progress, then the time with the machine. A
-// value not read yet is drawn `-`, never `0`, so a header still loading reads as unknown rather than
-// as an empty run.
-
-const { HEADER_ICONS, STATE_ICONS, WORDS, bar_of, clock_of, elapsed_of, left_of, minute_of } =
-	run_board_labels
+// The top of `run:board`: whether the run is moving, how long it has run, how fresh its last event is,
+// and how far through the plan it is. Every time comes from a record (the carry's start, the stream's
+// events); nothing here guesses one. Lines of symbols rather than sentences: the `⏰` that moves every
+// second is the proof the board is live, so no `updated` line is drawn. **Always two lines, in three
+// columns**: the run's mark and name over its repository's, the run's age over the `💓`, then the
+// progress over the machine the run is on — so the first line reads as how far the run is and the
+// second as what it runs on, a slow run apart from a stuck one. Both are written the same while the
+// run works and while it waits, so a wait is read off the mark and the `💓` rather than off a line
+// that changes shape. A value not read yet is drawn `-`, never `0`, so a header still loading reads
+// as unknown rather than as an empty run.
+
+const { HEADER_ICONS, STATE_ICONS, WORDS, bar_of, minute_of, span_of } = run_board_labels
+const { cell_of } = run_board_render_slot
 const UNKNOWN = '-'
-const { GAP } = run_board_machine
+const BLANK = ' '
+const REPO_SEPARATOR = '/'
+const { GAP, PERCENT_WIDTH } = run_board_machine
 // A running run whose newest event is older than this is drawn as stale, so a hang stands out; past
 // twice that it is drawn as alarming.
 const STALE_MINUTES = 15
 const STALE_MS = STALE_MINUTES * backlog_budget.MS_PER_MINUTE
 const ALARM_FACTOR = 2
 const ALARM_MS = STALE_MS * ALARM_FACTOR
-const INDENT = '  '
 const RUN_NAME = 'backlogrun'
 
 // Who reads the frame: a person on a screen, or a chat a session answers a progress question in, which
@@ -56,6 +59,8 @@ interface BoardHeader {
 	// terminal and they draw their still icons.
 	spinner: string | undefined
 	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
@@ -103,9 +108,8 @@ function quiet_mark(layout: BoardLayout | undefined): RunMark {
 // The run's state, each state overriding the ones below it.
 function mark_of(header: BoardHeader, running: number): RunMark {
 	if (header.activity.is_stopped) return 'stopped'
-	if (running > 0) return 'running'
 
-	return header.activity.idle === undefined ? quiet_mark(header.layout) : 'idle'
+	return running > 0 ? 'running' : quiet_mark(header.layout)
 }
 
 // A running run turns the spinner in place of ▶, both one column wide; every other mark stands still.
@@ -116,25 +120,61 @@ function run_part(mark: RunMark, spinner: string | undefined): string {
 	return styleText(color, `${shown} ${RUN_NAME}`)
 }
 
+// The repository's own name — `kit` of `owner/kit` — under the run's, past the mark's columns, so a
+// board open beside another repository's is told apart. Blank before a plan names one.
+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}`
+}
+
 function aged(part: string, age_ms: number): string {
 	if (age_ms > ALARM_MS) return styleText('red', part)
 
 	return age_ms > STALE_MS ? styleText('yellow', part) : part
 }
 
-// How long ago the stream last moved; only a running run can be stale, so only it is colored. An ended
-// run has no heartbeat to keep: one counting on would read as a hang.
-function heartbeat_part(header: BoardHeader, mark: RunMark): string | undefined {
+// How long ago the stream last moved. An ended run has no heartbeat to keep: one counting on would
+// read as a hang.
+function age_of(header: BoardHeader): number | undefined {
 	const last = header.activity.last_event_ms
 
 	if (last === undefined || header.ended_ms !== undefined) return undefined
 
-	const age = header.now_ms - last
-	const part = `💓 ${elapsed_of(age)}`
+	return header.now_ms - last
+}
+
+// The minute an ended run ended, standing where its heartbeat did. Blank while the run has none to draw.
+function ended_part(header: BoardHeader): string {
+	const { ended_ms } = header
+
+	return ended_ms === undefined ? '' : `${HEADER_ICONS.ended} ${minute_of(ended_ms)}`
+}
+
+// The `💓` under the run's age, in the `⏰`'s own format with its digits right-aligned to `width` —
+// only a running run can be stale, so only it is colored. Only an ended run draws anything else there:
+// the minute it ended.
+function beat_part(header: BoardHeader, mark: RunMark, width: number): string {
+	const age = age_of(header)
+
+	if (age === undefined) return ended_part(header)
+
+	const part = `${HEADER_ICONS.heartbeat} ${span_of(age).padStart(width)}`
 
 	return mark === 'running' ? aged(part, age) : part
 }
 
+// A run's age over the `💓`, or over the minute an ended run ended: the shorter of the two lengths is
+// right-aligned to the longer, so the digits stand in one column when only one has passed ten hours.
+function time_parts(header: BoardHeader, mark: RunMark): Array<string> {
+	const elapsed = span_of((header.ended_ms ?? header.now_ms) - header.started_ms)
+	const age = age_of(header)
+	const width = Math.max(elapsed.length, age === undefined ? 0 : span_of(age).length)
+
+	return [`${HEADER_ICONS.elapsed} ${elapsed.padStart(width)}`, beat_part(header, mark, width)]
+}
+
 // A plan fetch is said only when it failed — the board otherwise keeps quiet about a routine read.
 function plan_warning(header: BoardHeader): string | undefined {
 	const failed = header.plan_failed_ms
@@ -152,23 +192,6 @@ function loading_part(header: BoardHeader): string | undefined {
 	return is_plan_loading && spinner !== undefined ? `${HEADER_ICONS.loading} ${spinner}` : undefined
 }
 
-// A running run's age and time left before the cut-off, or an ended run's frozen duration and the
-// minute it ended — an ended run has no cut-off left.
-function time_parts(header: BoardHeader): Array<string> {
-	const { now_ms, started_ms, ended_ms } = header
-
-	if (ended_ms !== undefined) {
-		return [
-			`⏱ ${elapsed_of(ended_ms - started_ms)}`,
-			`${HEADER_ICONS.ended} ${minute_of(ended_ms)}`,
-		]
-	}
-
-	const cutoff = started_ms + backlog_budget.WHOLE_RUN_BUDGET_MS
-
-	return [`⏱ ${elapsed_of(now_ms - started_ms)}`, `⌛ ${left_of(cutoff - now_ms)}`]
-}
-
 function layout_of(header: BoardHeader): BoardLayout {
 	return header.layout ?? run_board_layout.EMPTY_LAYOUT
 }
@@ -186,14 +209,25 @@ function plus_of(counts: BoardCounts, header: BoardHeader): string {
 	return added > 0 ? ` (+${String(added)})` : ''
 }
 
-// Icon, figure, then bar, as the machine gauges: the settled count is right-aligned to the total's
-// width, so the bar starts in one column as the count grows. Arrivals since the board first looked
-// follow the bar, where they cannot move it.
-function tally_part(counts: BoardCounts, is_read: boolean): string {
+// The plan's total as the tally draws it, unknown until the plan is read.
+function total_of(counts: BoardCounts, header: BoardHeader): string {
+	return is_plan_read(header) ? String(counts.total) : UNKNOWN
+}
+
+// The width the tally and the machine's first figure are both right-aligned to — the wider of a full
+// tally and a full percent — so the progress bar and the gauge under it start in one column, and
+// neither moves as a count or a percent gains a digit.
+function figure_width(total: string): number {
+	return Math.max(PERCENT_WIDTH, `${total}/${total}`.length)
+}
+
+// Icon, figure, then bar, as the machine gauges. Arrivals since the board first looked follow the
+// bar, where they cannot move it.
+function tally_part(counts: BoardCounts, header: BoardHeader): string {
 	const { settled } = counts
-	const total = is_read ? String(counts.total) : UNKNOWN
-	const tally = `${String(settled)}/${total}`.padStart(`${total}/${total}`.length)
-	const bar = is_read ? bar_of(settled, counts.total) : bar_of(0, 0)
+	const total = total_of(counts, header)
+	const tally = `${String(settled)}/${total}`.padStart(figure_width(total))
+	const bar = is_plan_read(header) ? bar_of(settled, counts.total) : bar_of(0, 0)
 
 	return `${STATE_ICONS.merged} ${tally} ${bar}`
 }
@@ -202,47 +236,20 @@ function progress_parts(counts: BoardCounts, header: BoardHeader): Array<string>
 	const is_read = is_plan_read(header)
 
 	return [
-		`${tally_part(counts, is_read)}${is_read ? plus_of(counts, header) : ''}`,
+		`${tally_part(counts, header)}${is_read ? plus_of(counts, header) : ''}`,
 		`${STATE_ICONS.running} ${String(counts.running)}`,
 		`${STATE_ICONS.waiting} ${is_read ? String(counts.remaining) : UNKNOWN}`,
 		`${STATE_ICONS.parked} ${String(counts.parked)}`,
 	]
 }
 
-// The run's mark and its progress, then how fresh its stream is and what its plan read is doing.
-function state_line(counts: BoardCounts, header: BoardHeader): string {
-	const mark = mark_of(header, counts.running)
-	const parts = [
-		run_part(mark, header.spinner),
-		...progress_parts(counts, header),
-		heartbeat_part(header, mark),
-		loading_part(header),
-		plan_warning(header),
-	]
+// The run's progress, then what its plan read is doing.
+function progress_part(counts: BoardCounts, header: BoardHeader): string {
+	const parts = [...progress_parts(counts, header), loading_part(header), plan_warning(header)]
 
 	return parts.filter((part) => part !== undefined).join(GAP)
 }
 
-function idle_line(idle: IdleWindow, now_ms: number): string {
-	const ending = idle.bound === 'idle' ? WORDS.idle_end_idle : WORDS.idle_end_run
-	const left = `${elapsed_of(idle.until_ms - now_ms)} ${WORDS.idle_left}`
-	const until = `${WORDS.idle_until} ${clock_of(idle.until_ms)} (${left}) → ${ending}`
-	const next_check = `${WORDS.next_check} ${clock_of(backlog_idle.next_check_ms(idle))}`
-
-	return `${INDENT}${RUN_MARKS.idle.glyph} ${until} · ${next_check}`
-}
-
-// The wait, under the header's blank line, drawn only while it is what the run is doing: no child
-// running and the run not ended. The children running are the run's own, read
-// locally, so a board still waiting on GitHub never draws a running run as waiting.
-function idle_lines(header: BoardHeader): Array<string> {
-	const { idle, is_stopped } = header.activity
-
-	if (is_stopped || idle === undefined || counts_of(layout_of(header)).running > 0) return []
-
-	return ['', idle_line(idle, header.now_ms)]
-}
-
 // The gauges the machine line draws: every one on a screen, the memory alone in a chat.
 function machine_of(header: BoardHeader): MachineGauges | undefined {
 	const { machine } = header
@@ -257,19 +264,35 @@ const MACHINE_UNKNOWN = [HEADER_ICONS.cpu, HEADER_ICONS.memory, HEADER_ICONS.swa
 	.map((icon) => `${icon} ${UNKNOWN}`)
 	.join(GAP)
 
-// The time, then the machine the run is on.
-function clock_line(header: BoardHeader): string {
-	const machine = run_board_machine.line_of(machine_of(header)) ?? MACHINE_UNKNOWN
+// The machine the run is on, its first figure as wide as the tally over it.
+function machine_part(counts: BoardCounts, header: BoardHeader): string {
+	const width = figure_width(total_of(counts, header))
 
-	return [...time_parts(header), machine].join(GAP)
+	return run_board_machine.line_of(machine_of(header), width) ?? MACHINE_UNKNOWN
 }
 
-// The run's state with its progress, then the time with the machine, in every state the board can be in.
+// Both lines' cells of one column, the narrower padded to the wider as the terminal counts them.
+function column_of(cells: ReadonlyArray<string>): Array<string> {
+	const width = Math.max(...cells.map((cell) => run_board_fit.width_of(cell)))
+
+	return cells.map((cell) => cell_of(cell, width))
+}
+
+// The run's name, age and progress, then its repository, heartbeat and machine under them, in every
+// state the board can be in.
 function header_lines(header: BoardHeader): Array<string> {
-	return [state_line(counts_of(layout_of(header)), header), clock_line(header)]
+	const counts = counts_of(layout_of(header))
+	const mark = mark_of(header, counts.running)
+	const columns = [
+		column_of([run_part(mark, header.spinner), repo_part(header, mark)]),
+		column_of(time_parts(header, mark)),
+		[progress_part(counts, header), machine_part(counts, header)],
+	]
+
+	return [0, 1].map((line) => columns.map((column) => column[line]).join(GAP))
 }
 
-const run_board_header = { counts_of, header_lines, idle_lines, is_plan_read }
+const run_board_header = { counts_of, header_lines, is_plan_read }
 
 export { run_board_header }
 export type { BoardCounts, BoardForm, BoardHeader }

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

@@ -6,16 +6,16 @@ import type { BoardNote } from './run-board-notes'
 import type { Phase } from './run-board-phase'
 import type { ItemState } from './run-board-status'
 
-// The words and the clock `run:board` draws with. A moment on the board is a local `HH:MM:SS` clock;
-// how long something has run is a short `MM:SS`, so a person reads the board against the clock on
-// their own screen.
+// The words and the clock `run:board` draws with. A moment on the board is a local clock, `HH:MM`
+// where a person reads it to the minute; how long a row or the heartbeat has run is a short `MM:SS`,
+// and how long the run has run or its wait has left is `H:MM:SS` — two separators are a length and one
+// is a time of day, so the header's time column never reads a length as a moment.
 
 const CLOCK_WIDTH = 2
 const CLOCK_PAD = '0'
 const MS_PER_SECOND = 1000
 const SECONDS_PER_MINUTE = 60
 const MINUTES_PER_HOUR = 60
-const MS_PER_MINUTE = MS_PER_SECOND * SECONDS_PER_MINUTE
 // Every gauge is this wide — the plan, the machine and a row's phase.
 const BAR_WIDTH = 10
 // A centered square done and a thin line left: the shapes alone tell the two apart where no color is
@@ -58,11 +58,6 @@ const WORDS = {
 	followup: 'followup',
 	report: 'report',
 	failed: 'failed',
-	idle_until: 'wait ends',
-	idle_left: 'left',
-	idle_end_idle: 'ends and reports if nothing new',
-	idle_end_run: 'ends at the whole-run cut-off and reports',
-	next_check: 'next check',
 	notes: 'findings and decisions',
 	more: 'more',
 	filed: 'filed',
@@ -168,13 +163,16 @@ const KIND_WORDS: Readonly<Record<FiledKind, keyof Words>> = {
 }
 
 // The header's gauges and marks. ⚡ rather than 🔥: a fire beside a gauge drawn green reads as an
-// alarm.
+// alarm. ⏰ rather than ⏱, a text symbol some terminals draw one column wide: under it the 💓's digits
+// would stand a column off.
 const HEADER_ICONS = {
 	cpu: '⚡',
 	memory: '🧠',
 	swap: '💾',
 	ended: '🔚',
 	loading: '⏳',
+	elapsed: '⏰',
+	heartbeat: '💓',
 } as const
 
 // **The machine gauges' three colors, decided here alone**: Activity Monitor's green, yellow and red
@@ -207,8 +205,8 @@ function minute_of(ms: number): string {
 	return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(':')
 }
 
-// How long something has run, as `MM:SS` whose minutes never carry into hours (`61:05`), so the header
-// and every row read one short column; a negative span reads as zero.
+// How long a row's child has run, as `MM:SS` whose minutes never carry into hours (`61:05`), so every
+// row reads one short column; a negative span reads as zero.
 function elapsed_of(ms: number): string {
 	const seconds = Math.floor(Math.max(0, ms) / MS_PER_SECOND)
 	const minutes = Math.floor(seconds / SECONDS_PER_MINUTE)
@@ -216,12 +214,15 @@ function elapsed_of(ms: number): string {
 	return `${two_digits(minutes)}:${two_digits(seconds % SECONDS_PER_MINUTE)}`
 }
 
-// How long is left, as `7h38m`; a deadline already passed reads as zero.
-function left_of(ms: number): string {
-	const minutes = Math.floor(Math.max(0, ms) / MS_PER_MINUTE)
+// How long the run has run or its stream has been silent, as `H:MM:SS` with the hours not padded; a negative
+// span reads as zero. Always three fields, so a run under an hour (`0:03:25`) never reads as a time.
+function span_of(ms: number): string {
+	const seconds = Math.floor(Math.max(0, ms) / MS_PER_SECOND)
+	const minutes = Math.floor(seconds / SECONDS_PER_MINUTE)
 	const hours = Math.floor(minutes / MINUTES_PER_HOUR)
+	const tail = [minutes % MINUTES_PER_HOUR, seconds % SECONDS_PER_MINUTE]
 
-	return `${String(hours)}h${two_digits(minutes % MINUTES_PER_HOUR)}m`
+	return [String(hours), ...tail.map((value) => two_digits(value))].join(':')
 }
 
 function is_shade(color: Paint): color is Shade {
@@ -289,9 +290,9 @@ const run_board_labels = {
 	bar_of,
 	clock_of,
 	elapsed_of,
-	left_of,
 	minute_of,
 	painted,
+	span_of,
 	spinner_of,
 }
 

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

@@ -157,28 +157,40 @@ function alert_of(spec: GaugeSpec, value: number, pressure: number | undefined):
 	return verdict ?? threshold_alert(value, spec)
 }
 
+// One gauge's reading: its value, the width its figure is right-aligned to where that is wider than
+// the figure's own, and the kernel's pressure verdict where the gauge takes one.
+interface Reading {
+	value: number | undefined
+	width: number
+	pressure?: number | undefined
+}
+
 // Icon, figure, then bar: the figure is what a person reads, and its fixed
 // width keeps every bar starting in one column. The bar stops full past `spec.full`; the figure still
 // says how far past, and takes the warning colors only, so a quiet machine's figures stay the terminal's
 // own.
-function gauge(spec: GaugeSpec, value: number | undefined, pressure?: number): string | undefined {
+function gauge(spec: GaugeSpec, reading: Reading): string | undefined {
+	const { value, width } = reading
+
 	if (value === undefined) return undefined
 
-	const alert = alert_of(spec, value, pressure)
+	const alert = alert_of(spec, value, reading.pressure)
 	const warning = alert === 'normal' ? undefined : GAUGE_SHADES[alert]
 	const bar = bar_of(value, spec.full, undefined, warning ?? spec.normal)
 
-	return `${spec.icon} ${painted(warning, spec.format(value))} ${bar}`
+	return `${spec.icon} ${painted(warning, spec.format(value).padStart(width))} ${bar}`
 }
 
-// `undefined` when not one gauge could be read, so the header draws no line at all.
-function line_of(gauges: MachineGauges | undefined): string | undefined {
+// `undefined` when not one gauge could be read, so the header draws no line at all. `width` is the
+// header's figure column: a figure narrower than it is right-aligned to it, so the first gauge's bar
+// starts under the progress bar whichever gauge that is.
+function line_of(gauges: MachineGauges | undefined, width = 0): string | undefined {
 	if (gauges === undefined) return undefined
 
 	const parts = [
-		gauge(SPECS.cpu, gauges.cpu_percent),
-		gauge(SPECS.memory, gauges.memory_percent, gauges.memory_pressure),
-		gauge(SPECS.swap, gauges.swap_mb_per_s),
+		gauge(SPECS.cpu, { value: gauges.cpu_percent, width }),
+		gauge(SPECS.memory, { value: gauges.memory_percent, width, pressure: gauges.memory_pressure }),
+		gauge(SPECS.swap, { value: gauges.swap_mb_per_s, width }),
 	].filter((part) => part !== undefined)
 
 	return parts.length === 0 ? undefined : parts.join(GAP)
@@ -188,6 +200,7 @@ const run_board_machine = {
 	CPU_YELLOW,
 	GAP,
 	MEMORY_YELLOW,
+	PERCENT_WIDTH,
 	gauges_of,
 	line_of,
 	percent_text,

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

@@ -373,11 +373,7 @@ function bounded(parts: FrameParts, bounds: FrameBounds): Array<string> {
 
 function render(view: BoardView): Array<string> {
 	const { header, notes } = view
-	const above = [
-		...run_board_header.header_lines(header),
-		...resume_lines(view.resume),
-		...run_board_header.idle_lines(header),
-	]
+	const above = [...run_board_header.header_lines(header), ...resume_lines(view.resume)]
 	const parts = {
 		above,
 		plan: plan_sections(header, view.size),

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

@@ -28,7 +28,6 @@ function ended_span(ended: EndedRun | undefined): BoardSpan | undefined {
 }
 
 // The running run wins over the ended one, so a run that begins replaces the finished board at once.
-// An expired carry is still the running run's budget spent, not a run that ended, so it draws nothing.
 function span_of(read: CarryRead, ended: EndedRun | undefined): BoardSpan | undefined {
 	if (read.kind !== 'carried') return read.kind === 'none' ? ended_span(ended) : undefined
 

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

@@ -1,4 +1,3 @@
-import { backlog_idle, type IdleWindow } from '#scripts/backlog/backlog-idle'
 import {
 	has_label_name,
 	IN_PROGRESS_LABEL,
@@ -30,8 +29,6 @@ interface ItemStatus {
 // The run as a whole, read off the same stream.
 interface RunActivity {
 	last_event_ms: number | undefined
-	// The idle watch's window, when the newest one opened after the newest launch.
-	idle: IdleWindow | undefined
 	// The run's last position is a `stop` that names no child — the run itself ended.
 	is_stopped: boolean
 }
@@ -243,19 +240,6 @@ function settle_closed(
 	return new Map([...statuses].map(([issue, status]) => [issue, settled(issue, status, read)]))
 }
 
-function newest_of(events: ReadonlyArray<RunEvent>, kind: string): RunEvent | undefined {
-	return events.findLast((event) => event.kind === kind)
-}
-
-function idle_of(events: ReadonlyArray<RunEvent>): IdleWindow | undefined {
-	const idle = newest_of(events, KIND.IDLE)
-	const launch = newest_of(events, KIND.CHILD_LAUNCH)
-
-	if (idle === undefined || (launch !== undefined && launch.pos > idle.pos)) return undefined
-
-	return backlog_idle.parse(idle.text)
-}
-
 function is_run_stop(event: RunEvent | undefined): boolean {
 	return event?.kind === KIND.STOP && run_event_scope.issue_named(event) === undefined
 }
@@ -268,7 +252,6 @@ function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActi
 
 	return {
 		last_event_ms: last === undefined ? undefined : moment(last),
-		idle: idle_of(events),
 		is_stopped: is_ended || is_run_stop(position),
 	}
 }

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

@@ -135,6 +135,7 @@ function header_of(
 		machine: state.gauges,
 		usages: state.usages,
 		form: redraw.ports.form,
+		repo: state.plan?.context.repo,
 		spinner: redraw.ports.is_tty ? SPOT : undefined,
 		link: run_board_link.linker(state.plan?.context.repo, redraw.ports.link),
 	}