@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/scripts/auto-ok/auto-ok-judge-cli.ts

@@ -1,6 +1,6 @@
 import { fileURLToPath } from 'node:url'
-import { RUN_LANE_LABEL, RUN_SOLO_LABEL } from '#scripts/issue/issue-labels'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { issue_run_verdict } from '#scripts/issue/issue-run-verdict'
 import { session_cite } from '#scripts/issue/session-cite'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { auto_ok_judge_read } from './auto-ok-judge-read'
@@ -19,13 +19,12 @@ const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const NONE_TOKEN = 'none'
 const USAGE =
-	'Usage: josh auto-ok:judge [--apply <N> (--lane | --solo) | --decline <N> --reason <text>]'
+	'Usage: josh auto-ok:judge [--apply <N> (--lane | --solo --defect yes --verification yes --every-run yes) | --decline <N> --reason <text>]'
 
 const OPTIONS = {
 	apply: { type: 'string' },
 	decline: { type: 'string' },
-	lane: { type: 'boolean' },
-	solo: { type: 'boolean' },
+	...issue_run_verdict.RUN_LABEL_OPTIONS,
 	reason: { type: 'string' },
 } as const
 
@@ -33,19 +32,13 @@ type Values = NonNullable<ReturnType<typeof cli_flags.values_of<typeof OPTIONS>>
 
 type JudgeRequest =
 	| { kind: 'list' }
-	| { kind: 'apply'; issue: string; run_label: string }
+	| { kind: 'apply'; issue: string; run_label: string; answers: Values }
 	| { kind: 'decline'; issue: string; reason: string }
 
-function run_label_of(values: Values): string | undefined {
-	if (values.lane === values.solo) return undefined
-
-	return values.lane === true ? RUN_LANE_LABEL : RUN_SOLO_LABEL
-}
-
 function apply_request(issue: string, values: Values): JudgeRequest | undefined {
-	const run_label = run_label_of(values)
+	const run_label = issue_run_verdict.run_label_of(values)
 
-	return run_label === undefined ? undefined : { kind: 'apply', issue, run_label }
+	return run_label === undefined ? undefined : { kind: 'apply', issue, run_label, answers: values }
 }
 
 function decline_request(issue: string, values: Values): JudgeRequest | undefined {
@@ -98,7 +91,7 @@ async function dispatch(request: JudgeRequest): Promise<number> {
 	if (request.kind === 'list') return await list()
 	if (request.kind === 'decline') return await decline(request.issue, request.reason)
 
-	return await apply(request.issue, request.run_label)
+	return await apply(request.issue, request.run_label, request.answers)
 }
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {

package/scripts/auto-ok/auto-ok-judge-read.ts

@@ -10,9 +10,9 @@ import { auto_ok_judge, type JudgeIssue } from './auto-ok-judge'
 // The reading half of `josh auto-ok:judge`: the open issues that still owe a judgement, shared by the
 // command's listing and the backlog driver's check for a free lane with nothing opted in.
 //
-// **The driver asks once a minute while it watches**, so it hands in a cache it keeps for its process:
-// an issue seen judged is remembered with its `updatedAt`, and its comments are read again only once
-// that moves — a body edit, a comment or a label change. Without it every watch minute would read the
+// **The driver asks every offer interval while it watches**, so it hands in a cache it keeps for its
+// process: an issue seen judged is remembered with its `updatedAt`, and its comments are read again only
+// once that moves — a body edit, a comment or a label change. Without it every watch ask would read the
 // comments of every candidate in the repository.
 
 // The listing cap `auto-ok:next` reads the opted-in pool under; the open backlog is read under the same.

package/scripts/auto-ok/auto-ok-judge-write.ts

@@ -3,6 +3,7 @@ import { issue_label_schema } from '#scripts/git/git-schemas'
 import { parse_json_object_or_undefined } from '#scripts/git/parse-json-array'
 import { issue_auto_ok, type AutoOkDecision } from '#scripts/issue/issue-auto-ok'
 import { AUTO_OK_LABEL, has_label_name } from '#scripts/issue/issue-labels'
+import { issue_run_verdict, type RunLabelFlags } from '#scripts/issue/issue-run-verdict'
 import { session_cite } from '#scripts/issue/session-cite'
 import { z } from 'zod'
 import { auto_ok_judge } from './auto-ok-judge'
@@ -62,17 +63,6 @@ function settled_of(read: IssueRead): string | undefined {
 		: undefined
 }
 
-async function apply_labels(issue: string, run_label: string): Promise<string | undefined> {
-	for (const label of [run_label, AUTO_OK_LABEL]) {
-		// eslint-disable-next-line no-await-in-loop -- the run label must land before `auto-ok`
-		const write = await git_gh_command.issue_apply_label(issue, label)
-
-		if (!write.is_applied) return `could not apply \`${label}\`: ${write.reason}`
-	}
-
-	return undefined
-}
-
 async function record(issue: string, decision: AutoOkDecision, body: string): Promise<number> {
 	try {
 		await git_gh_command.issue_comment(issue, auto_ok_judge.comment_of(decision, body))
@@ -93,30 +83,42 @@ function refused(issue: string, problem: string): number {
 	return FAILURE_EXIT_CODE
 }
 
-async function apply_to(issue: string, run_label: string, read: IssueRead): Promise<number> {
+async function apply_to(
+	issue: string,
+	run_label: string,
+	read: IssueRead,
+	answers: RunLabelFlags,
+): Promise<number> {
 	const exclusion = issue_auto_ok.exclusion_of(read.labels)
 
 	if (exclusion !== undefined) return refused(issue, issue_auto_ok.line_of(exclusion))
 
-	const reason = `judged by backlogrun: no exclusion holds and no person's judgement is needed (${run_label})`
+	const reason = issue_run_verdict.comment_with_answers(
+		`judged by backlogrun: no exclusion holds and no person's judgement is needed (${run_label})`,
+		answers,
+	)
 
 	if ((await record(issue, { is_applied: true, reason }, read.body)) !== SUCCESS_EXIT_CODE) {
 		return FAILURE_EXIT_CODE
 	}
 
-	const problem = await apply_labels(issue, run_label)
+	const problem = await issue_run_verdict.apply_labels(issue, [run_label, AUTO_OK_LABEL])
 
 	return problem === undefined ? SUCCESS_EXIT_CODE : refused(issue, `${problem}; ${RETRY_HINT}`)
 }
 
-async function apply(issue: string, run_label: string): Promise<number> {
+async function apply(
+	issue: string,
+	run_label: string,
+	answers: RunLabelFlags = {},
+): Promise<number> {
 	const read = await read_issue(issue)
 
 	if (read === undefined) return refused(issue, UNREADABLE)
 
 	const settled = settled_of(read)
 
-	if (settled === undefined) return await apply_to(issue, run_label, read)
+	if (settled === undefined) return await apply_to(issue, run_label, read, answers)
 
 	console.info(`${session_cite.issue(issue)}: nothing to apply — ${settled}`)
 

package/scripts/backlog/backlog-arrival-added.ts

@@ -1,9 +1,11 @@
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 
-// Whether `pnpm josh run:add` handed the run an issue since the watcher started.
-// The arrival probe reads the backlog once a minute, and a `--only` run's pool is empty by definition, so
-// an added issue would otherwise wait for the minute — or never wake a `--only` parent at all. The event
+// Whether the run's event stream holds an event of one kind since an instant: a `pnpm josh run:add`
+// addition, or a `lane:limit` raise the drive asks about early (joshuafolkken/kit#6861).
+// The arrival probe reads the backlog only once the `auto-ok` listing changes, and a `--only` run's pool
+// is empty by definition, so an added issue would otherwise wait for that — or never wake a `--only`
+// parent at all. The event
 // stream is a local file, so this is read on every tick rather than on the probe's interval.
 
 type EventReader = () => Promise<ReadonlyArray<RunEvent>>
@@ -14,21 +16,55 @@ async function read_stream(): Promise<ReadonlyArray<RunEvent>> {
 	return target === undefined ? [] : run_event_stream.read_events(target)
 }
 
-function has_added_since(events: ReadonlyArray<RunEvent>, since_ms: number): boolean {
-	return events.some(
-		(event) => event.kind === run_event_stream.EVENT_KIND.ADD && Date.parse(event.at) >= since_ms,
-	)
+function has_kind_since(events: ReadonlyArray<RunEvent>, kind: string, since_ms: number): boolean {
+	return events.some((event) => event.kind === kind && Date.parse(event.at) >= since_ms)
 }
 
-// A stream that cannot be read is no addition: the probe's own backlog read is still the fallback.
-async function is_added_since(since_ms: number, read: EventReader = read_stream): Promise<boolean> {
+// A stream that cannot be read is no event: the probe's own backlog read is still the fallback.
+async function is_kind_since(kind: string, since_ms: number, read: EventReader): Promise<boolean> {
 	try {
-		return has_added_since(await read(), since_ms)
+		return has_kind_since(await read(), kind, since_ms)
 	} catch {
 		return false
 	}
 }
 
-const backlog_arrival_added = { has_added_since, is_added_since }
+async function is_added_since(since_ms: number, read: EventReader = read_stream): Promise<boolean> {
+	return await is_kind_since(run_event_stream.EVENT_KIND.ADD, since_ms, read)
+}
+
+// Whether `lane:limit` raised the limit since the instant — it writes the event on a raise only, so a
+// lowered or reset limit reads false (joshuafolkken/kit#6861).
+async function is_raised_since(
+	since_ms: number,
+	read: EventReader = read_stream,
+): Promise<boolean> {
+	return await is_kind_since(run_event_stream.EVENT_KIND.LANE_LIMIT, since_ms, read)
+}
+
+interface TickReader {
+	read: EventReader
+	begin_tick: () => void
+}
+
+// One parse of the stream per drive tick, shared by the addition and the raise question
+// (joshuafolkken/kit#7016): the first read in a tick reads the stream, the later ones reuse it.
+function tick_reader(read: EventReader = read_stream): TickReader {
+	const memo: { pending: Promise<ReadonlyArray<RunEvent>> | undefined } = { pending: undefined }
+
+	return {
+		read: async () => {
+			memo.pending ??= read()
+
+			return await memo.pending
+		},
+		begin_tick: () => {
+			memo.pending = undefined
+		},
+	}
+}
+
+const backlog_arrival_added = { has_kind_since, is_added_since, is_raised_since, tick_reader }
 
 export { backlog_arrival_added }
+export type { EventReader, TickReader }

package/scripts/backlog/backlog-arrival.ts

@@ -4,6 +4,8 @@ import { lane_limit_override } from '#scripts/lane/lane-limit-override'
 import { COMMAND_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { run_headless } from '#scripts/run/run-headless'
 import { backlog_arrival_added } from './backlog-arrival-added'
+import { backlog_budget } from './backlog-budget'
+import { backlog_drive_listing, type ListingCheck } from './backlog-drive-listing'
 import { backlog_next } from './backlog-next'
 import { backlog_ready, type ReadyPorts, type ReadyReading } from './backlog-ready'
 import { backlog_stalled } from './backlog-stalled'
@@ -14,19 +16,26 @@ import { backlog_stalled_detect } from './backlog-stalled-detect'
 // next wakes — a child's merge, or the progress interval — so in practice the ten-minute stall detector
 // becomes the pick-up, ten minutes late.
 //
-// **The watcher's exit is the only thing that wakes a live parent**, so the probe rides it: once a
-// minute it reads the backlog the pick-up line reads (`backlog_ready.read_ready`, cheap first — a full
-// pool answers without the network read), and an issue runnable now that was not runnable when the
-// watcher started ends the wait. The exit prints the `ready #N` line as every exit does, and that line
-// is what sends the parent to `backlog:offer`. The stall detector stays the safety net.
+// **The watcher's exit is the only thing that wakes a live parent**, so the probe rides it: every
+// `PROBE_INTERVAL_MS` it reads the backlog the pick-up line reads (`backlog_ready.read_ready`, cheap
+// first — a full pool answers without the network read), and an issue runnable now that was not
+// runnable when the watcher started ends the wait. The exit prints the `ready #N` line as every exit
+// does, and that line is what sends the parent to `backlog:offer`. The stall detector stays the safety
+// net.
+//
+// **The `auto-ok` listing gates the read** (joshuafolkken/kit#7229): each probe first asks the listing
+// check `backlog:drive` asks (`backlog_drive_listing.watcher`), whose 304 spends no REST core, and reads
+// the backlog only once the listing holds a new issue — so the probe shares that check's ten-second
+// interval. A raised lane limit changes no listing, so it reads regardless, and a listing change whose
+// reading failed is read again at the next probe.
 //
 // **"New" is measured against the watcher's own start**, so one issue wakes the parent once: the next
 // `--wait` the parent starts takes the pool as it stands then — the woken issue included, dispatched or
 // not — as its baseline. A reading that fails is not an arrival; the probe says nothing and reads again
-// a minute later. A baseline that cannot be read is never read as empty — an empty one would wake the
+// at the next probe. A baseline that cannot be read is never read as empty — an empty one would wake the
 // parent for the whole pool — but it is not given up on either: the scheduled report no longer ends the
 // wait, so an inert probe would leave the parent without a wake until `--hours`. The
-// probe reads the baseline again each minute until one answers.
+// probe reads the baseline again at each probe until one answers.
 //
 // **Every read is bounded.** The probe is awaited inside the watcher's tick loop, so a `gh` call that
 // hangs would otherwise freeze the loop — its `--hours` bound, its liveness ping and the exit that is
@@ -36,7 +45,7 @@ import { backlog_stalled_detect } from './backlog-stalled-detect'
 // the lenient pick-up read takes as an empty pool — here that empty baseline is the whole-pool wake the
 // paragraph above rules out, so either verdict, like a non-zero exit, is a read that did not answer.
 
-const PROBE_INTERVAL_MS = 60_000
+const PROBE_INTERVAL_MS = backlog_budget.LISTING_CHECK_INTERVAL_MS
 const SUCCESS_EXIT_CODE = 0
 const NO_FREE = 0
 const NONE = 0
@@ -67,11 +76,13 @@ async function bounded_ready_issues(): Promise<ReadonlyArray<string>> {
 	return answered_issues(await backlog_ready.read_backlog_next(COMMAND_TIMEOUT_MS))
 }
 
-// The backlog reads, whether `run:add` handed the run an issue since a given instant, and the stall
-// detector's record of whether work and a free lane coexist (joshuafolkken/kit#4349).
+// The backlog reads, whether `run:add` handed the run an issue since a given instant, the stall
+// detector's record of whether work and a free lane coexist (joshuafolkken/kit#4349), and a fresh
+// `auto-ok` listing check per watcher, since each check keeps the numbers it has seen.
 interface ArrivalPorts extends ReadyPorts {
 	is_added_since: (since_ms: number) => Promise<boolean>
 	observe_offerable: (is_offerable: boolean) => Promise<void>
+	listing_watcher: () => ListingCheck
 }
 
 const ARRIVAL_PORTS: ArrivalPorts = {
@@ -79,12 +90,46 @@ const ARRIVAL_PORTS: ArrivalPorts = {
 	ready_issues: bounded_ready_issues,
 	is_added_since: backlog_arrival_added.is_added_since,
 	observe_offerable: backlog_stalled_detect.observe_offerable,
+	listing_watcher: backlog_drive_listing.watcher,
 }
 
 interface ArrivalProbe {
 	has_arrived: (now_ms: number) => Promise<boolean>
 }
 
+// What may have changed since the start: the lane limit, and whether the backlog is worth reading.
+interface PoolWatch {
+	is_raised: () => boolean
+	is_due: () => Promise<boolean>
+	settle: () => void
+}
+
+// A listing change stays due until a reading answers, so a failed reading is read again at the next
+// probe rather than waiting for yet another new issue.
+function pool_watch_of(is_changed: ListingCheck, is_raised: () => boolean): PoolWatch {
+	const memory = { is_pending: false }
+
+	function mark(is_pending: boolean): void {
+		memory.is_pending = is_pending
+	}
+
+	async function is_due(): Promise<boolean> {
+		if (is_raised() || memory.is_pending) return true
+
+		const is_new = await is_changed()
+
+		mark(is_new)
+
+		return is_new
+	}
+
+	function settle(): void {
+		mark(false)
+	}
+
+	return { is_raised, is_due, settle }
+}
+
 // Runnable now, not runnable at the start, and a lane free to take it. **A raised lane limit makes the
 // whole pool new**: the issues the baseline holds were waiting for a lane, and
 // the raise — unlike a merge — wakes nothing else, so the room it made would sit idle until a merge.
@@ -106,8 +151,8 @@ function is_offerable(reading: ReadyReading): boolean {
 // The baseline is the whole runnable pool, free lane or not: an issue that was waiting for a lane is not
 // new when one frees, and the child's merge that freed it already wakes the parent.
 //
-// A baseline read during a `triage` answer names none of the issues it withheld, so every one of them
-// would arrive once they were judged — the whole-pool wake. It is read as a baseline that did not answer.
+// A baseline read during a `triage` answer — alone, or trailing the triaged candidates — leaves out the
+// held issue, so it would arrive once judged. It is read as a baseline that did not answer.
 async function read_baseline(ports: ReadyPorts): Promise<ReadonlySet<string> | undefined> {
 	try {
 		const issues = await ports.ready_issues()
@@ -155,11 +200,30 @@ async function retry_baseline(
 // The next-probe instant is set before any read is awaited. A baseline that did not answer is read again
 // at the next probe instead of the reading, and the first one that answers is the baseline from then on
 // — never an arrival itself, since it is the pool as it stands.
+// A reading is made only on a probe the watch finds due, and only a reading that answered records the
+// stall detector's observation or settles the watch.
+async function has_reading_arrival(
+	baseline: ReadonlySet<string>,
+	ports: ArrivalPorts,
+	watch: PoolWatch,
+): Promise<boolean> {
+	if (!(await watch.is_due())) return false
+
+	const reading = await read_reading(ports)
+
+	if (reading === undefined) return false
+
+	watch.settle()
+	await ports.observe_offerable(is_offerable(reading))
+
+	return arrivals(baseline, reading, watch.is_raised()).length > NONE
+}
+
 function pool_probe_of(
 	initial: ReadonlySet<string> | undefined,
 	first_ms: number,
 	ports: ArrivalPorts,
-	is_raised: () => boolean,
+	watch: PoolWatch,
 ): ArrivalProbe {
 	let next_ms = first_ms
 	// At most one entry, held in a list so the baseline that answers after an await is added rather than
@@ -175,25 +239,21 @@ function pool_probe_of(
 
 		if (baseline === undefined) return await retry_baseline(answered, ports)
 
-		const reading = await read_reading(ports)
-
-		if (reading !== undefined) await ports.observe_offerable(is_offerable(reading))
-
-		return reading !== undefined && arrivals(baseline, reading, is_raised()).length > NONE
+		return await has_reading_arrival(baseline, ports, watch)
 	}
 
 	return { has_arrived }
 }
 
 // An issue `run:add` handed the run since the watcher started wakes the parent at the next tick, ahead
-// of the pool probe's minute.
+// of the pool probe's interval.
 function probe_of(
 	initial: ReadonlySet<string> | undefined,
 	started_ms: number,
 	ports: ArrivalPorts,
-	is_raised: () => boolean,
+	watch: PoolWatch,
 ): ArrivalProbe {
-	const pool = pool_probe_of(initial, started_ms + PROBE_INTERVAL_MS, ports, is_raised)
+	const pool = pool_probe_of(initial, started_ms + PROBE_INTERVAL_MS, ports, watch)
 
 	async function has_arrived(now_ms: number): Promise<boolean> {
 		if (await ports.is_added_since(started_ms)) return true
@@ -205,7 +265,9 @@ function probe_of(
 }
 
 // Inert outside a driving `backlogrun` parent — a `fullrun` watcher has no pool to pick from — and there
-// it reads nothing at all. The raise watch starts with the probe, so only a raise after it wakes.
+// it reads nothing at all. The raise watch starts with the probe, so only a raise after it wakes, and
+// the listing check's first read — its own baseline — is made before the pool's, so an issue opted in
+// between the two is either in the pool's baseline or new to the listing.
 async function start(
 	now_ms: number,
 	ports: ArrivalPorts = ARRIVAL_PORTS,
@@ -215,8 +277,13 @@ async function start(
 	if (!(await is_parent_safely(is_parent))) return INERT
 
 	const is_raised = await watch_raise()
+	const is_changed = ports.listing_watcher()
+
+	await is_changed()
+
+	const watch = pool_watch_of(is_changed, is_raised)
 
-	return probe_of(await read_baseline(ports), now_ms, ports, is_raised)
+	return probe_of(await read_baseline(ports), now_ms, ports, watch)
 }
 
 const backlog_arrival = { PROBE_INTERVAL_MS, answered_issues, arrivals, start }

package/scripts/backlog/backlog-auto-triage.ts

@@ -0,0 +1,130 @@
+import type { EpicChild } from '#scripts/epic/epic-graph'
+import { epic_report, type EpicNextResult } from '#scripts/epic/epic-report'
+import { epic_triage } from '#scripts/epic/epic-triage'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { BUG_LABEL, has_label_name, RUN_LANE_LABEL } from '#scripts/issue/issue-labels'
+
+// The mechanical half of the triage gate (joshuafolkken/kit#5517).
+//
+// `run:solo` needs all three conditions of `backlogrun-lanes.md` → "A solo run", and the first two are
+// readable without an agent: a defect carries `bug`, and a defect in kit's own verification names one
+// of its paths. An untriaged candidate missing either is `run:lane` by the rule itself, so it is
+// labelled here, with the missing condition in a comment, instead of waking a judgment session for
+// minutes. Only a `bug` naming a verification-gate path is left untriaged for the judgment.
+//
+// A label read or write that fails, or a `bug` whose body was not read, leaves the candidate
+// untriaged, so the judgment still covers it.
+
+// Condition 2's area: the lint / type check / spell check / unit-test gate, the code review, the
+// pre-push hook and the merge checks. A path missed here costs a wrong `run:lane`; one too many costs
+// only a judgment session, so the list errs wide.
+const GATE_PATHS: ReadonlyArray<string> = [
+	'eslint/',
+	'eslint.config',
+	'scripts/hooks/',
+	'scripts/gate/',
+	'scripts/lint/',
+	'scripts/review/',
+	'scripts/ci/',
+	'prompts/review',
+	'lefthook',
+	'.github/workflows/',
+	'vitest.config',
+	'tsconfig',
+	'cspell.config',
+]
+
+function names_gate_path(body: string): boolean {
+	return GATE_PATHS.some((path) => body.includes(path))
+}
+
+// The condition the candidate lacks, or `undefined` when only a judgment can answer.
+function lane_reason(child: EpicChild): string | undefined {
+	if (!has_label_name(child.labels, BUG_LABEL)) return `it carries no \`${BUG_LABEL}\` label`
+	if (child.body === undefined || names_gate_path(child.body)) return undefined
+
+	return `it is a \`${BUG_LABEL}\`, but its body names no verification-gate path`
+}
+
+// `issue_comment` appends the run marker itself.
+function comment_of(reason: string): string {
+	return [
+		`Triaged mechanically to \`${RUN_LANE_LABEL}\`: ${reason}.`,
+		'`run:solo` needs all three conditions of `backlogrun-lanes.md` → "A solo run", so no judgment session was woken.',
+	].join('\n')
+}
+
+// The labels the candidate carries once decided, or `undefined` to leave it for the judgment. They are
+// read fresh first: `backlog:next` runs from several callers at once (the arrival probe, each lane's
+// merge), and the second to arrive finds the first one's label and posts no second comment.
+async function decided_labels(
+	child: EpicChild,
+	repo: string,
+): Promise<ReadonlyArray<string> | undefined> {
+	const reason = lane_reason(child)
+
+	if (reason === undefined) return undefined
+
+	const issue = String(child.number)
+	const current = await git_gh_command.read_label_names(issue, repo)
+
+	if (current === undefined || epic_triage.has_triage_label(current)) return current
+
+	const write = await git_gh_command.issue_apply_label(issue, RUN_LANE_LABEL, repo)
+
+	if (!write.is_applied) return undefined
+
+	await git_gh_command.issue_try_comment(issue, comment_of(reason), repo)
+
+	return [...current, RUN_LANE_LABEL]
+}
+
+async function settle_child(child: EpicChild, repo: string): Promise<EpicChild> {
+	if (epic_triage.is_triaged(child)) return child
+
+	const labels = await decided_labels(child, repo)
+
+	return labels === undefined ? child : { ...child, labels }
+}
+
+async function settle_children(
+	children: ReadonlyArray<EpicChild>,
+	repo: string,
+): Promise<ReadonlyArray<EpicChild>> {
+	return await Promise.all(children.map(async (child) => await settle_child(child, repo)))
+}
+
+// The result with every mechanically-decided candidate of `repo` carrying `run:lane`, as it now does
+// on GitHub.
+async function settle(result: EpicNextResult, repo: string): Promise<EpicNextResult> {
+	if (result.verdict !== 'run') return result
+
+	const candidates = await Promise.all(
+		result.candidates.map(async (bucket) =>
+			bucket.repo === repo
+				? { ...bucket, children: await settle_children(bucket.children, repo) }
+				: bucket,
+		),
+	)
+
+	return { ...result, candidates }
+}
+
+// The candidates of `repo` the settle above left for the judgment.
+async function untriaged_of(
+	result: EpicNextResult,
+	repo: string,
+): Promise<{ result: EpicNextResult; untriaged: ReadonlyArray<EpicChild> }> {
+	const settled = await settle(result, repo)
+
+	if (settled.verdict !== 'run') return { result: settled, untriaged: [] }
+
+	return {
+		result: settled,
+		untriaged: epic_triage.untriaged(epic_report.candidates_for_repo(settled, repo)),
+	}
+}
+
+const backlog_auto_triage = { lane_reason, untriaged_of }
+
+export { backlog_auto_triage }

package/scripts/backlog/backlog-budget-cli.ts

@@ -150,8 +150,9 @@ function build_input(values: ParsedValues, now_ms: number): BudgetInput | undefi
 function print_json(input: BudgetInput, decision: BudgetDecision): void {
 	const { verdict, reason } = decision
 	const is_finish = backlog_budget.is_finish(input)
+	const idle_until_ms = backlog_budget.idle_until_ms(input)
 
-	console.info(JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish }))
+	console.info(JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish, idle_until_ms }))
 }
 
 function refuse(): number {

package/scripts/backlog/backlog-budget.ts

@@ -29,14 +29,31 @@ const IDLE_WAIT_HOURS = 8
 const DEFAULT_IDLE_MINUTES = IDLE_WAIT_HOURS * MINUTES_PER_HOUR
 const DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE
 
-// **The one interval between two asks for work, whether lanes are running or nothing is.** The driver
-// and the wake supervisor both read it from here. The loop is a process, so an ask spends no AI turn,
-// and a watch is polled as often as a running batch; a child collected in between is asked about at
+// **The interval between two asks for work, whether lanes are running or a watch has nothing named
+// left.** The loop is a process, so an ask spends no AI turn, and a watch is polled as often as a
+// running batch; a child collected in between, or an issue `run:add` hands the run, is asked about at
 // once, without waiting it out. `backlogrun-progress.md` → "Waiting, and never waiting forever" holds
-// the row; the figure is here because `idle_watch_reason` below has to say it.
-const OFFER_INTERVAL_SECONDS = 60
+// the row; the figure is here because `idle_watch_reason` below has to say it. Three minutes keeps the
+// asks within the REST core budget while lanes run (joshuafolkken/kit#6718); the wake supervisor's
+// pause is its own (`run-wake-window.ts`).
+const OFFER_INTERVAL_SECONDS = 180
 const OFFER_INTERVAL_MS = OFFER_INTERVAL_SECONDS * MS_PER_SECOND
 
+// **The interval while no lane runs and an issue the run names is still left to dispatch**
+// (joshuafolkken/kit#6788). That stretch ends at the named issue's dispatch, and no lane spends the
+// REST core allowance beside it. At the empty-seat ask's measured cost (joshuafolkken/kit#6718) a
+// half-minute keeps the warm asks of an hour under half the hourly core allowance, and only the first
+// ask after a gap is cold. A dry allowance is waited out by `backlog-drive-rate-limit.ts` either way.
+const IDLE_OFFER_INTERVAL_SECONDS = 30
+const IDLE_OFFER_INTERVAL_MS = IDLE_OFFER_INTERVAL_SECONDS * MS_PER_SECOND
+
+// **How often a free seat checks the `auto-ok` listing between two asks** (joshuafolkken/kit#7227).
+// The check reads the listing's first page by its ETag, and a 304 spends no REST core, so the floor is
+// the drive's own poll (`backlog-drive-cli.ts` → `POLL_MS`); a changed listing asks at once, an unchanged one waits out the intervals
+// above.
+const LISTING_CHECK_INTERVAL_SECONDS = 10
+const LISTING_CHECK_INTERVAL_MS = LISTING_CHECK_INTERVAL_SECONDS * MS_PER_SECOND
+
 const RUN_VERDICT = 'run'
 const WATCH_VERDICT = 'watch'
 const STOP_VERDICT = 'stop'
@@ -221,6 +238,12 @@ function answer_decision(input: BudgetInput): BudgetDecision {
 	return FIXED_DECISIONS[input.answer] ?? idle_decision(input)
 }
 
+function idle_until_ms(input: BudgetInput): number | undefined {
+	if (FIXED_DECISIONS[input.answer] !== undefined || input.answer === 'candidates') return undefined
+
+	return input.idle_budget_ms === undefined ? undefined : input.active_at_ms + input.idle_budget_ms
+}
+
 function decide(input: BudgetInput): BudgetDecision {
 	return max_decision(input) ?? answer_decision(input)
 }
@@ -230,7 +253,9 @@ const backlog_budget = {
 	BLOCKED_REASON,
 	DEFAULT_IDLE_MINUTES,
 	DEFAULT_IDLE_MS,
+	IDLE_OFFER_INTERVAL_MS,
 	IDLE_WAIT_HOURS,
+	LISTING_CHECK_INTERVAL_MS,
 	OFFER_INTERVAL_MS,
 	RUN_VERDICT,
 	STOP_VERDICT,
@@ -241,6 +266,7 @@ const backlog_budget = {
 	decide,
 	draining_reason,
 	idle_expired_reason,
+	idle_until_ms,
 	idle_watch_reason,
 	is_finish,
 	max_reached_reason,