@joshuafolkken/kit 1.2116.0 → 1.3041.0

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

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

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

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

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

@@ -0,0 +1,53 @@
+// A reading the board draws as last taken, re-read in the background once it is `interval_ms` old: a
+// redraw never waits on the read, and no second read starts while one is under way. Only the very
+// first read, with nothing yet to draw, waits for it. Shared by `top` (`run-board-usage-top.ts`) and the
+// usage-limit gauges (`run-board-quota-held.ts`).
+
+interface HeldPorts<Reading> {
+	read: () => Promise<Reading>
+	now: () => number
+	interval_ms: number
+	// What a first read that fails answers; a later failure keeps the reading before it.
+	fallback: Reading
+}
+
+interface Held<Reading> {
+	reading: Reading | undefined
+	read_ms: number
+	pending: Promise<Reading> | undefined
+}
+
+async function refreshed<Reading>(
+	held: Held<Reading>,
+	ports: HeldPorts<Reading>,
+): Promise<Reading> {
+	try {
+		held.reading = await ports.read()
+	} catch {
+		held.reading ??= ports.fallback
+	} finally {
+		held.pending = undefined
+	}
+
+	return held.reading
+}
+
+function held_reader<Reading>(ports: HeldPorts<Reading>): () => Promise<Reading> {
+	const held: Held<Reading> = { reading: undefined, read_ms: -Infinity, pending: undefined }
+
+	async function read(): Promise<Reading> {
+		if (held.pending === undefined && ports.now() - held.read_ms >= ports.interval_ms) {
+			held.read_ms = ports.now()
+			held.pending = refreshed(held, ports)
+		}
+
+		return held.reading ?? (await (held.pending ?? Promise.resolve(ports.fallback)))
+	}
+
+	return read
+}
+
+const run_board_held = { held_reader }
+
+export { run_board_held }
+export type { HeldPorts }

package/scripts/run/board/run-board-human-merge.ts

@@ -0,0 +1,113 @@
+import type { EpicChild } from '#scripts/epic/epic-graph'
+import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
+import { git_gh_etag_read } from '#scripts/gh/git-gh-etag-read'
+import { git_gh_pr_rest } from '#scripts/gh/git-gh-pr-rest'
+import { git_closes_keyword } from '#scripts/git/git-closes-keyword'
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { has_label_name, NEEDS_HUMAN_MERGE_LABEL } from '#scripts/issue/issue-labels'
+import { run_board_labels } from './run-board-labels'
+import type { BoardPlan, Overlay, RowReason } from './run-board-layout'
+
+// The current open listing owns this wait; an old launch or park must not hide it.
+function is_waiting(plan: BoardPlan, issue: number): boolean {
+	return (
+		plan.context.open_numbers?.has(issue) !== false &&
+		has_label_name(plan.labels.get(issue) ?? [], NEEDS_HUMAN_MERGE_LABEL)
+	)
+}
+
+function has_waiting(plan: BoardPlan): boolean {
+	for (const issue of plan.labels.keys()) {
+		if (is_waiting(plan, issue)) return true
+	}
+
+	return false
+}
+
+async function read_prs(plan: BoardPlan): Promise<ReadonlyMap<number, number>> {
+	if (!has_waiting(plan)) return new Map()
+	const per_page = git_gh_api_path.FULL_PAGE_SIZE
+	const path = `${git_gh_api_path.pulls_api_path(plan.context.repo)}?state=open&per_page=${String(per_page)}`
+	const json = await git_gh_etag_read.read_listing(path, per_page)
+	const pulls = git_gh_pr_rest.parse_rest_pulls(json)
+	const pairs = pulls.flatMap((pull) => {
+		const issue = Number(git_closes_keyword.parse_closes_issue_number(pull.body ?? undefined))
+
+		return is_waiting(plan, issue) ? [[issue, pull.number] as const] : []
+	})
+
+	return new Map(pairs)
+}
+
+// The tail says what the person does next: merge the PR, or find it when the read listing pairs
+// none with the issue. The pairing reads only the first `closes #N`, so the find tail claims no
+// absence. An unread listing says nothing either way, so it adds no tail.
+function pr_reason(issue: number, prs: BoardPlan['human_merge_prs']): RowReason {
+	const icon = run_board_labels.WAIT_ICONS.human_merge
+	if (prs === undefined) return { icon, value: undefined }
+	const pr = prs.get(issue)
+
+	if (pr === undefined) {
+		const tail = `→ find its PR for ${issue_cite.plain_for('terminal', issue)}`
+
+		return { icon, value: undefined, tail }
+	}
+
+	return {
+		icon,
+		value: `PR ${String(pr)}`,
+		tail: `→ merge PR ${issue_cite.plain_for('terminal', pr)}`,
+		pr,
+	}
+}
+
+function reason_of(child: EpicChild, plan: BoardPlan): RowReason | undefined {
+	if (child.state !== 'OPEN' || !is_waiting(plan, child.number)) return undefined
+
+	return pr_reason(child.number, plan.human_merge_prs)
+}
+
+async function with_prs(plan: BoardPlan | undefined): Promise<BoardPlan | undefined> {
+	return plan === undefined ? undefined : { ...plan, human_merge_prs: await read_prs(plan) }
+}
+
+function waiting_children(plan: BoardPlan): Array<EpicChild> {
+	const { waves } = plan
+	const all = [...waves.waves.flat(), ...waves.unreached, ...(waves.running ?? [])]
+
+	return all.filter(
+		(child) =>
+			child.state === 'OPEN' &&
+			is_waiting(plan, child.number) &&
+			!plan.occupied_lanes?.includes(String(child.number)),
+	)
+}
+
+// Only workers that released their seat move into the human-merge waiting section.
+function overlay_of(
+	plan: BoardPlan,
+	statuses: Overlay['statuses'],
+): Overlay & { waiting_numbers: ReadonlySet<number> } {
+	const { waves } = plan
+	const held = waiting_children(plan)
+	const numbers = new Set(held.map((child) => child.number))
+	const hidden = new Set([...numbers, ...(plan.occupied_lanes ?? []).map(Number)])
+	const next = {
+		...waves,
+		...(waves.running !== undefined && {
+			running: waves.running.filter((child) => !numbers.has(child.number)),
+		}),
+		waves: waves.waves.map((wave) => wave.filter((child) => !hidden.has(child.number))),
+		unreached: [...waves.unreached.filter((child) => !hidden.has(child.number)), ...held],
+	}
+
+	return {
+		waiting_numbers: numbers,
+		plan: { ...plan, waves: next },
+		statuses: new Map([...statuses].filter(([issue]) => !numbers.has(issue))),
+	}
+}
+
+const run_board_human_merge = { overlay_of, read_prs, reason_of, with_prs }
+
+export { run_board_human_merge }

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

@@ -0,0 +1,37 @@
+import { issue_human_stops } from '#scripts/issue/issue-human-stops'
+import {
+	ALREADY_DONE_LABEL,
+	has_label_name,
+	NEEDS_HUMAN_MERGE_LABEL,
+	NEEDS_HUMAN_REVIEW_LABEL,
+} from '#scripts/issue/issue-labels'
+
+// joshuafolkken/kit#7097: the board's 🙋 state (`human`) — a stop waiting on a person — is read from the
+// human-stop registry (`issue-human-stops.ts`), so a stop added there is drawn as one without a board
+// change. A registry label the board draws elsewhere is named here with where.
+const DRAWN_ELSEWHERE: ReadonlyMap<string, string> = new Map([
+	[NEEDS_HUMAN_MERGE_LABEL, 'the merge wait (`run-board-human-merge.ts`)'],
+	[ALREADY_DONE_LABEL, 'the done section (joshuafolkken/kit#7095)'],
+	[NEEDS_HUMAN_REVIEW_LABEL, 'nowhere: it withholds the commit, not the lane'],
+])
+
+function human_labels(): ReadonlyArray<string> {
+	return [...issue_human_stops.labels()].filter((label) => !DRAWN_ELSEWHERE.has(label))
+}
+
+// Whether label names carry a stop that waits on a person.
+function is_human(labels: ReadonlyArray<string>): boolean {
+	return human_labels().some((label) => has_label_name(labels, label))
+}
+
+// A park waiting on a person's decision (joshuafolkken/kit#4099) — the one answer the 🙋 decision
+// section and the findings section read a park reason by.
+function is_decision(reason: string | undefined): boolean {
+	if (reason === undefined) return false
+
+	return human_labels().some((label) => reason.includes(label))
+}
+
+const run_board_human = { DRAWN_ELSEWHERE, human_labels, is_decision, is_human }
+
+export { run_board_human }

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

@@ -16,16 +16,19 @@ function since_of(before: IdleSince, idle: ReadonlyArray<string>, now_ms: number
 	return new Map(idle.map((lane) => [lane, before.get(lane) ?? now_ms]))
 }
 
-// The lanes idle for the whole window as of the read at `read_ms`; none before any read.
-function stopped_of(since: IdleSince, read_ms: number | undefined): Array<string> {
-	if (read_ms === undefined) return []
+// The lanes idle for the whole window as of the read at `read_ms`, each with when it was first read
+// idle — when its child stopped (joshuafolkken/kit#6577); none before any read.
+function stopped_since(since: IdleSince, read_ms: number | undefined): IdleSince {
+	if (read_ms === undefined) return NO_IDLE
 
-	const lasted = [...since].filter(([, at]) => read_ms - at >= lane_await.RECONFIRM_MS)
+	return new Map([...since].filter(([, at]) => read_ms - at >= lane_await.RECONFIRM_MS))
+}
 
-	return lasted.map(([lane]) => lane)
+function stopped_of(since: IdleSince, read_ms: number | undefined): Array<string> {
+	return [...stopped_since(since, read_ms).keys()]
 }
 
-const run_board_idle = { NO_IDLE, since_of, stopped_of }
+const run_board_idle = { NO_IDLE, since_of, stopped_of, stopped_since }
 
 export type { IdleSince }
 export { run_board_idle }