@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -1,7 +1,10 @@
-import { NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
+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'
+import { run_board_layout } from './run-board-layout'
 
 // The board's findings section: what a run filed, what it parked and the
 // one-line observations it left, read off the event stream alone. A run started from the command line
@@ -20,20 +23,16 @@ interface BoardNote {
 	found_during?: string | undefined
 	// A filed Issue's classification, which its line leads with.
 	filed_kind?: FiledKind | undefined
-	// A park waiting on a person's decision, drawn apart from an ordinary park.
-	is_decision: boolean
 }
 
 const KIND = run_event_stream.EVENT_KIND
-// `#<N> parked`, `#<N> parked (<reason>)` and `#<N> waiting on #<M>` lose their leading number, so a
-// waiting park does not name its issue twice.
-const PARK_PREFIX = /^#\d+ (?:parked\s*)?/u
-const PARENTHESES = /^\((?<inner>.*)\)$/u
 
+// Only the run's own filings (joshuafolkken/kit#4099): a session outside the run writes to the same
+// stream, and what it filed is drawn as any other plan row.
 function filed_note(event: RunEvent): BoardNote | undefined {
 	const filed = run_event_filed.parse(event.text)
 
-	if (filed === undefined) return undefined
+	if (filed?.is_run !== true) return undefined
 
 	return {
 		kind: 'filed',
@@ -42,20 +41,12 @@ function filed_note(event: RunEvent): BoardNote | undefined {
 		text: filed.title,
 		found_during: filed.found_during,
 		filed_kind: filed.kind,
-		is_decision: false,
 	}
 }
 
 // The board's titles by issue number: the plan's listing with its closed children's.
 type Titles = ReadonlyMap<number, string>
 
-// `#<N> parked (needs-decision)` reads as the reason `needs-decision`; a bare park has none.
-function reason_of(event: RunEvent): string {
-	const rest = event.text.replace(PARK_PREFIX, '')
-
-	return PARENTHESES.exec(rest)?.groups?.['inner'] ?? rest
-}
-
 // The parked issue's title with its reason after it; before the plan is read there is no title, and
 // the reason alone is drawn.
 function park_text(title: string | undefined, reason: string): string {
@@ -64,40 +55,76 @@ function park_text(title: string | undefined, reason: string): string {
 	return reason === '' ? title : `${title} (${reason})`
 }
 
-function park_note(event: RunEvent, titles: Titles): BoardNote {
-	const reason = reason_of(event)
+// A park waiting on a person's decision is no finding (joshuafolkken/kit#4099): while the child stays
+// parked its row is in the 🙋 decision section, and once it resumes the decision is made.
+function park_note(event: RunEvent, titles: Titles): BoardNote | undefined {
+	const reason = run_board_ending_reason.park_reason(event)
+
+	if (run_board_layout.is_decision(reason)) return undefined
+
 	const issue = run_event_scope.issue_named(event)
 	const title = issue === undefined ? undefined : titles.get(Number(issue))
-	const is_decision = reason.includes(NEEDS_DECISION_LABEL)
 
-	return {
-		kind: 'park',
-		at_ms: Date.parse(event.at),
-		issue,
-		text: park_text(title, reason),
-		is_decision,
-	}
+	return { kind: 'park', at_ms: Date.parse(event.at), issue, text: park_text(title, reason) }
+}
+
+// The line already leads with the number a note names, so a text that opens with it does not say it
+// again (joshuafolkken/kit#4097).
+function note_body(text: string, issue: string | undefined): string {
+	if (issue === undefined) return text
+
+	const lead = `${issue_cite.plain(issue)} `
+
+	return text.startsWith(lead) ? text.slice(lead.length) : text
 }
 
 function plain_note(event: RunEvent): BoardNote {
 	const issue = run_event_scope.issue_named(event)
+	const text = note_body(event.text, issue)
 
-	return { kind: 'note', at_ms: Date.parse(event.at), issue, text: event.text, is_decision: false }
+	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
 }
 
-// Newest first: the line a person glancing at the board needs is the latest one.
-function notes_of(events: ReadonlyArray<RunEvent>, titles: Titles): ReadonlyArray<BoardNote> {
-	return events.flatMap((event) => note_of(event, titles) ?? []).toReversed()
+// A park is said only of a child the board still holds parked, so one a person released or closed
+// is not (joshuafolkken/kit#4127).
+function is_listed(note: BoardNote, listed: ReadonlySet<number> | undefined): boolean {
+	return listed === undefined || note.kind !== 'park' || listed.has(Number(note.issue))
+}
+
+// Newest first: the line a person glancing at the board needs is the latest one. `listed` holds the
+// parked children whose park the section says (`run_board_layout.listed_parks`); without it, every
+// park is said.
+function notes_of(
+	events: ReadonlyArray<RunEvent>,
+	titles: Titles,
+	listed?: ReadonlySet<number>,
+): ReadonlyArray<BoardNote> {
+	return events
+		.flatMap((event) => note_of(event, titles) ?? [])
+		.filter((note) => is_listed(note, listed))
+		.toReversed()
+}
+
+// The issues the run filed in this repository — the rows that lead their title with ✚.
+function filed_numbers(notes: ReadonlyArray<BoardNote>): ReadonlySet<number> {
+	const filed = notes.filter((note) => note.kind === 'filed').map((note) => Number(note.issue))
+
+	return new Set(filed.filter((number) => Number.isSafeInteger(number)))
 }
 
-const run_board_notes = { notes_of }
+const run_board_notes = { filed_numbers, notes_of }
 
 export { run_board_notes }
 export type { BoardNote, Titles }

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

@@ -43,7 +43,7 @@ interface NowRead {
 }
 
 interface NowLine {
-	// The kind's icon, drawn under the `⚡`.
+	// The kind's icon, drawn under the `💪`.
 	icon: string
 	// The icon's word in the legend, `undefined` where the line's own words or the phase legend name it.
 	legend?: string | undefined

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

@@ -1,5 +1,6 @@
 import path from 'node:path'
-import { json_value } from '#scripts/lib/json-value'
+import { token_shape } from '#scripts/lib/token-shape'
+import { transcript_record, type TranscriptRecord } from '#scripts/lib/transcript-record'
 import { z } from 'zod'
 
 // The newest thing a session did, read off the end of its log — a lane child's dispatch log, the
@@ -37,28 +38,11 @@ const SPACES = /\s+/gu
 // The printable ASCII a target begins with: what follows may be the session's own language.
 const ASCII_HEAD = /^[ -~]*/u
 
-// A call names its tool; every other block of a line — its text, its thinking — is not one.
-const CALL_SCHEMA = z.looseObject({
-	type: z.literal(TOOL_USE),
-	name: z.string(),
-	input: z.unknown(),
-})
-
-function is_dated(text: string): boolean {
-	return !Number.isNaN(Date.parse(text))
-}
-
-const MESSAGE_SCHEMA = z.looseObject({ content: z.array(z.unknown()) })
-const LINE_SCHEMA = z.looseObject({
-	timestamp: z.string().refine(is_dated),
-	message: MESSAGE_SCHEMA,
-})
 // An input that is no object reads as one pointed at nothing.
 const INPUT_SCHEMA = z
 	.looseObject({ command: z.string().optional(), file_path: z.string().optional() })
 	.catch({})
 
-type Call = z.infer<typeof CALL_SCHEMA>
 type Input = z.infer<typeof INPUT_SCHEMA>
 
 function ascii_head(text: string): string {
@@ -77,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.
@@ -103,26 +88,25 @@ function target_of(input: Input, root: string | undefined): string | undefined {
 	return input.file_path === undefined ? undefined : shown(path_target(input.file_path, root))
 }
 
-function is_call(block: unknown): block is Call {
-	return CALL_SCHEMA.safeParse(block).success
-}
+// The last call a line holds, `undefined` for an undated line or one holding none. A call names its
+// tool; every other block of a line — its text, its thinking — is not one.
+function record_operation(
+	record: TranscriptRecord,
+	root: string | undefined,
+): Operation | undefined {
+	const call = transcript_record.tool_calls_of(record).at(-1)
+	const at_ms = Date.parse(record.timestamp ?? '')
 
-function last_call(content: ReadonlyArray<unknown>): Call | undefined {
-	return content.findLast((block) => is_call(block))
+	if (call === undefined || Number.isNaN(at_ms)) return undefined
+
+	return { kind: call.name, target: target_of(INPUT_SCHEMA.parse(call.input), root), at_ms }
 }
 
-// The last call a line holds, `undefined` for a line that is cut, is not JSON, or holds none.
+// The same, `undefined` too for a line that is cut or is not JSON.
 function line_operation(line: string, root: string | undefined): Operation | undefined {
-	const parsed = json_value.parse_with(line, LINE_SCHEMA)
-	const call = last_call(parsed?.message.content ?? [])
-
-	if (parsed === undefined || call === undefined) return undefined
+	const record = transcript_record.parse(line)
 
-	return {
-		kind: call.name,
-		target: target_of(INPUT_SCHEMA.parse(call.input), root),
-		at_ms: Date.parse(parsed.timestamp),
-	}
+	return record === undefined ? undefined : record_operation(record, root)
 }
 
 // The newest operation in `tail` — the end of a log, whose first line is usually cut mid-way and so

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

@@ -19,9 +19,9 @@ const PHASES = [
 	'plan',
 	'implement',
 	'ship',
+	'sync',
 	'review',
 	'gate',
-	'sync',
 	'commit',
 	'round_two',
 	'followup',
@@ -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-shared.ts

@@ -0,0 +1,115 @@
+import { backlog_next_shared } from '#scripts/backlog/backlog-next-shared'
+import type { NamedPlan } from '#scripts/backlog/backlog-plan'
+import { shared_cache, type CacheSlot } from '#scripts/josh/shared-cache'
+import { z } from 'zod'
+import type { BoardPlan } from './run-board-layout'
+import { run_board_plan } from './run-board-plan'
+
+// `run:board`'s plan read, shared the way the drive's assignment and the arrival probe share
+// `josh backlog:next` (joshuafolkken/kit#4558): one read within a minute, keyed by the scope it was
+// asked for and the newest event on the run's stream, so a launch, a merge or a park reads again.
+// Only a plan that read is kept; a failed read is asked again by the next redraw.
+//
+// The plan holds maps and sets, which JSON does not, so each is kept as its entries and rebuilt on read.
+
+const PLAN_CACHE: CacheSlot = {
+	prefix: 'josh-run-board-plan-',
+	ttl_ms: backlog_next_shared.NEXT_CACHE.ttl_ms,
+}
+
+type EntriesCodec<T, I> = z.ZodCodec<
+	z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodType<T, I>], null>>,
+	z.ZodReadonly<z.ZodMap<z.ZodNumber, z.ZodCustom<T, T>>>
+>
+
+// The value is checked once, on the entries side: a value that is itself a codec would otherwise be
+// encoded twice, by the map and again by its entries.
+function map_of<T, I>(value: z.ZodType<T, I>): EntriesCodec<T, I> {
+	const entries = z.array(z.tuple([z.number(), value]))
+	const map = z.map(z.number(), z.custom<T>()).readonly()
+
+	return z.codec(entries, map, {
+		decode: (pairs) => new Map(pairs),
+		encode: (pairs) => [...pairs],
+	})
+}
+
+const number_set = z.codec(z.array(z.number()), z.set(z.number()).readonly(), {
+	decode: (numbers) => new Set(numbers),
+	encode: (numbers) => [...numbers],
+})
+
+// A listing cut short knows no open issues (`PlanContext.open_numbers`); JSON drops an `undefined`
+// key, so the set is kept inside an object that is always written.
+const optional_numbers = z.array(z.number()).optional()
+const unknown_or_set = z.codec(
+	z.object({ numbers: optional_numbers }),
+	z.custom<ReadonlySet<number> | undefined>(),
+	{
+		decode: ({ numbers }) => (numbers === undefined ? undefined : new Set(numbers)),
+		encode: (numbers) => (numbers === undefined ? {} : { numbers: [...numbers] }),
+	},
+)
+
+const string_set = z.codec(z.array(z.string()), z.set(z.string()).readonly(), {
+	decode: (values) => new Set(values),
+	encode: (values) => [...values],
+})
+
+const names = z.array(z.string()).readonly()
+const reference_schema = z.object({ repo: z.string(), number: z.number() })
+
+const child_schema = z.object({
+	number: z.number(),
+	repo: z.string(),
+	state: z.enum(['OPEN', 'CLOSED']),
+	labels: names,
+	blocked_by: z.array(reference_schema).readonly(),
+	body: z.string().optional(),
+})
+
+const children = z.array(child_schema).readonly()
+
+const waves_schema = z.object({
+	waves: z.array(children).readonly(),
+	unreached: children,
+	running: children.exactOptional(),
+})
+
+const context_schema = z.object({
+	repo: z.string(),
+	titles: map_of(z.string()),
+	open_numbers: unknown_or_set,
+})
+
+const board_plan_schema = z.object({
+	waves: waves_schema,
+	tracked: map_of(z.number()),
+	context: context_schema,
+	labels: map_of(names),
+	declared: map_of(string_set).optional(),
+	withheld: number_set.optional(),
+})
+
+async function read(
+	named: NamedPlan,
+	read_plan = run_board_plan.read_plan,
+): Promise<BoardPlan | undefined> {
+	const key = await backlog_next_shared.stream_key({ board: named })
+	const now_ms = Date.now()
+	const kept = shared_cache.read(PLAN_CACHE, key, board_plan_schema, now_ms)
+
+	if (kept !== undefined) return kept
+
+	const plan = await read_plan(named)
+
+	if (plan !== undefined) {
+		shared_cache.write(PLAN_CACHE, key, board_plan_schema.encode(plan), now_ms)
+	}
+
+	return plan
+}
+
+const run_board_plan_shared = { PLAN_CACHE, read }
+
+export { run_board_plan_shared }

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

@@ -1,8 +1,9 @@
 import { auto_ok_cli, type OptedInRead } from '#scripts/auto-ok/auto-ok-cli'
-import type { OptedIn } from '#scripts/backlog/backlog-next'
-import type { NamedPlan } from '#scripts/backlog/backlog-plan'
+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'
+import { epic_classify } from '#scripts/epic/epic-classify'
 import type { EpicChild } from '#scripts/epic/epic-graph'
 import type { OpenIssueData } from '#scripts/git/git-schemas'
 import { run_board_layout, type BoardPlan } from './run-board-layout'
@@ -21,10 +22,20 @@ interface PlanPorts {
 	classify: (opted_in: OptedIn, exclude: ReadonlyArray<number>) => Promise<Plan | undefined>
 }
 
+// The board leads a row withheld for a person with 🙋, so classifying says no ❗ notice over it.
+async function classify_quietly(
+	opted_in: OptedIn,
+	exclude: ReadonlyArray<number>,
+): Promise<Plan | undefined> {
+	epic_classify.mute_notices()
+
+	return await backlog_plan_read.classify(opted_in, exclude)
+}
+
 const LIVE_PORTS: PlanPorts = {
 	fetch_open: backlog_plan_read.fetch_open,
 	fetch_opted_in: auto_ok_cli.fetch_opted_in,
-	classify: backlog_plan_read.classify,
+	classify: classify_quietly,
 }
 
 // One classified plan, against the listing it was read with.
@@ -57,6 +68,7 @@ async function board_of(
 		context: backlog_plan_read.context_of(plan, read.listing),
 		labels: labels_of(read.listing.rows),
 		declared: plan.scope.declared,
+		withheld: new Set(plan.result.blocked_on_people.map((child) => child.number)),
 	}
 }
 
@@ -80,6 +92,41 @@ function not_held(children: ReadonlyArray<EpicChild>, held: ReadonlySet<number>)
 	return children.filter((child) => !held.has(child.number))
 }
 
+// The issues the pool runs: its waves and its running issues, not what it leaves unreached.
+function runs_of(pool: BoardPlan): ReadonlySet<number> {
+	const running = pool.waves.running ?? []
+
+	return new Set([...pool.waves.waves.flat(), ...running].map((child) => child.number))
+}
+
+// The named plan is classified alone, so a blocker only the pool holds reads as outside it; the
+// child still waits on a person only while a standing blocker is one the pool does not run.
+function waits_outside(child: EpicChild, pool: BoardPlan, runs: ReadonlySet<number>): boolean {
+	const { context } = pool
+
+	return child.blocked_by.some(
+		(edge) =>
+			backlog_plan.is_standing(edge, context) &&
+			!(edge.repo === context.repo && runs.has(edge.number)),
+	)
+}
+
+function lead_withheld(lead: BoardPlan, pool: BoardPlan): Array<number> {
+	const runs = runs_of(pool)
+	const children = [...lead.waves.waves.flat(), ...lead.waves.unreached]
+	const freed = children.filter((child) => !waits_outside(child, pool, runs))
+	const freed_numbers = new Set(freed.map((child) => child.number))
+
+	return [...(lead.withheld ?? [])].filter((number) => !freed_numbers.has(number))
+}
+
+// The named plan's withheld issues the pool does not free, and the pool's the named plan does not hold.
+function withheld_of(lead: BoardPlan, pool: BoardPlan, held: ReadonlySet<number>): Set<number> {
+	const from_pool = [...(pool.withheld ?? [])].filter((number) => !held.has(number))
+
+	return new Set([...lead_withheld(lead, pool), ...from_pool])
+}
+
 // The named waves lead and the pool's follow, a child the named plan already holds left out of the pool
 // so a named epic's children are not drawn twice.
 function joined(lead: BoardPlan, pool: BoardPlan): BoardPlan {
@@ -89,11 +136,13 @@ function joined(lead: BoardPlan, pool: BoardPlan): BoardPlan {
 		waves: {
 			waves: [...lead.waves.waves, ...pool.waves.waves.map((wave) => not_held(wave, held))],
 			unreached: [...lead.waves.unreached, ...not_held(pool.waves.unreached, held)],
+			running: [...(lead.waves.running ?? []), ...not_held(pool.waves.running ?? [], held)],
 		},
 		tracked: new Map([...pool.tracked, ...lead.tracked]),
 		context: pool.context,
 		labels: pool.labels,
 		declared: new Map([...(pool.declared ?? []), ...(lead.declared ?? [])]),
+		withheld: withheld_of(lead, pool, held),
 	}
 }
 
@@ -108,13 +157,16 @@ async function scoped_board(named: NamedPlan, read: PlanRead): Promise<BoardPlan
 }
 
 // `undefined` is a failed read, which the board answers by keeping the plan it already has.
+// An empty listing is one too: the board is read while its own run's issues are open, and an empty one
+// drew every live child finished and the pool empty (joshuafolkken/kit#4537). The guard is the board's
+// alone — `backlog:plan` in a repository with no open issue reads an empty listing correctly.
 async function read_plan(
 	named: NamedPlan,
 	ports: PlanPorts = LIVE_PORTS,
 ): Promise<BoardPlan | undefined> {
 	const listing = await ports.fetch_open()
 
-	if (listing === undefined) return undefined
+	if (listing === undefined || listing.rows.length === 0) return undefined
 
 	const read = { listing, ports }
 

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

@@ -0,0 +1,45 @@
+import { backlog_drive_named } from '#scripts/backlog/backlog-drive-named'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
+import { run_board_labels } from './run-board-labels'
+import { run_board_layout, type RowReason } from './run-board-layout'
+import type { ReasonRead } from './run-board-reason'
+import { run_board_setup } from './run-board-setup'
+
+// The queued row the run's planning is for (joshuafolkken/kit#4279): while the run stands at its
+// `planning` stage, the one issue it launches next leads with 📝 and says how long it has planned, and
+// no other row does. That issue is the driver's own next in a named run (`backlog-drive-named.ts`), else
+// the plan's first waiting row — the head of its first wave. No event says it; the stage and the order do.
+
+const { STAGE } = run_event_setup
+const FIRST = 0
+const PLANNING_ICON = run_board_labels.STAGE_ICONS[STAGE.PLANNING]
+
+interface Planning {
+	issue: number
+	reason: RowReason
+}
+
+function named_next(read: ReasonRead, in_flight: ReadonlyArray<number>): number | undefined {
+	if (read.carry === undefined) return undefined
+
+	return backlog_drive_named.next_of(read.carry, in_flight.map(String))
+}
+
+function next_launch(read: ReasonRead, in_flight: ReadonlyArray<number>): number | undefined {
+	return named_next(read, in_flight) ?? run_board_layout.waiting_children(read)[FIRST]?.number
+}
+
+function planning_of(read: ReasonRead, in_flight: ReadonlyArray<number>): Planning | undefined {
+	const { setup, setup_ms } = run_board_setup.read(read.events)
+	if (read.is_stopped || setup !== STAGE.PLANNING) return undefined
+	const issue = next_launch(read, in_flight)
+
+	return issue === undefined
+		? undefined
+		: { issue, reason: { icon: PLANNING_ICON, since_ms: setup_ms } }
+}
+
+const run_board_planning = { planning_of }
+
+export { run_board_planning }
+export type { Planning }

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

@@ -0,0 +1,44 @@
+import type { BoardPriority } from './run-board-kind'
+import { run_board_labels } from './run-board-labels'
+import { run_board_layout, type BoardLayout, type BoardRow } from './run-board-layout'
+
+// A row's priority (joshuafolkken/kit#4383), drawn between its number and its kind, and tallied
+// beside the header's ⏳ count. A normal row draws `KIND_BLANK` in the column, so every title still
+// starts in one column.
+
+const { KIND_BLANK } = run_board_labels
+
+const PRIORITY_ICONS: Readonly<Record<BoardPriority, string>> = {
+	critical: '🚨',
+	high: '🔺',
+}
+const ORDER: ReadonlyArray<BoardPriority> = ['critical', 'high']
+
+function cell_of(row: BoardRow): string {
+	return row.priority === undefined ? KIND_BLANK : PRIORITY_ICONS[row.priority]
+}
+
+// The rows the ⏳ count holds: neither settled nor running.
+function is_waiting(row: BoardRow): boolean {
+	return row.state !== 'running' && !run_board_layout.is_settled(row.state)
+}
+
+function part_of(rows: ReadonlyArray<BoardRow>, priority: BoardPriority): string | undefined {
+	const count = rows.filter((row) => row.priority === priority).length
+
+	return count === 0 ? undefined : `${PRIORITY_ICONS[priority]} ${String(count)}`
+}
+
+// ` (🚨 1 🔺 2)` after the ⏳ count, naming only the priorities present; nothing when none is.
+function tally_of(layout: BoardLayout): string {
+	const waiting = run_board_layout.rows_of(layout).filter((row) => is_waiting(row))
+	const parts = ORDER.map((priority) => part_of(waiting, priority)).filter(
+		(part) => part !== undefined,
+	)
+
+	return parts.length === 0 ? '' : ` (${parts.join(' ')})`
+}
+
+const run_board_priority = { cell_of, tally_of }
+
+export { run_board_priority }