@joshuafolkken/kit 1.2114.0 → 1.3000.0

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

@@ -2,6 +2,7 @@ import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { z } from 'zod'
 import type { ClosedIssue } from './run-board-closed'
+import type { IssueCount } from './run-board-issue-count'
 
 // The last GitHub reads a `run:board` drew — the titles, the labels and the children read closed — kept
 // in one file per checkout, so a board opened again draws them at once rather than nameless until its
@@ -20,6 +21,8 @@ interface Known {
 interface Snapshot extends Known {
 	run_started_ms: number
 	closed: ReadonlyMap<number, ClosedIssue>
+	// The repository's issue count (`run-board-issue-count.ts`); none before one is read.
+	issue_count?: IssueCount | undefined
 }
 
 // Where a board keeps its snapshot; a board with none keeps nothing.
@@ -52,6 +55,7 @@ const snapshot_schema = z.object({
 	titles: z.array(title_entry_schema),
 	labels: z.array(label_entry_schema),
 	closed: z.array(closed_entry_schema),
+	issue_count: z.object({ open: z.number(), closed: z.number() }).optional(),
 })
 
 function snapshot_of(text: string): Snapshot | undefined {
@@ -60,13 +64,14 @@ function snapshot_of(text: string): Snapshot | undefined {
 
 		if (!parsed.success) return undefined
 
-		const { run_started_ms, titles, labels, closed } = parsed.data
+		const { run_started_ms, titles, labels, closed, issue_count } = parsed.data
 
 		return {
 			run_started_ms,
 			titles: new Map(titles),
 			labels: new Map(labels),
 			closed: new Map(closed),
+			issue_count,
 		}
 	} catch {
 		return undefined
@@ -85,6 +90,7 @@ function save(target: string, snapshot: Snapshot): void {
 		titles: [...snapshot.titles],
 		labels: [...snapshot.labels],
 		closed: [...snapshot.closed],
+		issue_count: snapshot.issue_count,
 	}
 
 	try {

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

@@ -1,3 +1,4 @@
+import type { AgentProvider } from '#scripts/agent/agent-provider'
 import type { PendingLaunch } from '#scripts/backlog/backlogrun-launch'
 import type { CarryRead } from '#scripts/run/carry/run-carry'
 import type { EndedRun } from '#scripts/run/carry/run-carry-ended'
@@ -10,6 +11,7 @@ import type { RunEvent } from '#scripts/run/event/run-event-stream'
 
 // One run to draw. `ended_ms` is set only for a run that has ended.
 interface BoardSpan {
+	scheduler_provider?: AgentProvider | undefined
 	invocation: string
 	started_ms: number
 	ended_ms: number | undefined
@@ -17,6 +19,14 @@ interface BoardSpan {
 
 const { moment_of } = run_event_scope
 
+function provider_of(
+	record: Pick<BoardSpan, 'scheduler_provider'>,
+): Pick<BoardSpan, 'scheduler_provider'> {
+	return record.scheduler_provider === undefined
+		? {}
+		: { scheduler_provider: record.scheduler_provider }
+}
+
 function ended_span(ended: EndedRun | undefined): BoardSpan | undefined {
 	if (ended === undefined) return undefined
 
@@ -25,7 +35,7 @@ function ended_span(ended: EndedRun | undefined): BoardSpan | undefined {
 
 	if (started_ms === undefined || ended_ms === undefined) return undefined
 
-	return { invocation: ended.invocation, started_ms, ended_ms }
+	return { invocation: ended.invocation, started_ms, ended_ms, ...provider_of(ended) }
 }
 
 // A run `josh backlogrun` launched and its parent has not claimed yet: it has no carry record, so the
@@ -35,7 +45,7 @@ function launch_span(launch: PendingLaunch | undefined): BoardSpan | undefined {
 
 	if (launch === undefined || started_ms === undefined) return undefined
 
-	return { invocation: launch.invocation, started_ms, ended_ms: undefined }
+	return { invocation: launch.invocation, started_ms, ended_ms: undefined, ...provider_of(launch) }
 }
 
 // With no carry record: the run on its way, else the one that last ended. **A launch older than that
@@ -67,7 +77,12 @@ function span_of(
 
 	if (started_ms === undefined) return undefined
 
-	return { invocation: read.carry.invocation, started_ms, ended_ms: undefined }
+	return {
+		invocation: read.carry.invocation,
+		started_ms,
+		ended_ms: undefined,
+		...provider_of(read.carry),
+	}
 }
 
 // Whether the span drawn with no carry record is the ended run's, rather than a launch's.

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

@@ -1,3 +1,4 @@
+import { poll } from '#scripts/lib/poll'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { run_board_fit, type TerminalSize } from './run-board-fit'
 import { run_board_labels } from './run-board-labels'
@@ -84,13 +85,18 @@ async function turn_until(
 	ports: SpinPorts,
 	until_ms: number,
 ): Promise<void> {
-	for (let now = ports.now(); now < until_ms; now = ports.now()) {
-		// eslint-disable-next-line no-await-in-loop -- polling: each turn waits for the spinner's next frame
-		await ports.sleep(next_turn(now, until_ms) - now)
-		const at_ms = ports.now()
+	await poll.poll_until(() => ports.now() >= until_ms, {
+		attempts: Infinity,
+		interval_ms: 0,
+		sleeper: async () => {
+			const now_ms = ports.now()
 
-		if (at_ms < until_ms) ports.write(spin_bytes(spots, spinner_of(at_ms)))
-	}
+			await ports.sleep(next_turn(now_ms, until_ms) - now_ms)
+			const at_ms = ports.now()
+
+			if (at_ms < until_ms) ports.write(spin_bytes(spots, spinner_of(at_ms)))
+		},
+	})
 }
 
 // Waits for the next second, turning the spinners until then; a frame with none just waits.

package/scripts/run/board/run-board-standing-waits.ts

@@ -0,0 +1,52 @@
+import { backlog_plan, type PlanContext } from '#scripts/backlog/backlog-plan'
+import type { EpicChild } from '#scripts/epic/epic-graph'
+import type { IssueReference } from '#scripts/epic/epic-reference'
+import { issue_cite } from '#scripts/issue/issue-cite'
+import type { ItemStatus } from './run-board-status'
+
+// The blockers that still hold a child, as its row names them: an untouched row draws them as 🔗, and
+// a stalled row — touched or not — waits on them in place of its retry.
+
+interface WaitSource {
+	plan: { context: PlanContext }
+	statuses: ReadonlyMap<number, ItemStatus>
+}
+
+// A blocker the plan still names, unless the stream has already seen it merge — the plan was read up
+// to two minutes ago, and a merge since then is no longer worth waiting on.
+function is_waiting_on(edge: IssueReference, source: WaitSource): boolean {
+	const { context } = source.plan
+	const is_merged =
+		edge.repo === context.repo && source.statuses.get(edge.number)?.state === 'merged'
+
+	return !is_merged && backlog_plan.is_standing(edge, context)
+}
+
+function reference_of(edge: IssueReference, repo: string): string {
+	return edge.repo === repo
+		? String(edge.number)
+		: issue_cite.plain_for('terminal', edge.number, edge.repo)
+}
+
+function waits_of(child: EpicChild, source: WaitSource): Array<string> {
+	return child.blocked_by
+		.filter((edge) => is_waiting_on(edge, source))
+		.map((edge) => reference_of(edge, source.plan.context.repo))
+}
+
+// Each planned child's standing blockers, by number — what a touched row, which the plan does not
+// draw, reads its own from.
+function by_number(
+	children: ReadonlyArray<EpicChild>,
+	source: WaitSource,
+): ReadonlyMap<number, ReadonlyArray<string>> {
+	return new Map(children.map((child) => [child.number, waits_of(child, source)]))
+}
+
+const run_board_standing_waits = {
+	by_number,
+	is_waiting_on,
+	waits_of,
+}
+
+export { run_board_standing_waits }

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

@@ -5,9 +5,11 @@ import type { SectionKey, TerminalSize } from './run-board-fit'
 import type { Gatherer, GatherRead } from './run-board-gather'
 import type { BoardForm } from './run-board-header'
 import { run_board_idle } from './run-board-idle'
+import type { IssueCount } from './run-board-issue-count'
 import type { KeyInput } from './run-board-keys'
 import type { BoardPlan } from './run-board-layout'
 import type { Link } from './run-board-link'
+import type { GithubRateLimit } from './run-board-render-quota-github'
 import { run_board_snapshot, type Known, type SnapshotStore } from './run-board-snapshot'
 import type { Spot } from './run-board-spin'
 import type { Thanks } from './run-board-thanks-csv'
@@ -45,6 +47,11 @@ interface BoardPorts {
 	mark: () => Promise<void>
 	// The reviewers' roster (`run-board-thanks-read.ts`); none where the frame thanks nobody — the chat.
 	read_thanks?: (() => Promise<Thanks>) | undefined
+	// GitHub's REST core and GraphQL allowances with the transport (`gh-core-rate-limit.ts`); none where
+	// the frame shows none.
+	read_rate_limit?: (() => Promise<GithubRateLimit | undefined>) | undefined
+	// The repository's open and closed issues (`run-board-issue-count.ts`); none where none is read.
+	read_issue_count?: ((repo: string) => Promise<IssueCount | undefined>) | undefined
 	// Sends one chat frame off-screen, for `--every` alone.
 	push: (frame: string) => Promise<void>
 	// Runs `leave` however the process ends: a normal exit, Ctrl+C or SIGTERM.
@@ -83,6 +90,16 @@ interface BoardState extends GatherRead {
 	thanks: Thanks
 	thanks_fetch: Fetch<Thanks> | undefined
 	thanks_attempted_ms: number | undefined
+	// The allowances drawn on the usage row — none once a read fails — the read in flight, and when
+	// it was last launched.
+	rate_limit: GithubRateLimit | undefined
+	rate_limit_fetch: Fetch<GithubRateLimit | undefined> | undefined
+	rate_limit_attempted_ms: number | undefined
+	// The repository's issue count — none once a read fails — the read in flight, and when it was last
+	// launched.
+	issue_count: IssueCount | undefined
+	issue_count_fetch: Fetch<IssueCount | undefined> | undefined
+	issue_count_attempted_ms: number | undefined
 }
 
 const FRESH_STATE: BoardState = {
@@ -109,6 +126,12 @@ const FRESH_STATE: BoardState = {
 	thanks: [],
 	thanks_fetch: undefined,
 	thanks_attempted_ms: undefined,
+	rate_limit: undefined,
+	rate_limit_fetch: undefined,
+	rate_limit_attempted_ms: undefined,
+	issue_count: undefined,
+	issue_count_fetch: undefined,
+	issue_count_attempted_ms: undefined,
 }
 
 function is_due(last_ms: number | undefined, interval_ms: number, now_ms: number): boolean {

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

@@ -1,20 +1,21 @@
-import {
-	has_label_name,
-	IN_PROGRESS_LABEL,
-	NEEDS_DECISION_LABEL,
-	RUN_STALLED_LABEL,
-} from '#scripts/issue/issue-labels'
+import type { AgentResult } from '#scripts/agent/agent-event'
 import type { Span } from '#scripts/lane/lane-spans'
 import type { PrChecks } from '#scripts/run/event/run-event-checks'
+import { run_event_retry } from '#scripts/run/event/run-event-retry'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import { run_board_checks } from './run-board-checks'
-import type { ClosedIssue } from './run-board-closed'
+import { run_board_closed, type ClosedIssue, type ListingRead } from './run-board-closed'
 import { run_board_ending_reason } from './run-board-ending-reason'
+import { run_board_ending_states } from './run-board-ending-states'
+import { run_board_idle, type IdleSince } from './run-board-idle'
 import { run_board_lane_event, type LaneEvent } from './run-board-lane-event'
 import type { BoardLanes } from './run-board-lane-state'
+import { run_board_lane_stop } from './run-board-lane-stop'
 import { run_board_lane_time } from './run-board-lane-time'
 import { run_board_phase, type Phase } from './run-board-phase'
+import { run_board_settle } from './run-board-settle'
 import { run_board_setup, type SetupRead } from './run-board-setup'
 
 // What each issue of a run is doing now, read from the run's own event stream and what each open lane's
@@ -29,6 +30,8 @@ type ItemState =
 	| 'merged'
 	| 'parked'
 	| 'done'
+	// Closed by `josh issue:already-done` with verified evidence — finished, nothing to merge.
+	| 'already_done'
 	| 'waiting'
 	| 'human'
 	| 'stopped'
@@ -56,10 +59,17 @@ interface ItemStatus {
 	track?: ReadonlyArray<Phase> | undefined
 	// When a running child entered the phase its track ends on — the event that moved it there.
 	phase_ms?: number | undefined
-	// Why the park or withdraw that ended the child ended it, where its event gives a reason.
+	// The raw reason the ending event gave; the layout chooses the current stalled resume action.
 	reason?: string | undefined
 	// The command that paused a paused lane, read off its lane state record (`run-board-lane-state.ts`).
 	paused_by?: string | undefined
+	// What stopped the lane or its ship — the command its record or its labels name
+	// (`run-board-lane-stop.ts`).
+	stop_reason?: string | undefined
+	// A running lane's transcript result (`run_liveness.read_agent_state`); `undefined` where unread.
+	result?: AgentResult | undefined
+	// When a running lane's transcript was last written — the latest an idle lane can have stopped.
+	written_ms?: number | undefined
 }
 
 interface LatestEvent {
@@ -81,20 +91,13 @@ interface RunActivity extends Partial<SetupRead> {
 	lane_events?: ReadonlyMap<number, LaneEvent> | undefined
 	// Each child's newest `pr-checks`, by issue (`run-board-checks.ts`).
 	pr_checks?: ReadonlyMap<number, PrChecks> | undefined
+	// The newest session's start until its first lane opened (`run-board-first-lane.ts`).
+	first_lane_ms?: number | undefined
 	// The run's last position is a `stop` that names no child — the run itself ended.
 	is_stopped: boolean
 }
 
 const KIND = run_event_stream.EVENT_KIND
-const ENDING_STATES: Readonly<Partial<Record<string, ItemState>>> = {
-	[KIND.MERGE]: 'merged',
-	// A drive-closed measurement completes its issue as a merge does (`issue-merged.ts` → `is_measured`).
-	[KIND.MEASURED]: 'merged',
-	[KIND.PARK]: 'parked',
-	[KIND.SPLIT]: 'done',
-	[KIND.STOP]: 'done',
-	[KIND.WITHDRAW]: 'withdrawn',
-}
 // A cut or a resume says the child is still running, on whatever phase it had reached.
 const CONTINUING_KINDS: ReadonlySet<string> = new Set([KIND.CUT, KIND.RESUME])
 // A person's restart, and a re-dispatch after an outage, start the child over in a fresh session, so
@@ -103,21 +106,17 @@ const { LAUNCH_KINDS } = run_board_lane_time
 // What the GitHub read may still settle: a running child, and one whose lane has no child left in it —
 // a child that merged and then died is drawn merged, not stopped.
 const UNSETTLED_STATES: ReadonlySet<ItemState> = new Set(['running', 'paused', 'stopped'])
-// A parked child waits on a person, who may close its issue after the park; only a closed read settles
-// it again, so one still open stays parked whatever its labels say (joshuafolkken/kit#3958).
-const PARKED_STATE: ItemState = 'parked'
+// A child waiting on a person — parked, or stopped for human review — is drawn in 🙋 decision. The
+// person may close its issue after the stop; only a closed read settles it again, so one still open
+// keeps waiting whatever its labels say (joshuafolkken/kit#3958).
+const WAITING_STATES: ReadonlySet<ItemState> = new Set(['parked', 'human'])
+
+const { relaunch_of, settled_as } = run_board_settle
 
 function moment(event: RunEvent): number {
 	return Date.parse(event.at)
 }
 
-// The newest launch carried on, where the child launched more than once.
-function relaunch_of(status: ItemStatus | undefined): Pick<ItemStatus, 'launched_ms'> {
-	const launched_ms = status?.launched_ms
-
-	return launched_ms === undefined ? {} : { launched_ms }
-}
-
 // joshuafolkken/kit#3971: a launch keeps the start of the child's first one in this run.
 function launched(previous: ItemStatus | undefined, event: RunEvent): ItemStatus {
 	const at_ms = moment(event)
@@ -140,30 +139,22 @@ function moved(previous: ItemStatus, track: ReadonlyArray<Phase>, event: RunEven
 	return { ...previous, track, phase_ms: is_same ? previous.phase_ms : moment(event) }
 }
 
-// The status a child settles into: its start and the track it had reached, so a settled row still
-// draws how it got there.
-// What a settled child keeps of its run: its newest launch, its spans on a lane, and its track.
-function kept_of(
+// A bare ending that repeats the one before keeps that one's reason: `run:merge` writes a bare park
+// after the ship-stop cap's park named its cause (joshuafolkken/kit#5780).
+function kept_reason(
 	previous: ItemStatus | undefined,
-): Pick<ItemStatus, 'launched_ms' | 'spans' | 'track'> {
-	const spans = previous?.spans
-	const track = previous?.track
-
-	return {
-		...relaunch_of(previous),
-		...(spans !== undefined && { spans }),
-		...(track !== undefined && { track }),
-	}
-}
-
-function settled_as(previous: ItemStatus | undefined, state: ItemState): ItemStatus {
-	return { state, started_ms: previous?.started_ms, ...kept_of(previous) }
+	state: ItemState,
+): Pick<ItemStatus, 'reason'> {
+	return previous?.state === state && previous.reason !== undefined
+		? { reason: previous.reason }
+		: {}
 }
 
 function ended(previous: ItemStatus | undefined, state: ItemState, event: RunEvent): ItemStatus {
 	return {
 		...settled_as(previous, state),
 		ended_ms: moment(event),
+		...kept_reason(previous, state),
 		...run_board_ending_reason.recorded_of(event),
 	}
 }
@@ -210,15 +201,25 @@ function advanced(previous: ItemStatus | undefined, event: RunEvent): ItemStatus
 
 // One event folded into the status of the child it names; an event the board does not track keeps it.
 function next_status(previous: ItemStatus | undefined, event: RunEvent): ItemStatus | undefined {
+	if (run_event_retry.is_retry(event)) return settled_as(previous, 'waiting')
 	if (LAUNCH_KINDS.has(event.kind)) return launched(previous, event)
 
-	const ending = ENDING_STATES[event.kind]
+	const ending = run_board_ending_states.STATES[event.kind]
 
 	if (ending !== undefined) return ended(previous, ending, event)
 
 	return CONTINUING_KINDS.has(event.kind) ? continued(previous) : advanced(previous, event)
 }
 
+// A yielded lane's close hands its child back to the queue untouched, so its next launch starts it over.
+function fold_event(statuses: Map<number, ItemStatus>, event: RunEvent): void {
+	const issue = Number(run_event_scope.issue_named(event))
+	const status = next_status(statuses.get(issue), event)
+
+	if (run_board_ending_states.is_requeued(event)) statuses.delete(issue)
+	else if (status !== undefined && Number.isSafeInteger(issue)) statuses.set(issue, status)
+}
+
 // `seed` is what each issue is doing before `events` — a lane's record, so a cut or a stage line whose
 // launch rolled off the stream carries the child on.
 function fold_events(
@@ -227,12 +228,7 @@ function fold_events(
 ): Map<number, ItemStatus> {
 	const statuses = new Map(seed)
 
-	for (const event of events) {
-		const issue = Number(run_event_scope.issue_named(event))
-		const status = next_status(statuses.get(issue), event)
-
-		if (status !== undefined && Number.isSafeInteger(issue)) statuses.set(issue, status)
-	}
+	for (const event of events) fold_event(statuses, event)
 
 	return statuses
 }
@@ -271,34 +267,24 @@ function with_spans(statuses: Map<number, ItemStatus>, events: ReadonlyArray<Run
 	}
 }
 
-// A running lane no child is working in is stopped whatever the stream last said: a child that died
-// writes no ending, so its row would otherwise run — and its phase time grow — for as long as the lane
-// stays.
-function lane_status(status: ItemStatus, is_idle: boolean): ItemStatus {
-	if (!is_idle || status.state !== 'running') return status
-
-	return { ...settled_as(status, 'stopped'), lane: status.lane }
-}
-
 // Every child the run has touched, with what each of this run's open lanes is doing laid over it. An
 // earlier run's lane and one with no record are drawn apart (`run-board-earlier.ts`), so what the span
-// says of their issues is not this run's. A lane in `idle` has no child working in it (`lane-spent.ts`).
+// says of their issues is not this run's. A lane in `idle` has had no child working in it since the
+// time it maps to (`lane-spent.ts`); one this run's record ended is stopped too, though no longer open
+// (`run-board-lane-stop.ts`).
 function statuses_of(
 	events: ReadonlyArray<RunEvent>,
 	lanes: BoardLanes,
-	idle: ReadonlyArray<string> = [],
+	idle: IdleSince = run_board_idle.NO_IDLE,
 ): ReadonlyMap<number, ItemStatus> {
 	const statuses = new Map(remembered(FOLDED, events, fold_events))
 	const apart = [...lanes.earlier.keys(), ...lanes.unknown.map(Number)]
 
 	for (const issue of apart) statuses.delete(issue)
 
-	for (const [issue, status] of lanes.own) {
-		const is_idle = idle.includes(String(issue))
-
-		statuses.set(issue, lane_status(status, is_idle))
-	}
+	for (const [issue, status] of lanes.own) statuses.set(issue, status)
 
+	run_board_lane_stop.stop_lanes(statuses, lanes, idle)
 	with_spans(statuses, events)
 
 	return statuses
@@ -321,10 +307,8 @@ function since_launch(
 }
 
 // The open listing the plan was read with, and when it was read.
-interface OpenRead {
-	// `undefined` when the listing was cut short, so absence from it proves nothing.
-	open_numbers: ReadonlySet<number> | undefined
-	read_ms: number | undefined
+// `open_numbers` is `undefined` when the listing was cut short, so absence from it proves nothing.
+interface OpenRead extends ListingRead {
 	// The children read closed from GitHub (`run-board-closed.ts`), by number.
 	closed: ReadonlyMap<number, ClosedIssue>
 	// Each listed issue's label names, by number; an issue the listing did not hold has none to read.
@@ -341,23 +325,13 @@ function is_read_after_launch(status: ItemStatus, read: OpenRead): boolean {
 	return read.read_ms !== undefined && (launch_ms(status) ?? 0) <= read.read_ms
 }
 
-// What a running child's labels say it is doing, `undefined` where they agree it is running: the child
-// applies `needs-decision` and drops `in-progress` itself when it stops, while the stream's park is
-// written by a parent that may no longer be there.
-function labelled_state(labels: ReadonlyArray<string> | undefined): ItemState | undefined {
-	if (labels === undefined) return undefined
-	if (has_label_name(labels, NEEDS_DECISION_LABEL)) return 'human'
-	if (has_label_name(labels, RUN_STALLED_LABEL)) return 'stopped'
-
-	return has_label_name(labels, IN_PROGRESS_LABEL) ? undefined : 'stopped'
-}
-
+// A running child's labels, read after its launch, settle it (`run-board-lane-stop.ts`).
 function labelled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
-	const state = is_read_after_launch(status, read)
-		? labelled_state(read.labels.get(issue))
+	const stop = is_read_after_launch(status, read)
+		? run_board_lane_stop.label_stop(read.labels.get(issue))
 		: undefined
 
-	return state === undefined ? status : settled_as(status, state)
+	return stop === undefined ? status : run_board_lane_stop.label_settled(status, stop)
 }
 
 // A close dated before the launch is an earlier life of the issue, not how this run's child ended.
@@ -369,20 +343,19 @@ function is_closed_before_launch(status: ItemStatus, closed: ClosedIssue): boole
 	return closed.closed_ms < launch
 }
 
-function closed_state(closed: ClosedIssue): ItemState {
-	if (closed.is_merged) return 'merged'
-
-	return closed.is_not_planned ? 'withdrawn' : 'done'
+// A child read closed ends when GitHub says it closed — merged, withdrawn as not planned, already
+// done, or done.
+function closed_as(status: ItemStatus, closed: ClosedIssue): ItemStatus {
+	return { ...settled_as(status, run_board_closed.state_of(closed)), ended_ms: closed.closed_ms }
 }
 
-// A child read closed ends when GitHub says it closed — merged, withdrawn as not planned, or done.
 function closed_status(
 	status: ItemStatus,
 	closed: ClosedIssue | undefined,
 ): ItemStatus | undefined {
 	if (closed === undefined || is_closed_before_launch(status, closed)) return undefined
 
-	return { ...settled_as(status, closed_state(closed)), ended_ms: closed.closed_ms }
+	return closed_as(status, closed)
 }
 
 function unsettled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
@@ -391,16 +364,22 @@ function unsettled(issue: number, status: ItemStatus, read: OpenRead): ItemStatu
 	return from_closed ?? labelled(issue, status, read)
 }
 
-// The closed read is kept for the run, so a parked child a person reopened since is told apart by the
-// listing holding it again.
-function parked_settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
-	if (read.open_numbers?.has(issue) === true) return status
+// The closed read is kept for the run, so a waiting child (parked or human) a person reopened since is
+// told apart by a listing read after the close holding it again. Once a listing has landed, that — not
+// the launch — dates the close, so a closed child never waits in 🙋 decision (joshuafolkken/kit#6535,
+// joshuafolkken/kit#6891).
+function waiting_settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
+	const closed = read.closed.get(issue)
+	// `undefined` too for a close dated before this launch — an earlier life's close never settles it.
+	const settled_closed = closed_status(status, closed)
+
+	if (closed === undefined || settled_closed === undefined) return status
 
-	return closed_status(status, read.closed.get(issue)) ?? status
+	return run_board_closed.is_reopened(issue, closed, read) ? status : settled_closed
 }
 
 function settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
-	if (status.state === PARKED_STATE) return parked_settled(issue, status, read)
+	if (WAITING_STATES.has(status.state)) return waiting_settled(issue, status, read)
 
 	return UNSETTLED_STATES.has(status.state) ? unsettled(issue, status, read) : status
 }
@@ -410,7 +389,7 @@ function settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus
 // finished instead — merged, withdrawn or done, and timed. Absence from the open listing alone settles
 // nothing: a listing that came back short would draw live children finished (joshuafolkken/kit#4537).
 // One the listing holds is drawn as its labels say, so a child that stopped with no parent to record it
-// does not read as running. A parked child is settled again only by a closed read; one a person
+// does not read as running. A waiting child is settled again only by a closed read; one a person
 // released is dropped after it (`run-board-released.ts`).
 function settle_closed(
 	statuses: ReadonlyMap<number, ItemStatus>,
@@ -449,6 +428,7 @@ function stream_activity(events: ReadonlyArray<RunEvent>): RunActivity {
 		idle_ms: idle_of(events),
 		lane_events: run_board_lane_event.newest_of(events),
 		pr_checks: run_board_checks.newest_of(events),
+		first_lane_ms: run_event_setup.first_lane_ms(events),
 		is_stopped: is_run_stop(position),
 	}
 }
@@ -463,7 +443,14 @@ function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActi
 	return is_ended ? { ...activity, is_stopped: true } : activity
 }
 
-const run_board_status = { activity_of, fold_events, settle_closed, since_launch, statuses_of }
+const run_board_status = {
+	WAITING_STATES,
+	activity_of,
+	fold_events,
+	settle_closed,
+	since_launch,
+	statuses_of,
+}
 
 export { run_board_status }
 export type { ItemState, ItemStatus, LatestEvent, OpenRead, RunActivity }