@joshuafolkken/kit 1.1383.0 → 1.1435.0

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

@@ -1,13 +1,13 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
 import { cost_cli } from '#scripts/cost-runtime/cost-cli'
 import { cost_verdict } from '#scripts/cost-runtime/cost-verdict'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
-import { run_merge_collect } from '#scripts/run/merge/run-merge-collect'
 import { run_cli_fault } from '#scripts/run/run-cli-fault'
 import { run_headless } from '#scripts/run/run-headless'
-import { run_stop_notify } from '#scripts/run/run-stop-notify'
 import {
 	run_carry,
 	type CarryClaim,
@@ -17,8 +17,7 @@ import {
 } from './run-carry'
 import { run_carry_args, type CountRequest, type Request } from './run-carry-args'
 import { run_carry_conversation } from './run-carry-conversation'
-import { run_carry_ended } from './run-carry-ended'
-import { run_carry_stash } from './run-carry-stash'
+import { run_carry_end } from './run-carry-end'
 
 // `josh run:carry` — the record that carries one invocation's budget across its own session cuts.
 // A `backlogrun` begins it, counts a merge and a filing into it, marks each
@@ -151,25 +150,47 @@ function report_claim(
 	return report(CLAIM_VERDICTS[claim], carry, is_json, FAILURE_EXIT_CODE)
 }
 
-function start_fresh(target: string, request: CarryClaimRequest, is_json: boolean): number {
-	const carry = run_carry.begin_carry(target, request.invocation, request.owner)
+// When the run began: the moment `josh backlogrun` launched this owner, so the clock `run:board` was
+// already counting from does not restart at the claim; `undefined` — now — for every other run.
+async function launch_start(request: CarryClaimRequest): Promise<Date | undefined> {
+	const directory = await run_carry.repository_directory()
+
+	if (directory === undefined) return undefined
+
+	return backlogrun_launch.started_for(directory, request.owner.pid)
+}
+
+// A run that began is planning, which is what its board says until the supervisor takes it over.
+async function start_fresh(
+	target: string,
+	request: CarryClaimRequest,
+	is_json: boolean,
+): Promise<number> {
+	const started = await launch_start(request)
+	const carry = run_carry.begin_carry(target, request.invocation, request.owner, started)
 
 	if (carry === undefined) return report_lost(is_json)
 
+	await run_event_setup.emit(run_event_setup.STAGE.PLANNING)
+
 	return report_carry(BEGAN_VERDICT, carry, is_json)
 }
 
 // **A standing record is never replaced, and never resumed into by something else.** Replacing one
 // would restart the budget the cut exists to carry, and resuming into one would put two parents on a
 // single budget. Its age changes none of that: a record is replaced by nothing but a person's `--end`.
-function begin(target: string, request: CarryClaimRequest, is_json: boolean): number {
+async function begin(
+	target: string,
+	request: CarryClaimRequest,
+	is_json: boolean,
+): Promise<number> {
 	const read = run_carry.read_carry(target)
 
 	if (read.kind === 'unreadable') return report_unreadable(is_json)
 
 	if (read.kind === 'carried') return report_claim(target, read.carry, request, is_json)
 
-	return start_fresh(target, request, is_json)
+	return await start_fresh(target, request, is_json)
 }
 
 function report_nothing_to_resume(is_json: boolean): number {
@@ -203,10 +224,16 @@ function report_over(is_json: boolean): number {
 	return report(OVER_VERDICT, undefined, is_json, FAILURE_EXIT_CODE)
 }
 
-function claim_record(target: string, request: CarryClaimRequest, is_json: boolean): number {
+async function claim_record(
+	target: string,
+	request: CarryClaimRequest,
+	is_json: boolean,
+): Promise<number> {
 	if (cost_cli.session_verdict() === cost_verdict.OVER_VERDICT) return report_over(is_json)
 
-	return request.is_adoption ? adopt(target, request, is_json) : begin(target, request, is_json)
+	if (request.is_adoption) return adopt(target, request, is_json)
+
+	return await begin(target, request, is_json)
 }
 
 // The record is no longer this session's to advance — handed off at a cut, or taken over by a live
@@ -286,52 +313,12 @@ async function count(
 	return report_carry(COUNTED_VERDICT, carry, is_json)
 }
 
-// **A stop over a record that is still there pushes one ⏸️ confirmation before the record goes**.
-// `plan` is read from the record `--end` is about to remove, so the second `--end` reads `none` and
-// plans nothing — one stop never notifies twice. A clean `--end` passes no reason and stays silent,
-// because a completed run has its own notification. The closed-issue stash report
-// (`run-carry-stash.ts`) is once per invocation on the same read.
-async function report_end(read: CarryRead): Promise<void> {
-	if (read.kind === 'none') return
-
-	await run_carry_stash.report_orphans()
-}
-
-// Best-effort: the board's record of the ended run never stands between `--end` and the carry record it
-// clears, so a failed write goes to stderr rather than leaving the run carried.
-function keep_ended(directory: string, read: CarryRead, stopped: string | undefined): void {
-	try {
-		run_carry_ended.record_ended(run_carry_ended.ended_path(directory), read, new Date(), stopped)
-	} catch (error) {
-		console.error(`run:carry: the ended run was not recorded for run:board: ${String(error)}`)
-	}
-}
-
-// The record goes, and the run it held stays readable as the last ended run, so `run:board` keeps the
-// finished run on screen until the next one begins — a stopped one with the session to resume it from.
-function close_record(directory: string, stopped: string | undefined): CarryRead {
-	const target = run_carry.carry_path(directory)
-	const read = run_carry.read_carry(target)
-
-	keep_ended(directory, read, stopped)
-	run_carry.end_carry(target)
-
-	return read
-}
-
-// The merges the run ended with are recorded while its record can still count them.
 async function finish(
 	directory: string,
 	stopped: string | undefined,
 	is_json: boolean,
 ): Promise<number> {
-	await run_merge_collect.collect_merged(directory)
-	const read = close_record(directory, stopped)
-	const notice = run_stop_notify.plan(read, stopped)
-
-	if (notice !== undefined) await run_stop_notify.announce(notice)
-
-	await report_end(read)
+	const read = await run_carry_end.end_run(directory, { stopped, is_announced: true })
 
 	if (read.kind === 'none') return report(NONE_VERDICT, undefined, is_json, SUCCESS_EXIT_CODE)
 
@@ -347,7 +334,7 @@ async function act(
 	request: Exclude<Request, { kind: 'end' }>,
 	is_json: boolean,
 ): Promise<number> {
-	if (request.kind === 'claim') return claim_record(target, request.claim, is_json)
+	if (request.kind === 'claim') return await claim_record(target, request.claim, is_json)
 
 	const read = run_carry.read_carry(target)
 

package/scripts/run/carry/run-carry-end.ts

@@ -0,0 +1,73 @@
+import { run_merge_collect } from '#scripts/run/merge/run-merge-collect'
+import { run_stop_notify } from '#scripts/run/run-stop-notify'
+import { run_carry, type CarryRead } from './run-carry'
+import { run_carry_ended } from './run-carry-ended'
+import { run_carry_stash } from './run-carry-stash'
+
+// Ending a run's record, apart from the command that prints the verdict: `run:carry --end` and
+// `josh backlogrun --stop` both end it here, so the one end is never written twice.
+
+interface EndRequest {
+	// Why the run stopped; `undefined` is a clean finish.
+	stopped: string | undefined
+	// Whether a stop pushes its ⏸️ confirmation. A person who typed the stop is already at the terminal.
+	is_announced: boolean
+}
+
+// **A stop over a record that is still there pushes one ⏸️ confirmation before the record goes**.
+// `plan` is read from the record the end is about to remove, so the second end reads `none` and
+// plans nothing — one stop never notifies twice. A clean end passes no reason and stays silent,
+// because a completed run has its own notification.
+async function announce_stop(read: CarryRead, request: EndRequest): Promise<void> {
+	if (!request.is_announced) return
+
+	const notice = run_stop_notify.plan(read, request.stopped)
+
+	if (notice !== undefined) await run_stop_notify.announce(notice)
+}
+
+// The closed-issue stash report (`run-carry-stash.ts`) is once per invocation on the same read.
+async function report_end(read: CarryRead): Promise<void> {
+	if (read.kind === 'none') return
+
+	await run_carry_stash.report_orphans()
+}
+
+// Best-effort: the board's record of the ended run never stands between the end and the carry record it
+// clears, so a failed write goes to stderr rather than leaving the run carried.
+function keep_ended(directory: string, read: CarryRead, stopped: string | undefined): void {
+	try {
+		run_carry_ended.record_ended(run_carry_ended.ended_path(directory), read, new Date(), stopped)
+	} catch (error) {
+		console.error(`run:carry: the ended run was not recorded for run:board: ${String(error)}`)
+	}
+}
+
+// The record goes, and the run it held stays readable as the last ended run, so `run:board` keeps the
+// finished run on screen until the next one begins — a stopped one with the session to resume it from.
+function close_record(directory: string, stopped: string | undefined): CarryRead {
+	const target = run_carry.carry_path(directory)
+	const read = run_carry.read_carry(target)
+
+	keep_ended(directory, read, stopped)
+	run_carry.end_carry(target)
+
+	return read
+}
+
+// The merges the run ended with are recorded while its record can still count them. The read handed
+// back is the record as it stood before it was removed.
+async function end_run(directory: string, request: EndRequest): Promise<CarryRead> {
+	await run_merge_collect.collect_merged(directory)
+	const read = close_record(directory, request.stopped)
+
+	await announce_stop(read, request)
+	await report_end(read)
+
+	return read
+}
+
+const run_carry_end = { end_run }
+
+export type { EndRequest }
+export { run_carry_end }

package/scripts/run/carry/run-carry-ended.ts

@@ -79,7 +79,15 @@ function read_ended(target: string): EndedRun | undefined {
 	return raw === undefined ? undefined : parse_ended(raw)
 }
 
-const run_carry_ended = { ended_path, read_ended, record_ended }
+// Whether the run that began at `started_at` is the one `--end` last ended — what tells a record that is
+// gone because its run ended from one that only failed to read.
+function has_ended(target: string, started_at: string | undefined): boolean {
+	const ended = read_ended(target)
+
+	return ended !== undefined && ended.started_at === started_at
+}
+
+const run_carry_ended = { ended_path, has_ended, read_ended, record_ended }
 
 export { run_carry_ended }
 export type { EndedRun }

package/scripts/run/carry/run-carry.ts

@@ -102,6 +102,9 @@ interface RunCarry {
 	// The owner conversation's transcript, which outlives a restart of its process
 	// (`run-carry-conversation.ts`). Optional for the same reason as the pid.
 	owner_transcript?: string | undefined
+	// The owner is a session the run launched headless (`run-headless.ts`), so nobody can end the run
+	// from it. Kept here, beside the owner it describes, so it outlives the supervisor's own record.
+	is_owner_headless?: boolean | undefined
 	// Set by `--cut`, and by nothing else. A crash never reaches `--cut`, which is what makes a
 	// declared cut the only standing record carried without a person deciding.
 	is_handed_off?: boolean | undefined
@@ -138,6 +141,7 @@ interface CarryOwner {
 	pid?: number | undefined
 	start?: string | undefined
 	transcript?: string | undefined
+	is_headless?: boolean | undefined
 }
 
 // **`resume` is the only one of the four that establishes anything.** The other three are refusals,
@@ -199,6 +203,7 @@ const run_carry_schema = z.object({
 	owner_pid: z.number().optional(),
 	owner_start: z.string().optional(),
 	owner_transcript: z.string().optional(),
+	is_owner_headless: z.boolean().optional(),
 	is_handed_off: z.boolean().optional(),
 	done: z.array(z.number()).optional(),
 	retrospective: z.boolean().optional(),
@@ -265,6 +270,7 @@ function fresh_carry(invocation: string, owner: CarryOwner, now: Date): RunCarry
 		owner_pid: owner.pid,
 		owner_start: owner.start,
 		owner_transcript: owner.transcript,
+		is_owner_headless: owner.is_headless,
 	}
 }
 
@@ -297,7 +303,7 @@ function adopt_carry(
 	owner: CarryOwner = NO_OWNER,
 ): RunCarry | undefined {
 	// The run's own fields carry across untouched — the counters, the outage fold timestamp, `done` so the successor does not re-run what the cut session finished,
-	// and `retrospective` so a run resumed after a cut does not repeat its retrospective. Only the three
+	// and `retrospective` so a run resumed after a cut does not repeat its retrospective. Only the
 	// ownership fields are overridden: the new owner replaces the old — a caller that declared none
 	// writes `undefined`, so the previous owner cannot survive — and the declared hand-off is spent.
 	const next: RunCarry = {
@@ -305,6 +311,7 @@ function adopt_carry(
 		owner_pid: owner.pid,
 		owner_start: owner.start,
 		owner_transcript: owner.transcript,
+		is_owner_headless: owner.is_headless,
 		is_handed_off: false,
 	}
 
@@ -336,6 +343,21 @@ function is_foreign_live_owner(carry: RunCarry, owner: CarryOwner): boolean {
 	return is_owner_live(carry) && !is_owned_by(carry, owner)
 }
 
+// Whether a process other than the caller still holds the record. **By process alone, never by
+// conversation**: the wake supervisor inherits the environment of the session that started it, so a
+// conversation match would read that live session's record as the supervisor's own. The driver adopts
+// the record for the supervisor's process (`run-wake-driver.ts` → `claim_record`), so without this a
+// supervisor reads itself as a session at work.
+function is_held_by_another(
+	carry: RunCarry,
+	is_live: (carry: RunCarry) => boolean = is_owner_live,
+): boolean {
+	const caller = owner_of(process.pid)
+	const is_own = carry.owner_pid === caller.pid && carry.owner_start === caller.start
+
+	return !is_own && is_live(carry)
+}
+
 function is_handed_off_to(carry: RunCarry, invocation: string): boolean {
 	return carry.is_handed_off === true && carry.invocation === invocation
 }
@@ -504,6 +526,7 @@ const run_carry = {
 	fresh_carry,
 	is_count_refused,
 	is_foreign_live_owner,
+	is_held_by_another,
 	is_owner_live,
 	lost_message,
 	nothing_to_resume_message,

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

@@ -1,6 +1,7 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { issue_watch } from '#scripts/issue/issue-watch'
 import { session_cite } from '#scripts/issue/session-cite'
 import { josh_command } from '#scripts/josh/josh-run'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
@@ -254,6 +255,10 @@ async function proceed(issue_number: string, hold: string, cost: string): Promis
 	await run_label.mark(issue_number)
 	const reads = await gather_reads(issue_number)
 
+	// The issue the report prints is the one the run has read, so it is the baseline a person's later
+	// update is measured against (`issue-watch.ts`).
+	await issue_watch.record_baseline_here(issue_number)
+
 	return emit({ issue_number, hold, cost, verdict: reads.verdict, report: reads.report })
 }
 

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

@@ -0,0 +1,54 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+
+// The words of a `pr-checks` event (joshuafolkken/kit#3770): `josh followup` writes them and `run:board`
+// reads them back, so the one spelling lives here. A line reads
+// `#3754 PR 3765 pass 6 pending 2 fail 0 coderabbit running` — the issue first, as every event names
+// it, so the stream's readers key it to the child as they key any other.
+
+const CODERABBIT_STATES = ['running', 'done', 'rate-limited', 'failed', 'none'] as const
+
+type CodeRabbitState = (typeof CODERABBIT_STATES)[number]
+
+interface PrChecks {
+	pr: number
+	pass: number
+	pending: number
+	fail: number
+	coderabbit: CodeRabbitState
+}
+
+const CHECKS_PATTERN =
+	/^#\d+ PR (?<pr>\d+) pass (?<pass>\d+) pending (?<pending>\d+) fail (?<fail>\d+) coderabbit (?<coderabbit>\S+)$/u
+
+function text_of(issue: string, checks: PrChecks): string {
+	const { pr, pass, pending, fail, coderabbit } = checks
+
+	return `${issue_cite.plain(issue)} PR ${String(pr)} pass ${String(pass)} pending ${String(pending)} fail ${String(fail)} coderabbit ${coderabbit}`
+}
+
+const STATE_NAMES: ReadonlySet<string> = new Set(CODERABBIT_STATES)
+
+function is_coderabbit_state(value = ''): value is CodeRabbitState {
+	return STATE_NAMES.has(value)
+}
+
+// The checks a line carries, `undefined` for a line written in some other shape.
+function checks_of(text: string): PrChecks | undefined {
+	const groups = CHECKS_PATTERN.exec(text)?.groups
+	const coderabbit = groups?.['coderabbit']
+
+	if (groups === undefined || !is_coderabbit_state(coderabbit)) return undefined
+
+	return {
+		pr: Number(groups['pr']),
+		pass: Number(groups['pass']),
+		pending: Number(groups['pending']),
+		fail: Number(groups['fail']),
+		coderabbit,
+	}
+}
+
+const run_event_checks = { checks_of, text_of }
+
+export { run_event_checks }
+export type { CodeRabbitState, PrChecks }

package/scripts/run/event/run-event-render.ts

@@ -28,6 +28,7 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	outage: { ja: '障害', en: 'outage' },
 	cut: { ja: 'セッション交代', en: 'session cut' },
 	resume: { ja: '実装を再開', en: 'implementation resumed' },
+	restart: { ja: '止めて出し直し', en: 'restarted' },
 	drain: { ja: 'バックログが空', en: 'backlog drained' },
 	stop: { ja: '停止', en: 'stopped' },
 	'pr-opened': { ja: 'PR 作成', en: 'PR opened' },
@@ -44,6 +45,8 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	'lane-phase': { ja: 'レーンの段階', en: 'lane phase' },
 	add: { ja: '割り込み', en: 'added' },
 	'lane-limit': { ja: 'レーン上限', en: 'lane limit' },
+	setup: { ja: '準備', en: 'setup' },
+	'pr-checks': { ja: 'PR のチェック', en: 'PR checks' },
 }
 
 const LABELS_BY_KIND: ReadonlyMap<string, KindLabel> = new Map(Object.entries(KIND_LABELS))

package/scripts/run/event/run-event-scope.ts

@@ -93,6 +93,7 @@ const KIND = run_event_stream.EVENT_KIND
 // so a lane child never reads one as its own.
 const BATCH_RECORD_KINDS: ReadonlySet<string> = new Set([
 	KIND.CHILD_LAUNCH,
+	KIND.RESTART,
 	KIND.PARK,
 	KIND.SPLIT,
 	KIND.RETROSPECTIVE,

package/scripts/run/event/run-event-setup.ts

@@ -0,0 +1,91 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { error_text } from '#scripts/lib/error-message'
+import { run_event_stream } from './run-event-stream'
+import { run_event_stream_emit } from './run-event-stream-emit'
+
+// The stages a run passes between `josh backlogrun` and its first child, and those of a later hand-back
+// to a session, each written to the stream as one `setup` event by the step that enters it. **The text
+// is the stage's own words**: `run:board` draws it as written, so the message a person reads and the
+// `💓` beside it come from one event and cannot disagree. Only the stages of a lane's launch — opening
+// it, installing into it, dispatching its child — name an issue, which is how a reader tells them from
+// the stages before them.
+
+const STAGE = {
+	// `josh backlogrun` started the parent session, which is reading its procedure.
+	STARTING: 'starting session',
+	// `run:carry --begin` claimed the run, and the parent is planning it.
+	PLANNING: 'planning',
+	// The supervisor took the run over from the parent and is asking for the first offer.
+	HANDING_OFF: 'handing off',
+	// The driver answered something only a session can act on — an untriaged child, an epic left to a
+	// person — and the supervisor is waking one. The next hand-off replaces it.
+	JUDGING: 'waiting on judgment',
+	// The supervisor started that session, which is now acting on the driver's answer. It is detached, so
+	// its end is the supervisor's next hand-off, which replaces this.
+	SESSION: 'judgment session running',
+	// The driver's launch of a lane returned without a child: no lane was free to open, or a step after
+	// the open failed. It names no issue, so the lane's own stage ends here whatever the driver does next.
+	NO_CHILD: 'no child launched',
+} as const
+
+const OPENING = 'opening lane'
+const INSTALLING = 'installing dependencies'
+const DISPATCHING = 'dispatching'
+// The stages of one lane's launch, in the order a lane passes them.
+const LANE_STAGE = { OPENING, INSTALLING, DISPATCHING } as const
+
+// The driver is about to open a lane for `issue` — for every child, not only the first.
+function opening_lane(issue: string): string {
+	return `${OPENING} ${issue_cite.plain(issue)}`
+}
+
+// The lane's work tree exists and its dependencies are about to be installed into it.
+function installing(issue: string): string {
+	return `${INSTALLING} ${issue_cite.plain(issue)}`
+}
+
+// The lane is ready and its child is about to be dispatched; the child's own `child-launch` follows.
+function dispatching(issue: string): string {
+	return `${DISPATCHING} ${issue_cite.plain(issue)}`
+}
+
+// Best-effort, as every append to this stream is: a stage that could not be written is a board that
+// says less, never a run that failed.
+async function emit(text: string): Promise<void> {
+	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SETUP, text)
+}
+
+// The same append to a stream the caller resolves, dated the moment it hands over.
+function append_stage(resolve_target: () => string, text: string, at: Date): void {
+	try {
+		const { SETUP } = run_event_stream.EVENT_KIND
+
+		run_event_stream.append(resolve_target(), SETUP, text, at.toISOString())
+	} catch (error) {
+		error_text.trace_swallowed('run_event_setup.append_stage', error)
+	}
+}
+
+// For a caller that already holds the repository's common git directory and the moment it wants the
+// stage dated — the launcher, whose record and first stage carry one time.
+function emit_in(repository: string, text: string, at: Date): void {
+	append_stage(() => run_event_stream.target_of(repository), text, at)
+}
+
+// For a caller that already holds the stream's own path — the supervisor, which resolved it once.
+function emit_to(target: string, text: string, at: Date): void {
+	append_stage(() => target, text, at)
+}
+
+const run_event_setup = {
+	LANE_STAGE,
+	STAGE,
+	dispatching,
+	emit,
+	emit_in,
+	emit_to,
+	installing,
+	opening_lane,
+}
+
+export { run_event_setup }

package/scripts/run/event/run-event-stream.ts

@@ -60,6 +60,10 @@ const EVENT_KIND = {
 	// resume clears the cut record, so without this the `cut` would stay the newest position and
 	// `run:step` would keep answering the resume command it had just run.
 	RESUME: 'resume',
+	// A person stopped a running lane child and re-dispatched its issue in a fresh session
+	// (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
+	// the board, and — like that launch — a batch record a lane child never reads as its own position.
+	RESTART: 'restart',
 	// The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
 	// at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
 	// the retrospective at the drain rather than after the watch runs its course. It is not itself a
@@ -83,7 +87,8 @@ const EVENT_KIND = {
 	// stalled is pointed straight at dispatching the work rather than left waiting.
 	STALL: 'stall',
 	// The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
-	// is watching. Emitted once per strand episode by the stop-time detector,
+	// is watching. Emitted once per strand episode by the stop-time detector — or by the `run:wake`
+	// supervisor as it fails, leaves that state behind and has warned of it —
 	// exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
 	// than once, and a terminal reader following the stream sees the line. The strand is the step before
 	// the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
@@ -124,6 +129,16 @@ const EVENT_KIND = {
 	// arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
 	// already holds. A trace: it says the run gained room, not where the run is.
 	LANE_LIMIT: 'lane-limit',
+	// One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
+	// lane opening (`run-event-setup.ts`). `run:board` draws it while the run stands at it, so the
+	// minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
+	// getting ready, not where the run is.
+	SETUP: 'setup',
+	// A child's pull request checks as `josh followup` last polled them — the CI counts and CodeRabbit's
+	// state (`run-event-checks.ts`), written only when they change, so `run:board` draws a child waiting
+	// in followup without asking GitHub (joshuafolkken/kit#3770). A trace: it says how the checks stand,
+	// not where the run is.
+	PR_CHECKS: 'pr-checks',
 } as const
 
 type EventKind = (typeof EVENT_KIND)[keyof typeof EVENT_KIND]
@@ -141,13 +156,21 @@ const TRACE_KINDS: ReadonlySet<string> = new Set([
 	EVENT_KIND.LANE_PHASE,
 	EVENT_KIND.ADD,
 	EVENT_KIND.LANE_LIMIT,
+	EVENT_KIND.SETUP,
+	EVENT_KIND.PR_CHECKS,
 ])
 
 // The trace kinds that say only that the run was alive, so the bound rolls them off first. A `filed` or
 // `note` line is a trace to the position readers but is the board's record of what the run found, so
 // it rolls off only with the positions. A ship-stage `start` is disposable but goes last of them:
-// `run:board` draws from that line.
-const DISPOSABLE_KINDS: ReadonlySet<string> = new Set([EVENT_KIND.SHIP_STAGE, EVENT_KIND.HEARTBEAT])
+// `run:board` draws from that line. Only the newest `setup` line is the stage the run stands at,
+// so every one but the newest goes; likewise only each child's newest `pr-checks` is drawn.
+const DISPOSABLE_KINDS: ReadonlySet<string> = new Set([
+	EVENT_KIND.SHIP_STAGE,
+	EVENT_KIND.HEARTBEAT,
+	EVENT_KIND.SETUP,
+	EVENT_KIND.PR_CHECKS,
+])
 
 const event_schema = z.object({
 	pos: z.number(),
@@ -217,17 +240,18 @@ function last_position(events: ReadonlyArray<RunEvent>): number {
 	return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION
 }
 
-// The issue a ship-stage names — `#<N> <stage> <phase>` carries it first.
+// The issue a ship-stage or a `pr-checks` line names — `#<N> …` carries it first.
 function issue_of(event: RunEvent): string {
 	return event.text.split(WORD_SEPARATOR)[FIRST_POSITION] ?? ''
 }
 
-// Each issue's newest ship-stage, the one the board reads its furthest phase from.
-function newest_stages(events: ReadonlyArray<RunEvent>): ReadonlySet<RunEvent> {
+// Each issue's newest line of one kind: the ship-stage the board reads its furthest phase from, and the
+// `pr-checks` it draws a followup row's end from.
+function newest_by_issue(events: ReadonlyArray<RunEvent>, kind: string): ReadonlySet<RunEvent> {
 	const newest = new Map<string, RunEvent>()
 
 	for (const event of events) {
-		if (event.kind === EVENT_KIND.SHIP_STAGE) newest.set(issue_of(event), event)
+		if (event.kind === kind) newest.set(issue_of(event), event)
 	}
 
 	return new Set(newest.values())
@@ -241,10 +265,22 @@ function is_stage_start(event: RunEvent): boolean {
 	return event.text.split(WORD_SEPARATOR)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START
 }
 
+// The disposable lines the bound never drops: each issue's newest ship-stage and `pr-checks` and the
+// run's newest `setup` stage, the ones `run:board` draws from now.
+function drawn_lines(events: ReadonlyArray<RunEvent>): ReadonlySet<RunEvent> {
+	const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP)
+
+	return new Set([
+		...newest_by_issue(events, EVENT_KIND.SHIP_STAGE),
+		...newest_by_issue(events, EVENT_KIND.PR_CHECKS),
+		...(setup === undefined ? [] : [setup]),
+	])
+}
+
 // The lines the bound may drop, in the order it drops them: the ones that draw nothing first, then the
 // ones `run:board` draws from, each group oldest first.
 function droppable(events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
-	const kept = newest_stages(events)
+	const kept = drawn_lines(events)
 	const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event))
 
 	return [
@@ -261,7 +297,8 @@ function droppable(events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
 //
 // **Each issue's newest ship-stage is not disposable**: it is the only record `run:board` draws a lane's
 // review-and-later phase from, and on a stream full of positions it would otherwise roll off in its own
-// append.
+// append. **The newest `setup` stage is kept for the same reason**: it is the stage `run:board` draws
+// while the run stands at it, and a run that starts on a full stream would otherwise show none.
 //
 // **A ship-stage `start` outlasts the other disposable lines**: each one is a phase on the lane's track,
 // so it is kept past the `done` lines and the heartbeats.