@joshuafolkken/kit 1.1784.0 → 1.2114.0

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

@@ -1,5 +1,6 @@
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { run_event_filed, type FiledKind } from '#scripts/run/event/run-event-filed'
+import { run_event_overrun } from '#scripts/run/event/run-event-overrun'
 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_board_ending_reason } from './run-board-ending-reason'
@@ -84,11 +85,16 @@ function plain_note(event: RunEvent): BoardNote {
 	return { kind: 'note', at_ms: Date.parse(event.at), issue, text }
 }
 
+// An overrun note is no finding (joshuafolkken/kit#4818): the merged row says it after its time.
+function is_finding(event: RunEvent): boolean {
+	return event.kind === KIND.NOTE && run_event_overrun.parse(event.text) === undefined
+}
+
 function note_of(event: RunEvent, titles: Titles): BoardNote | undefined {
 	if (event.kind === KIND.FILED) return filed_note(event)
 	if (event.kind === KIND.PARK) return park_note(event, titles)
 
-	return event.kind === KIND.NOTE ? plain_note(event) : undefined
+	return is_finding(event) ? plain_note(event) : undefined
 }
 
 // A park is said only of a child the board still holds parked, so one a person released or closed

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

@@ -1,4 +1,5 @@
 import path from 'node:path'
+import { token_shape } from '#scripts/lib/token-shape'
 import { transcript_record, type TranscriptRecord } from '#scripts/lib/transcript-record'
 import { z } from 'zod'
 
@@ -60,12 +61,13 @@ function without_assignments(command: string): string {
 }
 
 // The first line of what the command runs, cut to the limit. A command whose variable cannot be read
-// to its end is drawn as nothing: a part of the value would stand where the command should.
+// to its end is drawn as nothing: a part of the value would stand where the command should. A
+// credential later in the line is redacted before the cut, which would leave a head no shape matches.
 function command_target(command: string): string {
 	const [first = ''] = without_assignments(command.trim()).split(NEWLINE)
 	if (UNREAD_ASSIGNMENT.test(first)) return ''
 
-	return cut(ascii_head(first.replaceAll(SPACES, ' ')))
+	return cut(ascii_head(token_shape.redact(first).replaceAll(SPACES, ' ')))
 }
 
 // The path from `root` down; a file outside it is drawn by its name alone, never by where it is.

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

@@ -35,9 +35,6 @@ const KIND = run_event_stream.EVENT_KIND
 const { STAGE } = run_ship_stage
 // A launched child is investigating until a later record says otherwise — no event marks the start.
 const LAUNCHED_PHASE: Phase = 'investigate'
-const WORD_SEPARATOR = ' '
-const STAGE_INDEX = 1
-const PHASE_INDEX = 2
 
 // `josh ship`'s stages, each its own phase; the preflight is the ship's own start.
 const SHIP_PHASES: Readonly<Partial<Record<string, Phase>>> = {
@@ -62,12 +59,12 @@ const KIND_PHASES: Readonly<Partial<Record<string, Phase>>> = {
 
 // The word after the issue — `#<N> <stage> <phase>` carries the stage second.
 function stage_word_of(event: RunEvent): string {
-	return event.text.split(WORD_SEPARATOR)[STAGE_INDEX] ?? ''
+	return run_ship_stage.words_of(event.text).stage
 }
 
 // The word after the stage — whether it started, succeeded, failed or was passed over.
 function phase_word_of(event: RunEvent): string {
-	return event.text.split(WORD_SEPARATOR)[PHASE_INDEX] ?? ''
+	return run_ship_stage.words_of(event.text).phase
 }
 
 // A stage marks its phase when it starts; its `done`, and one a resumed ship passed over, mark none.

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

@@ -1,5 +1,5 @@
 import { auto_ok_cli, type OptedInRead } from '#scripts/auto-ok/auto-ok-cli'
-import type { OptedIn } from '#scripts/backlog/backlog-next'
+import type { OptedIn } from '#scripts/backlog/backlog-gate-scope'
 import { backlog_plan, type NamedPlan } from '#scripts/backlog/backlog-plan'
 import { backlog_plan_read, type OpenListing, type Plan } from '#scripts/backlog/backlog-plan-read'
 import { backlog_waves } from '#scripts/backlog/backlog-waves'

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

@@ -10,9 +10,12 @@ import { lane_state } 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_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_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_state, type BoardLanes } from './run-board-lane-state'
 import {
 	run_board_operation_read,
@@ -61,6 +64,9 @@ interface LocalRead {
 	occupied_count?: number | 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
 	// 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
@@ -72,6 +78,9 @@ interface LocalRead {
 	closing?: ReadonlySet<string> | undefined
 	// The run's record, whose declared order holds a queued row (`backlog-drive-named.ts`).
 	carry?: RunCarry | undefined
+	// What each done row says after its time, its sessions probed once a read against `table`
+	// (`run-board-found.ts`), never per redraw.
+	found?: FoundOf | undefined
 }
 
 const NO_SPAN: SpanHere = {
@@ -215,6 +224,42 @@ function ledger_here(repository: string): Pick<LocalRead, 'usual' | 'is_memory_h
 	}
 }
 
+// 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.
+function usage_reset_here(
+	events: ReadonlyArray<RunEvent>,
+	carry: RunCarry | undefined,
+): number | undefined {
+	if (carry === undefined) return undefined
+	const scope = run_event_scope.scope_of({ kind: 'carried', carry })
+
+	return run_merge_usage_limit.held_until(
+		run_event_scope.scoped_events(events, scope) ?? [],
+		Date.now(),
+	)
+}
+
+// The run's own events, what its done rows say after their time with each open investigation's
+// session asked of `table`, and the usage limit its record's invocation is held by.
+async function span_events_here(
+	events: ReadonlyArray<RunEvent>,
+	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)
+	// 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 })
+
+	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),
+	}
+}
+
 // `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> {
@@ -232,7 +277,7 @@ async function read_local(table?: TableRead): Promise<LocalRead | undefined> {
 		started_ms: span.started_ms,
 		ended_ms: span.ended_ms,
 		scope: run_board_scope.scope_of(span.invocation),
-		events: run_board_span.events_of(events, span),
+		...(await span_events_here(events, span, table, carry)),
 		lanes: lanes.map((lane) => lane.issue),
 		lane_states,
 		resume,

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

@@ -51,6 +51,8 @@ interface ReasonRead extends Overlay {
 	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.
@@ -59,6 +61,8 @@ interface ReasonRead extends Overlay {
 	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.
@@ -109,7 +113,7 @@ function running_of(read: ReasonRead): Array<number> {
 function is_candidate(child: EpicChild, read: ReasonRead): boolean {
 	return (
 		epic_triage.is_triaged(child) &&
-		issue_not_before.is_due(child.body) &&
+		issue_not_before.is_due(child.body, read.now_ms) &&
 		!run_board_layout.is_blocked(child, read)
 	)
 }
@@ -190,9 +194,16 @@ function no_memory_of(gauges: MachineGauges | undefined): RowReason {
 	}
 }
 
-// The machine's room: no lane left under the limit, else no memory for one more.
+// `🪫 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.is_memory_held === true ? no_memory_of(read.gauges) : undefined
 }
@@ -247,7 +258,7 @@ 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
-// left, then a machine with no memory.
+// 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) ??
@@ -259,20 +270,21 @@ function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): RowReason |
 }
 
 // `📅 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.
+// 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.pr)] }
+	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): RowReason | undefined {
-	const ms = issue_not_before.waiting_ms(child.body)
+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)
 
@@ -303,7 +315,7 @@ function wait_of(
 	if (!epic_triage.is_triaged(child)) return untriaged_of(waits)
 	if (waits.length > 0) return { icon: blocker_icon(child, pool), issues: waits }
 
-	return not_before_of(child) ?? offer_wait(child, read, 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.

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

@@ -42,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'),

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

@@ -2,6 +2,7 @@ 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'
@@ -24,6 +25,14 @@ function has_lanes(header: BoardHeader): boolean {
 	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> {
@@ -59,6 +68,8 @@ function drawn_of(
 		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)),
 	}
 }
 

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

@@ -0,0 +1,157 @@
+import { run_event_overrun, type OverrunNote } from '#scripts/run/event/run-event-overrun'
+import type { Found } from './run-board-found'
+import type { BoardHeader } from './run-board-header'
+import { run_board_labels } from './run-board-labels'
+import type { BoardRow } from './run-board-layout'
+import { run_board_render_title } from './run-board-render-title'
+import type { ItemState } from './run-board-status'
+
+// A done row's end after its time (joshuafolkken/kit#4772, joshuafolkken/kit#4818). A merged row says
+// its lane's net minutes — `?′` where there are none — the numbers of the Issues its child filed, then
+// what its overrun investigation came to and the numbers it filed (joshuafolkken/kit#4880), each group
+// two spaces apart: `⏭` and why it was skipped, or 🔍, the lane's longest stage and the numbers it filed
+// (`🔍 implement 51′ · 4983`), `↪N` for each open
+// Issue it appended causes to (joshuafolkken/kit#4858), `∅` and why it did not, `∅ ↻N` for a
+// recurrence commented on, or 💥 for an investigation that failed. While the investigation runs, the spinner stands for 🔍.
+// A row its merge left no note on was never asked. A done row that did not merge, and a merged row
+// 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 SEPARATOR = ', '
+const GROUP_SEPARATOR = '  '
+const LONGEST_SEPARATOR = ' · '
+const MINUTES_WIDTH = 3
+const MINUTE_MARK = '′'
+const UNKNOWN_MINUTES = '?'
+const SKIP_MARK = '⏭'
+const NONE_MARK = '∅'
+const RECURRED_MARK = '↻'
+const FOLDED_MARK = '↪'
+const FAILED_TEXT = `${OVERRUN_MARK} 💥`
+const NO_RECORD = 'no record'
+// The investigator writes its reason in about 15 characters; the row keeps no more.
+const REASON_LIMIT = 16
+
+function found_of(row: BoardRow, header: BoardHeader): Found | undefined {
+	if (!DONE_STATES.has(row.state)) return undefined
+
+	return header.found?.get(row.number)
+}
+
+function links_of(references: ReadonlyArray<string>, header: BoardHeader): string {
+	return references.map((reference) => header.link(reference)).join(SEPARATOR)
+}
+
+// Every filing, the child's and the investigation's alike: a row that did not merge has no outcome
+// to tell them apart by.
+function numbers_of(found: Found | undefined, header: BoardHeader): string {
+	return links_of([...(found?.filed ?? []), ...(found?.overrun_filed ?? [])], header)
+}
+
+function minutes_text(found: Found | undefined): string {
+	const minutes = found?.minutes === undefined ? UNKNOWN_MINUTES : String(found.minutes)
+
+	return `${minutes.padStart(MINUTES_WIDTH)}${MINUTE_MARK}`
+}
+
+// An investigation that filed nothing: the recurrence it commented on, a link with no `#` and its mark
+// outside it (joshuafolkken/kit#4956), else why it did not.
+function none_text(result: string, header: BoardHeader): string {
+	const recurred = run_event_overrun.recurred_of(result)
+
+	if (recurred !== undefined) return `${NONE_MARK} ${RECURRED_MARK}${header.link(String(recurred))}`
+
+	const why = run_board_render_title.title_of(run_event_overrun.reason_of(result), REASON_LIMIT)
+
+	return `${NONE_MARK} ${why}`
+}
+
+// The open Issues the investigation appended its causes to, each a link with no `#`.
+function folded_text(issues: ReadonlyArray<number>, header: BoardHeader): string {
+	const links = issues.map((issue) => `${FOLDED_MARK}${header.link(String(issue))}`)
+
+	return `${OVERRUN_MARK} ${links.join(SEPARATOR)}`
+}
+
+// The result decides, not whether anything was filed: an event written before the overrun mark reads
+// as the child's.
+function ended_text(result: string, header: BoardHeader): string {
+	const folded = run_event_overrun.folded_of(result)
+
+	if (folded.length > 0) return folded_text(folded, header)
+	if (result.startsWith(run_event_overrun.FILED_RESULT)) return OVERRUN_MARK
+
+	return `${OVERRUN_MARK} ${none_text(result, header)}`
+}
+
+// A started session still running turns the spinner, one gone without its end note failed, and one
+// whose start token was never read stands still while its pid lives.
+function started_text(found: Found, header: BoardHeader): string {
+	if (found.is_investigating === false) return FAILED_TEXT
+	if (found.is_investigating === undefined) return OVERRUN_MARK
+
+	return header.spinner ?? OVERRUN_MARK
+}
+
+// A lane at or under the threshold says nothing past its minutes.
+function outcome_text(found: Found, note: OverrunNote, header: BoardHeader): string {
+	if (note.kind === 'within') return ''
+	if (note.kind === 'skipped') return `${SKIP_MARK} ${note.reason}`
+	if (note.kind === 'ended') return ended_text(note.result, header)
+
+	return note.kind === 'started' ? started_text(found, header) : FAILED_TEXT
+}
+
+function joined(parts: ReadonlyArray<string>, separator: string): string {
+	return parts.filter((part) => part !== '').join(separator)
+}
+
+// The lane's longest stage its start note carried (joshuafolkken/kit#4995), else nothing.
+function longest_text(found: Found | undefined): string {
+	const longest = found?.longest
+
+	return longest === undefined ? '' : `${longest.name} ${String(longest.minutes)}${MINUTE_MARK}`
+}
+
+// What the investigation came to, its lane's longest stage, then the Issues it filed.
+function investigation_text(found: Found | undefined, header: BoardHeader): string {
+	const outcome =
+		found?.overrun === undefined
+			? `${SKIP_MARK} ${NO_RECORD}`
+			: outcome_text(found, found.overrun, header)
+
+	const filed = links_of(found?.overrun_filed ?? [], header)
+
+	return joined([outcome, joined([longest_text(found), filed], LONGEST_SEPARATOR)], ' ')
+}
+
+// The minutes, the child's own filings, then the investigation, each group apart by two spaces. While
+// the investigation switch is off, every merged row says only what was filed, whatever its note
+// (joshuafolkken/kit#5132, joshuafolkken/kit#5194).
+function merged_text(row: BoardRow, header: BoardHeader): string {
+	const found = found_of(row, header)
+
+	if (!header.is_investigation_on) return numbers_of(found, header)
+
+	const own = links_of(found?.filed ?? [], header)
+
+	return joined([minutes_text(found), own, investigation_text(found, header)], GROUP_SEPARATOR)
+}
+
+// Empty for an unmerged done row with nothing filed, for every row not done, and on a board that read
+// no stream.
+function found_text(row: BoardRow, header: BoardHeader): string {
+	if (row.state === 'merged' && header.found !== undefined) return merged_text(row, header)
+
+	return numbers_of(found_of(row, header), header)
+}
+
+// The row draws 🔍, which the legend names.
+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 }
+
+export { run_board_render_found }

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

@@ -1,6 +1,7 @@
 import { run_board_earlier } from './run-board-earlier'
 import { run_board_fresh } from './run-board-fresh'
 import type { BoardHeader } from './run-board-header'
+import { run_board_labels } from './run-board-labels'
 import type { BoardRow } from './run-board-layout'
 import { run_board_render_icon } from './run-board-render-icon'
 import { run_board_render_tail } from './run-board-render-tail'
@@ -16,6 +17,7 @@ const { BUDGET_ICON, held_of, held_time } = run_board_render_waits
 const { phase_time } = run_board_render_tail
 const { state_icon } = run_board_render_icon
 const { time_of } = run_board_render_time
+const { WAIT_ICONS } = run_board_labels
 // The widest span a time column draws: `1°14′58″`.
 const TIME_WIDTH = 8
 const LANE_INDENT = '  '
@@ -60,6 +62,12 @@ function whole_of(row: BoardRow, header: BoardHeader): string {
 	return run_board_fresh.padded(time, TIME_WIDTH, fresh)
 }
 
+// A lane row's indent: 🧍 on a `run:solo` row (joshuafolkken/kit#4625), as wide as the blanks it
+// replaces, so every column after it stays put.
+function indent_of(row: BoardRow): string {
+	return row.is_solo === true ? WAIT_ICONS.solo : LANE_INDENT
+}
+
 // A lane row's lead after its indent, ending where its usage cells start less one blank.
 function lead_of(row: BoardRow, header: BoardHeader): string {
 	const icon = running_fresh(row, state_icon(row), row.status?.phase_ms, header)
@@ -73,6 +81,7 @@ const run_board_render_lead = {
 	LANE_INDENT,
 	TIME_WIDTH,
 	USAGE_START,
+	indent_of,
 	lead_of,
 	running_fresh,
 }

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

@@ -20,10 +20,12 @@ const {
 	FILED_KIND_ICONS,
 	FILED_RUN_MARK,
 	KIND_WORDS,
+	OVERRUN_MARK,
 	PHASE_ICONS,
 	PHASE_WORDS,
 	STATE_ICONS,
 	WAITS_ICON,
+	WAIT_ICONS,
 	WAIT_WORDS,
 	WORDS,
 } = run_board_labels
@@ -43,6 +45,11 @@ interface LegendDrawn {
 	checks: ReadonlyArray<string>
 	// 🚧 and the reasons a held check is drawn with (joshuafolkken/kit#4052).
 	held: ReadonlyArray<string>
+	// A lane row leads with 🧍, its `run:solo` mark (joshuafolkken/kit#4625).
+	solo: boolean
+	// A merged row ends on 🔍, its overrun investigation running where no spinner turns
+	// (joshuafolkken/kit#4772) or its result once it ended (joshuafolkken/kit#4818).
+	overrun?: boolean | undefined
 }
 
 type LeadWords = ReadonlyArray<readonly [string, keyof Words]>
@@ -100,6 +107,16 @@ function waits_legend(rows: ReadonlyArray<BoardRow>): Array<string> {
 	)
 }
 
+// 🧍 is named only while a lane row draws it, and once where a waiting row leads with it too
+// (joshuafolkken/kit#4625).
+function solo_legend(rows: ReadonlyArray<BoardRow>, drawn: LegendDrawn): Array<string> {
+	if (!drawn.solo) return []
+
+	const is_named = rows.some((row) => wait_icon(row) === WAIT_ICONS.solo)
+
+	return is_named ? [] : [`${WAIT_ICONS.solo} ${WORDS.solo}`]
+}
+
 // ✚ is named only while a row the run filed draws it (joshuafolkken/kit#4099).
 function filed_legend(
 	rows: ReadonlyArray<BoardRow>,
@@ -135,7 +152,9 @@ function others_line(
 	return [
 		...kind_named,
 		...waits_legend(rows),
+		...solo_legend(rows, drawn),
 		...filed_legend(rows, notes),
+		...(drawn.overrun === true ? [`${OVERRUN_MARK} ${WORDS.overrun}`] : []),
 		...drawn.held,
 		...drawn.checks,
 		...run_board_render_notes.notes_legend(notes, named, rows),

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

@@ -173,7 +173,7 @@ function tail_of(row: BoardRow, header: BoardHeader): Array<string> {
 
 	const checks = checks_of(row, header)
 
-	if (checks !== undefined) return [run_board_render_checks.checks_part(checks)]
+	if (checks !== undefined) return [run_board_render_checks.checks_part(checks, header.pull_link)]
 
 	return [activity_part(row, header)]
 }