@joshuafolkken/kit 1.1387.0 → 1.1435.0

package/scripts/lib/buffered-process.ts

@@ -1,4 +1,6 @@
+import { existsSync } from 'node:fs'
 import { execa } from 'execa'
+import { pnpm_reach } from './pnpm-reach'
 import { SUITE_TIMEOUT_MS } from './timeouts'
 
 // One definition of "run a check, keep its output, never throw".
@@ -9,7 +11,7 @@ import { SUITE_TIMEOUT_MS } from './timeouts'
 // (so one failing check does not abort its siblings), and a bound on how long a child may hang.
 // They had the same code twice, which is how a fix to one of them missed the other.
 
-const PNPM = 'pnpm'
+const { PNPM } = pnpm_reach
 const FORCE_COLOR = '1'
 const FAIL_EXIT_CODE = 1
 
@@ -35,6 +37,38 @@ interface BufferedProcessOptions {
 	timeout_ms?: number
 }
 
+// What execa reports about a child that produced no exit code. Declared here because execa's own
+// result type does not carry `code` or `shortMessage` on the non-rejecting path, though both are
+// there at runtime whenever the child did not exit by itself.
+interface UnfinishedChild {
+	exitCode?: number | undefined
+	code?: string | undefined
+	shortMessage?: string | undefined
+}
+
+// A missing working directory is reported with the same code as a missing executable, so the code
+// alone would blame pnpm for a lane directory that was removed.
+function is_pnpm_missing(result: UnfinishedChild, cwd: string | undefined): boolean {
+	return pnpm_reach.is_not_found(result) && existsSync(cwd ?? process.cwd())
+}
+
+// Why a child has no exit code: it could not be started, it ran past its bound, or a signal ended
+// it. The child cannot say so itself — in the first case there is no child — and without this a
+// check that never ran reads as a check that failed with nothing to report.
+function unfinished_reason(result: UnfinishedChild, cwd: string | undefined): Array<string> {
+	if (result.exitCode !== undefined) return []
+	const reason = [result.shortMessage ?? '']
+	if (is_pnpm_missing(result, cwd)) reason.push(pnpm_reach.NOT_ON_PATH_NOTICE)
+
+	return reason
+}
+
+// The reason follows whatever the child wrote before it stopped: a timed-out suite's last lines
+// are the evidence, and the reason is what explains them.
+function collect_output(all: string, reason: ReadonlyArray<string>): string {
+	return [all, ...reason].filter((part) => part !== '').join('\n')
+}
+
 async function run_buffered_process(
 	command_args: ReadonlyArray<string>,
 	options: BufferedProcessOptions = {},
@@ -58,7 +92,7 @@ async function run_buffered_process(
 	})
 
 	return {
-		output: result.all,
+		output: collect_output(result.all, unfinished_reason(result, options.cwd)),
 		exit_code: result.exitCode,
 		elapsed_ms: performance.now() - started_at,
 	}

package/scripts/lib/pnpm-reach.ts

@@ -0,0 +1,27 @@
+// One definition of "pnpm is not reachable from this process", for every caller that starts pnpm.
+//
+// `josh` runs its checks as `pnpm josh <check>` children, so a `pnpm` missing from the PATH this
+// process sees fails every one of them before it starts. Nothing in the child's output can say so —
+// there is no child — and the two places that can tell the user (the spawn itself and `josh doctor`)
+// have to say the same thing.
+
+const PNPM = 'pnpm'
+// What Node reports when the executable to spawn is not on PATH.
+const NOT_FOUND_CODE = 'ENOENT'
+const PREREQUISITES_URL =
+	'https://github.com/joshuafolkken/kit/blob/main/docs/setup/prerequisites.md#2-install-pnpm-and-nodejs'
+const NOT_ON_PATH_NOTICE = [
+	'pnpm was not found on the PATH this process sees, so the command could not start.',
+	'A shell opened by an editor, an agent or a service can have a different PATH from your terminal.',
+	`Install pnpm or add its directory to that PATH: ${PREREQUISITES_URL}`,
+].join('\n')
+
+// Narrowed to the one field it reads: execa's declared result type does not carry `code` on the
+// non-rejecting path, though the value is there at runtime whenever the spawn itself failed.
+function is_not_found(result: { code?: string | undefined }): boolean {
+	return result.code === NOT_FOUND_CODE
+}
+
+const pnpm_reach = { PNPM, NOT_ON_PATH_NOTICE, is_not_found }
+
+export { pnpm_reach }

package/scripts/lib/status-icons.ts

@@ -15,10 +15,14 @@
 // `✔ verification gate passed` line to tell a green gate from the third-party warning bodies it
 // forwards, so the pass icon is under the same rule as the failure icon: declared
 // once, imported by the printer and the reader alike.
+//
+// **The warning icon is read as well.** It opens the gate's `not verified` verdict — a gate that ran no
+// check — which `josh-verdict.ts` reads back, so it is declared here for the reason the other two are.
 
 const FAIL_ICON = '✗'
 const PASS_ICON = '✔'
+const WARN_ICON = '⚠'
 
-const status_icons = { FAIL_ICON, PASS_ICON }
+const status_icons = { FAIL_ICON, PASS_ICON, WARN_ICON }
 
 export { status_icons }

package/scripts/lint/lint-parallel.ts

@@ -8,6 +8,7 @@ import {
 	FAIL_EXIT_CODE,
 	type BufferedProcessResult,
 } from '#scripts/lib/buffered-process'
+import { SKIP_MARKER } from '#scripts/test/skip-marker'
 import { cross_file_recheck, type CrossFileRecheckOptions } from './cross-file-recheck'
 
 const PRETTIER_ARGS = ['exec', 'prettier', '--check', '.'] as const
@@ -67,6 +68,22 @@ async function run_checked_eslint(
 	return await run_eslint(eslint)
 }
 
+function is_silent_pass(result: BufferedProcessResult): boolean {
+	return result.output === '' && !buffered_process.is_process_failed(result)
+}
+
+// Only beside a skipped sibling (`project_checks.ran_notice`): a `lint` that skipped nothing keeps the
+// output it always had.
+function with_ran_notice(
+	check: string,
+	result: BufferedProcessResult,
+	sibling: BufferedProcessResult,
+): BufferedProcessResult {
+	if (!sibling.output.includes(SKIP_MARKER) || !is_silent_pass(result)) return result
+
+	return { ...result, output: `${project_checks.ran_notice(check)}\n` }
+}
+
 function lint_exit_code(prettier: BufferedProcessResult, eslint: BufferedProcessResult): number {
 	return buffered_process.is_process_failed(prettier) || buffered_process.is_process_failed(eslint)
 		? FAIL_EXIT_CODE
@@ -94,8 +111,8 @@ async function run_lint_checks(
 		run_checked_eslint(directory, { args: eslint_args, recheck }),
 	])
 
-	write_output(prettier)
-	write_output(eslint)
+	write_output(with_ran_notice('prettier', prettier, eslint))
+	write_output(with_ran_notice('eslint', eslint, prettier))
 
 	return lint_exit_code(prettier, eslint)
 }

package/scripts/observations/observation-ledger-home.ts

@@ -119,6 +119,7 @@ async function append(target: string, lines: ReadonlyArray<string>): Promise<voi
 
 const observation_ledger_home = {
 	append,
+	file_path,
 	issue_path,
 	ledger_date,
 	ledger_root,

package/scripts/review/review-attest-cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { issue_watch_gate } from '#scripts/issue/issue-watch-gate'
 import { review_attest, type AttestVerdict } from './review-attest'
 import { review_checkout } from './review-checkout'
 
@@ -51,6 +52,22 @@ async function run_attest(nonce: string): Promise<number> {
 	return FAILURE_EXIT_CODE
 }
 
+// An attested review still describes the issue as it read it: a person's update it has not taken in,
+// or one taken in after the brief, makes its verdict stale (`issue-watch-gate.ts`).
+async function report_issue_watch(verdict: AttestVerdict): Promise<number> {
+	const refusal = await issue_watch_gate.review_refusal_here()
+
+	if (refusal !== undefined) {
+		console.error(refusal)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	console.info(attested_line(verdict))
+
+	return 0
+}
+
 // **`check_here`, not `check`** — the pointer is keyed on the repository root, and `check`'s default
 // is `PROJECT_ROOT`, which is `process.cwd()`. Run from a subdirectory, or from the session checkout
 // rather than the lane's, the two hash different keys: no pointer is found, the command prints "no
@@ -65,15 +82,13 @@ async function run_check(): Promise<number> {
 		return 0
 	}
 
-	if (verdict.status === 'ok') {
-		console.info(attested_line(verdict))
+	if (verdict.status !== 'ok') {
+		console.error(review_attest.refusal_message(verdict))
 
-		return 0
+		return FAILURE_EXIT_CODE
 	}
 
-	console.error(review_attest.refusal_message(verdict))
-
-	return FAILURE_EXIT_CODE
+	return await report_issue_watch(verdict)
 }
 
 // Anything unrecognized is a usage error rather than a default. A misspelled flag that fell through

package/scripts/review/review-brief-cli.ts

@@ -12,7 +12,7 @@ import type { FileMapStamp } from '#scripts/josh/file-map-stamp'
 import { find_package_directory } from '#scripts/josh/josh-logic'
 import { path_decision } from '#scripts/josh/path-decision'
 import { stamp_file } from '#scripts/josh/stamp-file'
-import { openai_review_broker } from '#scripts/lane/openai-review-broker'
+import { lane_session_broker } from '#scripts/lane/lane-session-broker'
 import { run_ship_review } from '#scripts/run/ship/run-ship-review'
 import { review_attest } from './review-attest'
 import { review_brief } from './review-brief'
@@ -150,7 +150,7 @@ function record_round_one(
 // was written by the brief the pointer names: one left by an earlier brief is not the tree the
 // finished review read, so the resume reads the whole change instead.
 function attested_tree(checkout: ReviewCheckout): FileMapStamp | undefined {
-	const { findings } = openai_review_broker.review_paths(PROJECT_ROOT)
+	const { findings } = lane_session_broker.review_paths(PROJECT_ROOT)
 	const briefed = review_stamps.briefed_stamp.read()
 
 	if (briefed === undefined || !review_attest.is_briefed_since(briefed.taken_at, checkout.root)) {

package/scripts/review/review-comment-round.ts

@@ -0,0 +1,114 @@
+import { existsSync } from 'node:fs'
+import { gh_author_association } from '#scripts/gh/gh-author-association'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { parse_json, parse_json_array_safe } from '#scripts/git/parse-json-array'
+import { session_cite } from '#scripts/issue/session-cite'
+import { observation_ledger_home } from '#scripts/observations/observation-ledger-home'
+import { z } from 'zod'
+import { review_finding_ledger } from './review-finding-ledger'
+
+// A review round recorded after its pull request opened (`josh review:record --comment`), and how its
+// lines reach the ledger's readers (joshuafolkken/kit#3811). The round is posted on the issue because
+// a ledger line written then would be pushed onto the open pull request and restart its CI — and so
+// nothing that reads the ledger (`review:findings`, the retrospective) ever saw it.
+//
+// **The next run that records a round carries it.** Once an issue is closed no round is added to it,
+// so `review:record` copies each closed issue's comment rounds not yet carried into
+// `<issue>-comment-rounds.md` in the ledger, and the lines ride that run's own commit: the ledger stays
+// the one place a reader looks, and no push restarts any CI. **The file is the carried mark** — an
+// issue whose file exists is never read again, and two lanes carrying one issue write the same file,
+// so their pull requests merge to the same lines.
+
+const COMMENT_HEADING_MARK = '### '
+const COMMENT_TITLE = 'Review round recorded after the pull request opened'
+const COMMENT_HEADING = `${COMMENT_HEADING_MARK}${COMMENT_TITLE}`
+const COMMENT_NOTE =
+	'Kept here rather than in the observation ledger: a line appended after the commit would be pushed onto the open pull request and restart its CI.'
+const CODE_FENCE = '```'
+const CARRIED_SUFFIX = '-comment-rounds'
+// One page of the newest closed issues: an issue leaves the search's interest once carried, so the
+// ones still to carry are the recently closed.
+const PER_PAGE = '100'
+const UNNAMED_REPOSITORY = 'Could not name this repository from `git remote`.'
+const UNREAD_SEARCH = 'Could not read the search for closed issues with a comment round.'
+const UNREAD_COMMENTS = 'Could not read the comments of'
+
+const search_item_schema = z.object({ number: z.number() })
+const search_schema = z.object({ items: z.array(search_item_schema) })
+const comment_schema = z.object({
+	body: z.string().nullish(),
+	author_association: z.string().nullish(),
+})
+
+type IssueComment = z.infer<typeof comment_schema>
+
+function body_of(lines: ReadonlyArray<string>): string {
+	return [COMMENT_HEADING, '', COMMENT_NOTE, '', CODE_FENCE, ...lines, CODE_FENCE].join('\n')
+}
+
+// The ledger lines of every comment round among one issue's comments, oldest first; any other
+// comment, one that only quotes the heading among them, carries none — nor does one whose author
+// cannot write to the repository: anyone can comment on a public issue, and the carried lines ride
+// the run's commit unreviewed.
+function lines_of(comments: ReadonlyArray<IssueComment>): Array<string> {
+	return comments
+		.filter((comment) => gh_author_association.is_trusted(comment.author_association))
+		.map((comment) => comment.body ?? '')
+		.filter((body) => body.startsWith(COMMENT_HEADING))
+		.flatMap((body) => body.split('\n'))
+		.filter((line) => review_finding_ledger.is_finding_line(line))
+}
+
+function search_path(repo: string): string {
+	const query = `repo:${repo} is:issue is:closed in:comments "${COMMENT_TITLE}"`
+	const parameters = new URLSearchParams({ q: query, sort: 'updated', per_page: PER_PAGE })
+
+	return `search/issues?${parameters.toString()}`
+}
+
+// The closed issues whose comments name a comment round; a repository that cannot be named or a
+// search that cannot be read throws, so the run says so rather than carrying nothing in silence.
+async function closed_issues(): Promise<ReadonlyArray<number>> {
+	const repo = session_cite.session_repo()
+
+	if (repo === undefined) throw new Error(UNNAMED_REPOSITORY)
+
+	const raw = await git_gh_exec.exec_gh_api({ path: search_path(repo) })
+	const page = parse_json.parse_json_object_or_undefined(raw, search_schema)
+
+	if (page === undefined) throw new Error(UNREAD_SEARCH)
+
+	return page.items.map((item) => item.number)
+}
+
+function carried_path(issue: number, root: string): string {
+	return observation_ledger_home.file_path(`${String(issue)}${CARRIED_SUFFIX}`, root)
+}
+
+// An issue whose comments could not be read writes no file, so the next run reads it again, and
+// throws so this one says so.
+async function carry_issue(issue: number, root: string): Promise<number> {
+	const raw = await git_gh_issue_read.issue_list_comments(String(issue))
+
+	if (raw === undefined) throw new Error(`${UNREAD_COMMENTS} ${session_cite.issue(issue)}`)
+
+	const lines = lines_of(parse_json_array_safe(raw, comment_schema))
+
+	await observation_ledger_home.append(carried_path(issue, root), lines)
+
+	return lines.length
+}
+
+// Copies every closed issue's comment rounds not yet in the ledger, and answers how many lines.
+async function carry(root: string): Promise<number> {
+	const issues = await closed_issues()
+	const pending = issues.filter((issue) => !existsSync(carried_path(issue, root)))
+	const counts = await Promise.all(pending.map(async (issue) => await carry_issue(issue, root)))
+
+	return counts.reduce((total, count) => total + count, 0)
+}
+
+const review_comment_round = { body_of, carried_path, carry, lines_of }
+
+export { review_comment_round }

package/scripts/review/review-record-cli.ts

@@ -4,6 +4,7 @@ import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { observation_ledger_home } from '#scripts/observations/observation-ledger-home'
+import { review_comment_round } from './review-comment-round'
 import { review_finding_ledger, type Finding } from './review-finding-ledger'
 import { review_record, type RecordVerdict } from './review-record'
 
@@ -16,7 +17,8 @@ import { review_record, type RecordVerdict } from './review-record'
 // **`--comment` records a round that ran after the pull request opened**: the same lines go to the
 // issue as a comment and nothing is appended. A line written to the tree then has no commit of the
 // run's left to ride, so `pnpm josh followup` would push it onto the open pull request and its CI
-// would start over.
+// would start over. The next round recorded to the ledger carries it there once the issue is closed
+// (`review-comment-round.ts`).
 //
 // `josh review:record --check --issue <N>` is the read half `pnpm josh followup` runs before it
 // merges: `ok` / `not-required` exit zero, `missing` exits non-zero so the
@@ -31,10 +33,10 @@ const CHECK_USAGE = 'Usage: josh review:record --check --issue <N>'
 const RECORDED_LINE = 'Recorded: the review round for this issue is in the ledger.'
 const NOT_REQUIRED_LINE =
 	'No review-finding ledger is kept in this checkout, so there is nothing to check.'
-const COMMENT_HEADING = '### Review round recorded after the pull request opened'
-const COMMENT_NOTE =
-	'Kept here rather than in the observation ledger: a line appended after the commit would be pushed onto the open pull request and restart its CI.'
-const CODE_FENCE = '```'
+const CARRIED_LINE =
+	'review-finding line(s) recorded on closed issues after their pull requests opened into the ledger.'
+const CARRY_FAILED_LINE =
+	'Could not carry the closed issues’ comment rounds into the ledger; the next round retries:'
 const OPTIONS = {
 	issue: { type: 'string' },
 	check: { type: 'boolean' },
@@ -161,15 +163,14 @@ async function run_check(issue: string | undefined, root: string): Promise<numbe
 	return FAILURE_EXIT_CODE
 }
 
-function comment_body(lines: ReadonlyArray<string>): string {
-	return [COMMENT_HEADING, '', COMMENT_NOTE, '', CODE_FENCE, ...lines, CODE_FENCE].join('\n')
-}
-
 // **A comment that could not be posted fails the record**: it is the round's only copy, so a
 // swallowed refusal would read as a recorded round that exists nowhere.
 async function post_comment(issue: number, lines: ReadonlyArray<string>): Promise<number> {
 	try {
-		const url = await git_gh_issue_write.issue_comment(String(issue), comment_body(lines))
+		const url = await git_gh_issue_write.issue_comment(
+			String(issue),
+			review_comment_round.body_of(lines),
+		)
 
 		console.info(`Recorded ${String(lines.length)} review-finding line(s) in ${url.trim()}.`)
 
@@ -181,8 +182,35 @@ async function post_comment(issue: number, lines: ReadonlyArray<string>): Promis
 	}
 }
 
+// The closed issues' comment rounds ride this round's commit (`review-comment-round.ts`). **A carry
+// that fails never fails the record**: this round is recorded, and the comment rounds wait for the
+// next run's.
+async function carry_comment_rounds(root: string): Promise<void> {
+	try {
+		const count = await review_comment_round.carry(root)
+
+		if (count > 0) console.info(`Carried ${String(count)} ${CARRIED_LINE}`)
+	} catch (error) {
+		console.warn(`${CARRY_FAILED_LINE} ${error instanceof Error ? error.message : String(error)}`)
+	}
+}
+
 // The round lands in its own issue's file, so two lanes recording at once
 // write two files, and their pull requests never conflict on the ledger.
+async function append_round(
+	issue: number,
+	lines: ReadonlyArray<string>,
+	root: string,
+): Promise<number> {
+	const ledger_path = observation_ledger_home.issue_path(issue, root)
+
+	await observation_ledger_home.append(ledger_path, lines)
+	console.info(confirmation(lines.length, ledger_path))
+	await carry_comment_rounds(root)
+
+	return 0
+}
+
 async function run_record(parsed: Parsed, now: Date, root: string): Promise<number> {
 	const request = to_request(parsed)
 
@@ -196,12 +224,7 @@ async function run_record(parsed: Parsed, now: Date, root: string): Promise<numb
 
 	if (parsed.comment) return await post_comment(request.issue, lines)
 
-	const ledger_path = observation_ledger_home.issue_path(request.issue, root)
-
-	await observation_ledger_home.append(ledger_path, lines)
-	console.info(confirmation(lines.length, ledger_path))
-
-	return 0
+	return await append_round(request.issue, lines, root)
 }
 
 // **The default is the work tree the command runs in, a lane's inside a lane**.
@@ -232,7 +255,6 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 const review_record_cli = {
 	accepted_values,
 	build_lines,
-	comment_body,
 	parse_finding,
 	run,
 	usage_text,

package/scripts/rules/implementation-cut.ts

@@ -176,9 +176,9 @@ const IMPLEMENTATION_CUT_REASON =
 	'because the verdict was only ever read at session entry, where the context has not yet grown. The ' +
 	"verdict is `pnpm josh cost --cut`'s exactly — the same per-request billed-input statistic against the " +
 	'same threshold, never a second measurement. Issue `pnpm josh run:cut --impl <N> --handoff <path>` now and read the ' +
-	'verdict: on `cut`, **end the turn immediately** — in a lane the fresh process owns the run and ' +
-	'continues implementing, so it must not be waited for; outside a lane nothing is relaunched, so first ' +
-	'send the `confirmation` Telegram naming the resume command `fullrun #<N>` and keep the hold; on `not-a-lane`, `unready`, `busy`, `failed` or ' +
+	'verdict: on `cut`, read what the command printed. Where it relaunched a fresh process, **end the turn ' +
+	'immediately** — that process owns the run and continues implementing, so it must not be waited for, ' +
+	'and **no Telegram is owed**: a cut that resumes itself leaves a person nothing to act on. Where it printed that nothing was relaunched, do what it prints, then end the turn; on `not-a-lane`, `unready`, `busy`, `failed` or ' +
 	'`unknown`, this process carries the run on and the edit is simply the next call. Never relaunch a ' +
 	'second process after `busy`. This fired because the dispatch mark names this lane or the run hold ' +
 	'names this issue; a person working here carries no mark and holds no run, so sees no refusal, so there is no human-or-child judgement left to make. The ' +

package/scripts/rules/pre-gate-cut.ts

@@ -172,7 +172,7 @@ const PRE_GATE_CUT_REASON =
 	'176K of 204K output riding across that boundary, and joshuafolkken/kit#1864 measured the step ' +
 	'itself firing 0 times in 6 lane children while it was carried as prose. Issue ' +
 	'`pnpm josh run:cut <N>` now, and read the verdict: on `cut`, **end the turn immediately** — the ' +
-	'fresh process owns the run from there and must not be waited for; on `not-a-lane`, `unready`, ' +
+	'fresh process owns the run from there and must not be waited for, and **no Telegram is owed** for a cut that resumes itself; on `not-a-lane`, `unready`, ' +
 	'`busy`, `failed` or `unknown`, this process carries the run on and the gate is simply the next ' +
 	'call. Never relaunch a second process after `busy`. This fired because the dispatch mark names ' +
 	'this lane; a person working here carries no mark and sees no refusal, so there is no ' +

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

@@ -0,0 +1,42 @@
+import { run_event_checks, type PrChecks } from '#scripts/run/event/run-event-checks'
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+
+// Each child's newest `pr-checks` line — its pull request's CI counts and CodeRabbit's state as
+// `josh followup` last polled them (joshuafolkken/kit#3770). Read from the stream alone, so a redraw
+// asks GitHub nothing.
+
+interface HeldChecks {
+	checks: PrChecks
+	at_ms: number
+}
+
+const { PR_CHECKS } = run_event_stream.EVENT_KIND
+
+function held_of(event: RunEvent): HeldChecks | undefined {
+	const checks = event.kind === PR_CHECKS ? run_event_checks.checks_of(event.text) : undefined
+
+	return checks === undefined ? undefined : { checks, at_ms: Date.parse(event.at) }
+}
+
+// The stream's bound reorders its lines, so the newest is the latest `at`, not the last line.
+function is_newer(held: HeldChecks, current: HeldChecks | undefined): boolean {
+	return current === undefined || held.at_ms >= current.at_ms
+}
+
+function newest_of(events: ReadonlyArray<RunEvent>): ReadonlyMap<number, PrChecks> {
+	const newest = new Map<number, HeldChecks>()
+
+	for (const event of events) {
+		const held = held_of(event)
+		const issue = Number(run_event_scope.issue_named(event))
+
+		if (held !== undefined && is_newer(held, newest.get(issue))) newest.set(issue, held)
+	}
+
+	return new Map([...newest].map(([issue, held]) => [issue, held.checks]))
+}
+
+const run_board_checks = { newest_of }
+
+export { run_board_checks }

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

@@ -15,6 +15,7 @@ import { run_board_read } from './run-board-read'
 import { run_board_screen, type Screen } from './run-board-screen'
 import { run_board_spin } from './run-board-spin'
 import type { BoardPorts } from './run-board-state'
+import { run_board_thanks_read } from './run-board-thanks-read'
 import { run_board_tick } from './run-board-tick'
 import { run_board_usage_read } from './run-board-usage-read'
 
@@ -52,6 +53,7 @@ const LIVE_PORTS: BoardPorts = {
 	read_machine: machine_capacity.read_sample,
 	read_usage: run_board_usage_read.usage_reader(),
 	read_closed: async (issues) => await run_board_closed.read_all(issues),
+	read_thanks: async () => await run_board_thanks_read.read_thanks(),
 	now: () => Date.now(),
 	write: (frame) => process.stdout.write(frame),
 	// No fallback: a terminal that opens no link, or a pipe, gets the bare number rather than a URL.

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

@@ -15,7 +15,8 @@ interface ChatFrame {
 	local: LocalRead | undefined
 }
 
-// One frame in the chat's form, with every escape stripped because a chat shows them as text.
+// One frame in the chat's form, with every escape stripped because a chat shows them as text. The
+// reviewers are thanked on the terminal's board alone, so the chat reads no roster.
 async function chat_frame(ports: BoardPorts): Promise<ChatFrame> {
 	let text = ''
 	const chat_ports: BoardPorts = {
@@ -23,6 +24,7 @@ async function chat_frame(ports: BoardPorts): Promise<ChatFrame> {
 		is_tty: false,
 		size: undefined,
 		form: 'chat',
+		read_thanks: undefined,
 		write: (frame) => {
 			text += stripVTControlCharacters(frame)
 		},

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

@@ -5,14 +5,17 @@ import { run_board_labels } from './run-board-labels'
 // A live `run:board` frame kept within the terminal. A frame taller than the pane scrolls the
 // alternate screen as it is written, and the header — the lines that say whether the run moves and
 // how far it is — is what scrolls off. So the parts below it give way instead, least wanted first:
-// the footer, the legend, the finished rows, the notes, the rows not yet started, the parked rows
-// and, last, the running rows — what a person keeps the board open to see. Each stage stops once the
+// the footer, the legend, the oldest notes until three are left, the finished rows, the rest of the
+// notes, the reviewers thanked above the legend, the rows not yet started, the parked rows and, last,
+// the running rows — what a person keeps the board open to see. Each stage stops once the
 // frame fits, a cut row is counted on its section's `more N` line, and the order a row is drawn in
 // never changes. A line wider than the pane wraps, so every line is counted by the rows it takes on
 // screen, not as one.
 
 const { WORDS } = run_board_labels
 const INDENT = '  '
+// The newest notes kept until the finished rows are gone; the older ones give way before them.
+const NOTES_KEPT = 3
 
 interface TerminalSize {
 	rows: number
@@ -52,21 +55,24 @@ interface FrameParts {
 	above: ReadonlyArray<string>
 	plan: ReadonlyArray<PlanSection>
 	notes: NotesPart
+	// The reviewers thanked, drawn right above the legend; none where nobody is.
+	thanks?: ReadonlyArray<string> | undefined
 	legend: ReadonlyArray<string>
 	footer: ReadonlyArray<string>
 }
 
 // One thing that gives way: a part as a whole, one note (the oldest shown), or one issue row.
-type Yielder = 'footer' | 'legend' | 'note' | PlanLine
+type Yielder = 'thanks' | 'footer' | 'legend' | 'note' | PlanLine
 
 interface Cut {
+	thanks: boolean
 	footer: boolean
 	legend: boolean
 	notes: number
 	rows: ReadonlySet<PlanLine>
 }
 
-const NO_CUT: Cut = { footer: false, legend: false, notes: 0, rows: new Set() }
+const NO_CUT: Cut = { thanks: false, footer: false, legend: false, notes: 0, rows: new Set() }
 
 // The columns a line takes on screen: its color escapes take none, an emoji two.
 function width_of(line: string): number {
@@ -117,6 +123,7 @@ function compose(parts: FrameParts, cut: Cut): Array<string> {
 		...parts.above,
 		...plan_lines(parts.plan, cut.rows),
 		...notes_lines(parts.notes, cut.notes),
+		...(cut.thanks ? [] : (parts.thanks ?? [])),
 		...(cut.legend ? [] : parts.legend),
 		...(cut.footer ? [] : parts.footer),
 	]
@@ -154,12 +161,15 @@ function order_of(parts: FrameParts): Array<Yielder> {
 		.map((line, index) => ({ line, index }))
 		.filter((entry) => entry.line.row !== undefined)
 	const notes = parts.notes.lines.map((): Yielder => 'note')
+	const surplus = Math.max(0, notes.length - NOTES_KEPT)
 
 	return [
 		'footer',
 		'legend',
+		...notes.slice(0, surplus),
 		...yielding(rows, 'finished'),
-		...notes,
+		...notes.slice(surplus),
+		'thanks',
 		...yielding(rows, 'pending'),
 		...yielding(rows, 'parked'),
 		...yielding(rows, 'running'),
@@ -175,6 +185,7 @@ function cut_of(order: ReadonlyArray<Yielder>, count: number): Cut {
 	const gone = order.slice(0, count)
 
 	return {
+		thanks: gone.includes('thanks'),
 		footer: gone.includes('footer'),
 		legend: gone.includes('legend'),
 		notes: gone.filter((item) => item === 'note').length,