@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/scripts/rules/third-party-write.ts

@@ -1,6 +1,10 @@
 import { repo_party } from '#scripts/discovery/repo-party'
 import { bash_triggers } from './bash-triggers'
 import { gh_api } from './gh-api'
+import { gh_repo_selector } from './gh-repo-selector'
+import { git_argv } from './git-argv'
+import { pr_merge } from './pr-merge'
+import { repo_admin } from './repo-admin'
 import { shell_segments } from './shell-segments'
 
 // The trigger and the delivered text behind the `third-party-write` row of `delivered-rules.ts`.
@@ -70,44 +74,126 @@ function candidates_at(
 	return has_moved ? unreadable_candidates : resolve_placeholder_owners
 }
 
-// The session owner is read only when a segment is actually a `gh api` write to a repository — so an
-// ordinary shell line, and every read, pays nothing for the local config read. `resolve_owner` and
+// A merge or an administration write is refused by its own row whoever owns the target, and one
+// refusal is what a PreToolUse hook carries — so the two readings this row added for
+// joshuafolkken/kit#4659 leave those to the row that names them. Asked only of a candidate, so an
+// ordinary shell line pays nothing for it.
+function is_claimed_by_narrower_row(command: string): boolean {
+	return pr_merge.is_pr_merge(command) || repo_admin.is_repo_admin_write(command)
+}
+
+// **A GraphQL mutation names no repository this guard can read** (joshuafolkken/kit#4659): its target
+// is a node id inside the body, so it is refused whoever owns the session — the disposition
+// `pr-merge.ts` takes for a GraphQL body it cannot read, which that row already refuses for a body
+// read from a file or computed by the shell. A query passes. The keyword is looked for in the whole
+// line, because the segment cut ignores quotes and a multi-line query splits across it. A query field
+// the shell expands (`query="$Q"`, or the whole argument quoted: `"query=$Q"`) hides its keyword the
+// same way, so it is refused as a mutation; a single-quoted `query='query($o: String!) {…}'` is
+// literal and still read. A body read from a file is `pr-merge.ts`'s, which refuses it already.
+const GRAPHQL_MUTATION = /\bmutation\b/u
+const EXPANDED_QUERY = /^(?:-[fF])?"?query=(?!')[\s\S]*\$/u
+
+function is_hidden_or_mutation(command: string, args: ReadonlyArray<string>): boolean {
+	return GRAPHQL_MUTATION.test(command) || args.some((argument) => EXPANDED_QUERY.test(argument))
+}
+
+// The arguments of a `gh api` GraphQL call, or `undefined` when the segment is not one.
+function graphql_args(segment: string): ReadonlyArray<string> | undefined {
+	const call = git_argv.program_of(segment)
+
+	if (call === undefined || !gh_api.is_gh_api(segment)) return undefined
+
+	return pr_merge.is_graphql_call(call.name, call.args) ? call.args : undefined
+}
+
+function is_graphql_mutation(command: string, segment: string): boolean {
+	const args = graphql_args(segment)
+
+	if (args === undefined) return false
+
+	return is_hidden_or_mutation(command, args) && !is_claimed_by_narrower_row(command)
+}
+
+// **A `gh <group> <action> -R <owner>/<repo>` write is judged by its selector** (kit#4659).
+// A selector whose owner cannot be read (`-R "$REPO"`) is refused, like an unreadable placeholder
+// candidate: it is a repository `gh` really writes to.
+function is_third_party_selector_write(
+	command: string,
+	segments: ReadonlyArray<string>,
+	index: number,
+	session_owner: string | undefined,
+): boolean {
+	const selectors = gh_repo_selector.write_selectors(segments, index)
+	const is_third_party = selectors.some((selector) => {
+		const owner = repo_party.selector_owner(selector)
+
+		return (
+			owner === undefined || repo_party.classify(session_owner, owner) === repo_party.THIRD_PARTY
+		)
+	})
+
+	return is_third_party && !is_claimed_by_narrower_row(command)
+}
+
+function is_owner_dependent_write(segments: ReadonlyArray<string>, index: number): boolean {
+	const segment = segments[index] ?? ''
+
+	if (gh_api.is_gh_api(segment)) return gh_api.is_write(segment)
+
+	return gh_repo_selector.write_selectors(segments, index).length > 0
+}
+
+function writes_to_third_party_owner(
+	command: string,
+	segments: ReadonlyArray<string>,
+	resolve_owner: () => string | undefined,
+	resolve_placeholder_owners: () => Array<string | undefined>,
+): boolean {
+	if (segments.every((_segment, index) => !is_owner_dependent_write(segments, index))) return false
+
+	const session_owner = resolve_owner()
+
+	return segments.some(
+		(segment, index) =>
+			is_third_party_selector_write(command, segments, index, session_owner) ||
+			is_third_party_write_segment(
+				segment,
+				session_owner,
+				candidates_at(segments, index, resolve_placeholder_owners),
+			),
+	)
+}
+
+// The session owner is read only when a segment is actually a repository write — so an ordinary shell
+// line, and every read, pays nothing for the local config read. `resolve_owner` and
 // `resolve_placeholder_owners` are injected so the suite fixes the owners without touching the real
 // remotes, the way `file-body.ts` injects `has_file`. Each segment is judged on its own, so a `gh api`
 // write quoted inside another command's argument is read as the write it is not, exactly as every
-// other trigger here reads its own.
+// other trigger here reads its own. The cut is by program — a pipe and a background `&` cut too, a
+// quoted one does not — after joining backslash-continued lines, so `echo hi | gh pr comment …` and a
+// `gh api graphql \⏎ -f query=…` are each read as the one `gh` call they launch.
 function writes_third_party(
 	command: string,
 	resolve_owner: () => string | undefined = repo_party.current_owner,
 	resolve_placeholder_owners: () => Array<string | undefined> = repo_party.placeholder_owners,
 ): boolean {
-	const segments = shell_segments.segments_of(command)
-	const has_write = segments.some(
-		(segment) => gh_api.is_gh_api(segment) && gh_api.is_write(segment),
+	const segments = shell_segments.quote_aware_commands_of(
+		shell_segments.joined_continuations(command),
 	)
 
-	if (!has_write) return false
-
-	const session_owner = resolve_owner()
+	if (segments.some((segment) => is_graphql_mutation(command, segment))) return true
 
-	return segments.some((segment, index) =>
-		is_third_party_write_segment(
-			segment,
-			session_owner,
-			candidates_at(segments, index, resolve_placeholder_owners),
-		),
-	)
+	return writes_to_third_party_owner(command, segments, resolve_owner, resolve_placeholder_owners)
 }
 
 // The instruction in the shape a refusal can carry: what the command does, why it is Tier C, and what
 // to do instead. The command that computes the party is handed over, because the whole point of this
 // Issue is that the test is computed rather than judged.
 const THIRD_PARTY_WRITE_REASON =
-	'⛔ third-party write: this `gh api` call writes to a repository whose owner is not this session, ' +
-	'which is Tier C and needs explicit current-turn user instruction. Check with ' +
-	'`pnpm josh repo:party <owner/repo>`, then record the finding on our own Issue and draft the ' +
-	'artifact for a person to post. This rule fires on every occurrence ' +
-	'(`prompts/collaboration-workflow/upstream-interrupt.md`).'
+	"⛔ third-party write: this `gh` call writes to another owner's repository, or one it cannot " +
+	'read (a GraphQL mutation, an unreadable `-R`) — Tier C. Check `pnpm josh repo:party ' +
+	'<owner/repo>`; first-party, use a REST `repos/<owner>/<repo>` path. Else record it on our ' +
+	'Issue and draft it for a person to post. Fires on every occurrence (`upstream-interrupt.md`).'
 
 // `decide` returns true so it refuses every occurrence; it declares no `keeps` — not writing to
 // another owner's tracker is the absence of a call, not a call, so the row is reported unmeasured
@@ -121,8 +207,9 @@ const ROW = {
 		title: 'Third-party write',
 		topic: '`upstream-interrupt.md`',
 		fires:
-			'a `gh api` write (field flag or a write method) to a repository whose owner is not this session. Every occurrence',
-		quiet: 'a read, or a first-party owner (`pnpm josh repo:party`)',
+			'a `gh api` write (field flag or a write method) or a `gh <group> <action>` write selected by `-R` / `GH_REPO` to a repository whose owner is not this session, or a `gh api graphql` call whose line names `mutation` or whose query the shell expands, outside the merge and administration rows. Every occurrence',
+		quiet:
+			'a read, a GraphQL query, or a first-party owner (pinned at session start, `pnpm josh repo:party`)',
 	},
 }
 

package/scripts/rules/timed-rerun.ts

@@ -12,7 +12,7 @@ import { shell_segments } from './shell-segments'
 //
 // **Once per run.** The rule allows one re-run when the record cannot answer, so the reissue goes
 // through. On that reissue `lane-direct-tool` still refuses a lane child's `time`-prefixed heavy tool
-// (`git_argv` skips the timer) and points it at `pnpm josh reserved-run`, the overlap
+// (`git_argv` skips the timer), never wrapping it, and points it at `pnpm josh reserved-run`, the overlap
 // `delivered-rules.ts` admits. A `hyperfine "<command>"` carries the tool inside a quoted argument,
 // which `lane-direct-tool` does not read, so in a lane that reissue is not budgeted.
 

package/scripts/rules/turn-filings.ts

@@ -0,0 +1,90 @@
+import { time_shell } from '#scripts/time-runtime/time-shell'
+import { time_transcript_line, type Block } from '#scripts/time-runtime/time-transcript-line'
+import { bash_triggers } from './bash-triggers'
+import { tail_commands } from './tail-commands'
+
+// The filings a turn made, read off the session transcript for the `Stop` hook's offer to file
+// (`stop-guard.ts`). **No new predicate**: the filing is `bash_triggers.is_issue_filing`, reused
+// verbatim. The filing cap is not this count — it is `issue:file`'s own step, per originating work item
+// (`scripts/issue/issue-file-cap.ts`, joshuafolkken/kit#4750).
+//
+// **A guard-refused filing does not count.** Claude Code writes a denied call to the transcript as a
+// `tool_use` block with an errored `tool_result` — the same exclusion `investigation-reads.ts` makes
+// for a refused read. **Nor does one `issue:file` held itself**: a lint problem or an unacknowledged
+// duplicate exits non-zero having filed nothing. The filing is counted only where its result did not
+// fail.
+
+interface TailFilings {
+	// The `tool_use` id of every filing on the tail.
+	filing_ids: Array<string>
+	// The id of every result that came back as a failure — a guard refusal, or `issue:file` holding the
+	// filing itself (a lint problem, an unacknowledged duplicate), which files nothing either.
+	failures: Set<string>
+}
+
+function is_filing_use(block: Block): boolean {
+	if (!tail_commands.is_bash_use(block)) return false
+
+	return bash_triggers.is_issue_filing(time_shell.bash_command(block.input))
+}
+
+function collect_block(block: Block, found: TailFilings): void {
+	if (block.result_id !== '' && block.is_error === true) found.failures.add(block.result_id)
+	if (is_filing_use(block)) found.filing_ids.push(block.id)
+}
+
+function collect_line(line: string, found: TailFilings): void {
+	const parsed = time_transcript_line.parse_line(line)
+
+	if (parsed === undefined) return
+
+	for (const block of parsed.blocks) collect_block(block, found)
+}
+
+function scan_tail(tail: string): TailFilings {
+	const found: TailFilings = { filing_ids: [], failures: new Set<string>() }
+
+	for (const line of tail.split('\n')) collect_line(line, found)
+
+	return found
+}
+
+// How many Issues the tail filed, counting only filings whose result did not fail.
+function filing_count(tail: string): number {
+	const { filing_ids, failures } = scan_tail(tail)
+
+	return filing_ids.filter((id) => !failures.has(id)).length
+}
+
+// A person's prompt: a `user` line carrying no tool result. Tool results ride `user` lines too, so the
+// absence of one is what marks the line as typed rather than returned.
+function is_prompt_line(line: string): boolean {
+	const parsed = time_transcript_line.parse_line(line)
+
+	if (parsed?.type !== 'user') return false
+
+	return parsed.blocks.every((block) => block.result_id === '')
+}
+
+// The tail from the last prompt on, so a filing an earlier turn made does not answer for this one.
+// A tail with no prompt on it is returned whole.
+function current_turn(tail: string): string {
+	const lines = tail.split('\n')
+	const start = lines.findLastIndex((line) => is_prompt_line(line))
+
+	return lines.slice(Math.max(start, 0)).join('\n')
+}
+
+// How many Issues this turn has filed — `filing_count` read over `current_turn`.
+function turn_filing_count(tail: string): number {
+	return filing_count(current_turn(tail))
+}
+
+const turn_filings = {
+	current_turn,
+	filing_count,
+	is_prompt_line,
+	turn_filing_count,
+}
+
+export { turn_filings }

package/scripts/rules/worktree-guard.ts

@@ -25,6 +25,14 @@ import { shell_segments } from './shell-segments'
 // stash with `git stash apply`, and the lane parked on how to apply it instead of popping by message;
 // the reason now says the substitution is the run's own to make (joshuafolkken/kit#3648).
 //
+// **The refusal names the way back for a single file.** A lane that refused `git checkout -- <file>`
+// reverted its own edit by hand with `Edit` and left a line behind, so a green record landed on the
+// wrong tree (joshuafolkken/kit#4988). The named restore writes HEAD's bytes over that one file, carries
+// no body inline (`file-edits.md`), and no row refuses it. It reverses the file's unstaged diff, so a
+// staged change (the user's) stays, `<path>` is read from the shell's directory like any pathspec,
+// nothing is emptied before git runs (a `git show HEAD:<path> > <path>` redirect is), and an untracked
+// path has no diff to reverse.
+//
 // **It fires on every occurrence**, for the reason `git-force.ts` does: discarding the working tree is
 // destructive each time it is issued.
 
@@ -122,33 +130,40 @@ function is_unauthorized_worktree_change(command: string): boolean {
 	return shell_segments.commands_of(command).some((segment) => is_unauthorized_segment(segment))
 }
 
-// The instruction in the shape a refusal can carry: what the command touches, the authorized route,
-// and — for a stash — the message form that is allowed. `pnpm josh git` and `pnpm josh stash:pop` are
-// invisible to this trigger, so a run that uses them is never refused.
+// The instruction in the shape a refusal can carry: the authorized route — for one file, the restore,
+// limited to this run's own edit (another's uncommitted change is never discarded); for a stash, the
+// message form that is allowed. The refused command is the caller's own, so it is not listed back.
+// The `headline:` opening is what `time-transcript-line.ts` names the guard by. `pnpm josh git` and
+// `pnpm josh stash:pop` are invisible to this trigger, so a run that uses them is never refused.
+const SINGLE_FILE_RESTORE = 'git diff -- <path> | git apply -R'
 const WORKTREE_MUTATION_REASON =
-	'⛔ unauthorized working-tree change: `git checkout --`, `git restore`, `git clean -f`, ' +
-	'`git stash`. A documented flow stashes with `pnpm josh stash:push "<message>"`; a handed-over ' +
+	"⛔ unauthorized working-tree change: undo only this run's edit: " +
+	`\`${SINGLE_FILE_RESTORE}\`. A documented flow stashes with ` +
+	'`pnpm josh stash:push "<message>"`; a handed-over ' +
 	'stash is `pnpm josh stash:pop "<message>"`; record the substitution on the Issue (Tier A) unless ' +
 	'the plan says why the owner keeps the stash: then stop and confirm. It fires on every occurrence ' +
 	'(`operating-rules.md`).'
+// The opening before joshuafolkken/kit#4988, so `rule-value.ts` still credits a refusal it delivered.
+const FORMER_OPENING = '⛔ unauthorized working-tree change: `git checkout --`, `git restore`'
 
 const ROW = {
 	id: 'worktree-mutation',
 	is_trigger: bash_triggers.on_bash_command(is_unauthorized_worktree_change),
 	reason: WORKTREE_MUTATION_REASON,
+	former_reasons: [FORMER_OPENING],
 	decide: (): boolean => true,
 	about: {
 		title: 'Unauthorized work-tree mutation',
 		topic: '`operating-rules.md`',
 		fires:
 			'`git checkout -- <path>` / `git restore <path>` / forced `git clean -f` / an unauthorized `git stash` (bare, push without a message, positional pop). Every occurrence',
-		quiet:
-			'`git stash push -m`, `git stash list`, `pnpm josh git`, `pnpm josh stash:push`, `pnpm josh stash:pop`',
+		quiet: `\`git stash push -m\`, \`git stash list\`, \`pnpm josh git\`, \`pnpm josh stash:push\`, \`pnpm josh stash:pop\`, \`${SINGLE_FILE_RESTORE}\``,
 	},
 }
 
 const worktree_guard = {
 	ROW,
+	SINGLE_FILE_RESTORE,
 	WORKTREE_MUTATION_REASON,
 	is_unauthorized_worktree_change,
 	touches_worktree,

package/scripts/run/board/run-board-ending-reason.ts

@@ -1,3 +1,4 @@
+import { lane_withdraw } from '#scripts/lane/lane-withdraw'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import { run_stalled } from '#scripts/run/park/run-stalled'
@@ -10,8 +11,11 @@ const KIND = run_event_stream.EVENT_KIND
 // waiting park does not name its issue twice.
 const PARK_PREFIX = /^#\d+ (?:parked\s*)?/u
 const PARENTHESES = /^\((?<inner>.*)\)$/u
-// `#<N> withdrawn by a person: <reason>` (`lane-withdraw.ts`).
-const WITHDRAW_PREFIX = /^#\d+ withdrawn by a person:\s*/u
+// `#<N> withdrawn by <who>: <reason>` — every withdrawer `lane-withdraw.ts` names.
+const WITHDRAW_PREFIX = new RegExp(
+	String.raw`^#\d+ withdrawn by (?:${lane_withdraw.WITHDRAWER_NAMES.join('|')}):\s*`,
+	'u',
+)
 
 // `#<N> parked (needs-decision)` reads as the reason `needs-decision`; a bare park has none.
 function park_reason(event: RunEvent): string {

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

@@ -107,9 +107,32 @@ const NO_CUT: Cut = {
 	rows: new Set(),
 }
 
+// A line of printable ASCII alone takes a column a character, so `string-width` is spared it.
+const PRINTABLE_ASCII = /^[ -~]*$/u
+
+// The widths measured so far. A fit weighs a frame for every cut of its order, each repeating most of
+// the last one's lines, and the next redraw draws nearly the same lines and cells again, so each is
+// measured once (joshuafolkken/kit#5185). Let go whole once it holds `WIDTHS_KEPT`, so a long-running
+// board does not keep every line it stopped drawing.
+const WIDTHS_KEPT = 10_000
+const widths = new Map<string, number>()
+
+function measured(plain: string): number {
+	return PRINTABLE_ASCII.test(plain) ? plain.length : string_width(plain)
+}
+
 // The columns a line takes on screen: its color escapes take none, an emoji two.
 function width_of(line: string): number {
-	return string_width(stripVTControlCharacters(line))
+	const known = widths.get(line)
+
+	if (known !== undefined) return known
+	if (widths.size >= WIDTHS_KEPT) widths.clear()
+
+	const width = measured(stripVTControlCharacters(line))
+
+	widths.set(line, width)
+
+	return width
 }
 
 function height_of(line: string, columns: number): number {

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

@@ -0,0 +1,134 @@
+import { process_identity } from '#scripts/josh/process-identity'
+import { lane_process_table, type TableRead } from '#scripts/lane/lane-process-table'
+import { run_event_filed } from '#scripts/run/event/run-event-filed'
+import {
+	run_event_overrun,
+	type Longest,
+	type OverrunNote,
+} from '#scripts/run/event/run-event-overrun'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+
+// What a done row says after its time (joshuafolkken/kit#4772, joshuafolkken/kit#4818): the Issues
+// filed during its child's work, its lane's net minutes and what its overrun investigation came to —
+// read off the stream's `filed` events and the overrun notes (`run-event-overrun.ts`). The child's own
+// filings and the investigation's are kept apart by the event's recorded mark (joshuafolkken/kit#4880).
+
+interface Found {
+	// Each filing of the child's own session as `header.link` takes it: `4768`, or `owner/repo#12` for
+	// one filed elsewhere. An event with no overrun mark is the child's.
+	filed: ReadonlyArray<string>
+	// Each filing of the lane's overrun investigation, read off its mark (joshuafolkken/kit#4880).
+	overrun_filed: ReadonlyArray<string>
+	// The lane's net minutes, from the notes; `undefined` where none said them.
+	minutes: number | undefined
+	// The child's latest overrun note.
+	overrun: OverrunNote | undefined
+	// The longest stage the overrun's start note carried (joshuafolkken/kit#4995), kept past its end note.
+	longest: Longest | undefined
+	// The latest note is the investigation's start and its session is alive; `undefined` where its start
+	// token could not be read, so neither its life nor its death is known.
+	is_investigating: boolean | undefined
+}
+
+// By the child's number.
+type FoundOf = ReadonlyMap<number, Found>
+
+// Whether the process a start note names — its pid and start token — is still there, one this reader
+// may not signal included, `undefined` where the note carries no start token; injected, so a test never
+// probes one.
+type IsLive = (pid: number, start: string | undefined) => boolean | undefined
+
+const KIND = run_event_stream.EVENT_KIND
+const NONE: Found = {
+	filed: [],
+	overrun_filed: [],
+	minutes: undefined,
+	overrun: undefined,
+	longest: undefined,
+	is_investigating: false,
+}
+
+// The child a filing was found during, the reference the board draws, and whether the overrun filed it.
+type FiledEntry = readonly [number, string, boolean]
+
+function filed_entry(event: RunEvent): ReadonlyArray<FiledEntry> {
+	const filed = event.kind === KIND.FILED ? run_event_filed.parse(event.text) : undefined
+
+	if (filed?.found_during === undefined) return []
+
+	return [
+		[Number(filed.found_during), filed.reference.replace(/^#/u, ''), filed.is_overrun === true],
+	]
+}
+
+function with_filed(known: Found, reference: string, is_overrun: boolean): Found {
+	if (is_overrun) return { ...known, overrun_filed: [...known.overrun_filed, reference] }
+
+	return { ...known, filed: [...known.filed, reference] }
+}
+
+function overrun_note(event: RunEvent): OverrunNote | undefined {
+	return event.kind === KIND.NOTE ? run_event_overrun.parse(event.text) : undefined
+}
+
+// The minutes a note carries, else the ones an earlier note did: an end note carries none.
+function minutes_of(note: OverrunNote, known: number | undefined): number | undefined {
+	return 'minutes' in note ? (note.minutes ?? known) : known
+}
+
+// A session that died before its end note turns no spinner, nor does a later process given its pid.
+function noted(found: Found, note: OverrunNote, is_live: IsLive): Found {
+	return {
+		...found,
+		minutes: minutes_of(note, found.minutes),
+		overrun: note,
+		longest: note.kind === 'started' ? note.longest : found.longest,
+		is_investigating: note.kind === 'started' ? is_live(note.pid, note.start) : false,
+	}
+}
+
+function add_filed(found: Map<number, Found>, events: ReadonlyArray<RunEvent>): void {
+	const entries = events.flatMap((event) => filed_entry(event))
+
+	for (const [issue, reference, is_overrun] of entries) {
+		found.set(issue, with_filed(found.get(issue) ?? NONE, reference, is_overrun))
+	}
+}
+
+// Each child's latest overrun note decides what its row says.
+function add_overrun(
+	found: Map<number, Found>,
+	events: ReadonlyArray<RunEvent>,
+	is_live: IsLive,
+): void {
+	const notes = events.flatMap((event) => overrun_note(event) ?? [])
+
+	for (const note of notes) {
+		found.set(note.issue, noted(found.get(note.issue) ?? NONE, note, is_live))
+	}
+}
+
+function found_of(events: ReadonlyArray<RunEvent>, is_live: IsLive): FoundOf {
+	const found = new Map<number, Found>()
+
+	add_filed(found, events)
+	add_overrun(found, events, is_live)
+
+	return found
+}
+
+// The board's own probe, each start time answered from the read's own `ps` snapshot, so neither the
+// read nor a redraw runs a `ps` of its own per note (joshuafolkken/kit#4263). The pid alone reads a
+// later process given that pid as the session, so the start token decides; a note without one — a
+// platform that could not read it — is known dead only once its pid is gone.
+async function live_in(table: TableRead | undefined): Promise<IsLive> {
+	const rows = table === undefined ? undefined : await table()
+	const read = lane_process_table.start_reader(rows ?? [])
+
+	return (pid, start) => process_identity.is_present_process(pid, start, read)
+}
+
+const run_board_found = { found_of, live_in }
+
+export { run_board_found }
+export type { Found, FoundOf, IsLive }

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

@@ -3,6 +3,7 @@ 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_fit } from './run-board-fit'
+import type { FoundOf } from './run-board-found'
 import { run_board_fresh } from './run-board-fresh'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type BoardLayout, type BoardRow } from './run-board-layout'
@@ -92,6 +93,11 @@ interface BoardHeader {
 	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
+	// 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
+	// (joshuafolkken/kit#5132, joshuafolkken/kit#5194).
+	is_investigation_on: boolean
 	// The spinner's frame a running run and a running row turn, `undefined` where the output is not a
 	// terminal and they draw their still icons.
 	spinner: string | undefined
@@ -101,6 +107,8 @@ interface BoardHeader {
 	// 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
 }
 
 interface BoardCounts {

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

@@ -62,6 +62,7 @@ const WORDS = {
 	named: 'named order',
 	held: 'held by triage',
 	headroom: 'memory headroom',
+	usage_limit: 'usage limit',
 	untriaged: 'untriaged',
 	solo: 'runs alone',
 	solo_ahead: 'behind solo',
@@ -95,6 +96,7 @@ const WORDS = {
 	park: 'park',
 	note: 'note',
 	found_during: ' (found during {n})',
+	overrun: 'overrun investigation',
 	// What the run is doing now, where no stage of its own says it.
 	watching: 'watching',
 	pool_empty: 'pool empty',
@@ -188,6 +190,10 @@ const NOTES_ICON = '📌'
 // A plan row the run filed leads its title with it, in place of a findings line naming it again
 // (joshuafolkken/kit#4099).
 const FILED_RUN_MARK = '✚'
+// A merged row whose overrun investigation is running ends on it where no spinner turns
+// (joshuafolkken/kit#4772), and leads its result once it ended (joshuafolkken/kit#4818): the
+// investigate phase's own icon, for the same work.
+const OVERRUN_MARK = PHASE_ICONS.investigate
 const NOTE_ICONS: Readonly<Record<BoardNote['kind'], string>> = {
 	filed: '🆕',
 	park: STATE_ICONS.parked,
@@ -252,8 +258,10 @@ const STAGE_ICONS: Readonly<Partial<Record<string, string>>> = {
 // running issue holds, 📋 the declared order, ✋ a pool held for a judgment, ❓ an issue nobody has
 // judged, 🧍 a `run:solo` issue waiting for the running lanes, 🙅 a row behind it (#4294; 🚧 is a
 // held check's) and 🔒 a row a running `run:solo` issue holds (#4391), chosen on the same rule as
-// every row icon. The rest are the board's own, shared rather than copied.
+// every row icon, and 🪫 the account's Claude usage limit until it resets (#4796). The rest are the
+// board's own, shared rather than copied.
 const WAIT_ICONS = {
+	usage_limit: '🪫',
 	path: '📂',
 	named: '📋',
 	held: '✋',
@@ -280,6 +288,7 @@ const WAIT_WORDS: ReadonlyArray<readonly [icon: string, word: keyof Words]> = [
 	[WAIT_ICONS.solo, 'solo'],
 	[WAIT_ICONS.solo_ahead, 'solo_ahead'],
 	[WAIT_ICONS.solo_running, 'solo_running'],
+	[WAIT_ICONS.usage_limit, 'usage_limit'],
 	[WAIT_ICONS.memory, 'headroom'],
 	[WAIT_ICONS.untriaged, 'untriaged'],
 	[WAIT_ICONS.blocker, 'waits'],
@@ -366,6 +375,7 @@ const run_board_labels = {
 	NOTES_ICON,
 	NOTE_ICONS,
 	NOW_ICONS,
+	OVERRUN_MARK,
 	PHASE_ICONS,
 	PHASE_WORDS,
 	SPINNER_INTERVAL_MS,

package/scripts/run/board/run-board-lane-time.ts

@@ -16,6 +16,7 @@ const OFF_LANE_KINDS: ReadonlySet<string> = new Set([
 	KIND.PARK,
 	KIND.WITHDRAW,
 	KIND.OUTAGE,
+	KIND.USAGE_LIMIT,
 	KIND.SPLIT,
 	KIND.STOP,
 ])

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

@@ -1,7 +1,8 @@
 // The issue numbers on `run:board` open their GitHub issue: each is wrapped in
 // an OSC 8 terminal hyperlink, so VSCode's terminal opens it on Cmd+click while the visible text stays
 // the number. A reference is drawn the way the plan names it — `3450` for this repository's issue,
-// `owner/repo#12` for one elsewhere — and links to the repository it names.
+// `owner/repo#12` for one elsewhere — and links to the repository it names. A followup row's pull
+// request number opens its pull request the same way (joshuafolkken/kit#4625).
 //
 // The columns are padded on the text before it is linked: the escape draws nothing, but `padEnd`
 // counts it. Whether a terminal gets the escape at all is the `link` port's answer.
@@ -18,6 +19,11 @@ function issue_url(reference: string, repo: string): string {
 	return `${GITHUB_URL_PREFIX}${target}/issues/${number}`
 }
 
+// A pull request of `repo` (joshuafolkken/kit#4625).
+function pull_url(number: number, repo: string): string {
+	return `${GITHUB_URL_PREFIX}${repo}/pull/${String(number)}`
+}
+
 // A board with no plan read yet knows no repository, so its references stay plain text.
 function linker(repo: string | undefined, link: Link): (reference: string) => string {
 	if (repo === undefined) return (reference) => reference
@@ -25,7 +31,14 @@ function linker(repo: string | undefined, link: Link): (reference: string) => st
 	return (reference) => link(reference, issue_url(reference, repo))
 }
 
-const run_board_link = { issue_url, linker }
+// A pull request's number linked to it, plain text on the same rule as `linker`.
+function pull_linker(repo: string | undefined, link: Link): (number: number) => string {
+	if (repo === undefined) return String
+
+	return (number) => link(String(number), pull_url(number, repo))
+}
+
+const run_board_link = { issue_url, linker, pull_linker, pull_url }
 
 export { run_board_link }
 export type { Link }