@joshuafolkken/kit 1.1379.0 → 1.1383.0

package/dist/hooks/stop-guard.js

@@ -16,7 +16,7 @@ import {
   run_event_stream,
   run_event_stream_emit,
   run_hold
-} from "./chunk-TG2AB3W6.js";
+} from "./chunk-6AC4C2IO.js";
 import {
   session_language
 } from "./chunk-6V5OPIUU.js";
@@ -26,22 +26,22 @@ import {
   issue_cite,
   lane_registry,
   run_headless
-} from "./chunk-YSDAH73S.js";
+} from "./chunk-2X2ART5G.js";
 import {
   timed_fetch
 } from "./chunk-FZ6FUSBM.js";
 import "./chunk-CDY4NFQG.js";
 import {
   hook_decision
-} from "./chunk-E7LZL5AN.js";
+} from "./chunk-LC56R53A.js";
 import {
   time_density_hook,
   time_hook_transcript,
   time_reported_failure
-} from "./chunk-TORRSNDJ.js";
+} from "./chunk-TT742SIO.js";
 import {
   lane_child_marker
-} from "./chunk-NBEAGPS4.js";
+} from "./chunk-Y5R47QHU.js";
 import {
   backlog_budget,
   issue_number_shape,
@@ -50,7 +50,7 @@ import {
   process_owner_schema,
   run_carry,
   run_invocation
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-4MGHBTOM.js";
 import {
   PROJECT_ROOT,
   stamp_file
@@ -981,7 +981,6 @@ var PENDING_DECISION = { kind: "pending" };
 var FAILED_DECISION = { kind: "failed" };
 var STOP_REASONS = {
   none: "ended",
-  expired: "expired",
   unreadable: "unreadable"
 };
 var run_wake_schema = process_owner_schema.extend({
@@ -1157,14 +1156,17 @@ function supervisor_liveness(wake, same_process = process_identity.is_same_proce
   if (is_same === void 0) return UNKNOWN;
   return is_same ? LIVE : GONE;
 }
+function had_driver(carry) {
+  return carry.is_handed_off === true || carry.owner_pid !== void 0;
+}
 function is_stranded(input) {
-  if (input.read.kind !== "carried" || input.read.carry.is_handed_off !== true || input.is_owner_live) {
+  if (input.read.kind !== "carried" || input.is_owner_live || !had_driver(input.read.carry)) {
     return false;
   }
   return input.supervisor === GONE;
 }
 function describe2(carry) {
-  return `Run stranded \u2014 ${run_carry.describe_carry(carry)}. The owner is gone, no cut successor claimed the budget, and no supervisor is watching.`;
+  return `Run stranded \u2014 ${run_carry.describe_carry(carry)}. The owner is gone, no successor holds the budget, and no supervisor is watching.`;
 }
 function verdict_of(is_run_stranded) {
   return is_run_stranded ? STRANDED : OK2;
@@ -1295,18 +1297,20 @@ async function outcome_of(raw_payload) {
     return stop_rules.NO_OUTCOME;
   }
 }
-async function has_run_record() {
+async function carried_owner_live() {
   try {
     const directory = await run_carry.repository_directory();
-    if (directory === void 0) return false;
-    return run_carry.read_carry(run_carry.carry_path(directory)).kind === "carried";
+    if (directory === void 0) return void 0;
+    const read = run_carry.read_carry(run_carry.carry_path(directory));
+    return read.kind === "carried" ? run_carry.is_owner_live(read.carry) : void 0;
   } catch {
-    return false;
+    return void 0;
   }
 }
 async function run_report_checks() {
-  if (!await has_run_record()) return;
-  await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS);
+  const is_owner_live = await carried_owner_live();
+  if (is_owner_live === void 0) return;
+  if (is_owner_live) await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS);
   await run_stranded_detect.run_stranded_check();
 }
 async function write_stop_decision(raw_payload) {

package/dist/josh.js

@@ -1867,7 +1867,7 @@ var AI_COMMANDS = {
     // `.env` rather than the ambient environment: the strand notification needs the Telegram
     // credentials, the same reason `run:wake` carries these flags.
     tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Report whether the run is stranded \u2014 budget handed off, owner gone, and no supervisor watching",
+    description: "Report whether the run is stranded \u2014 owner gone, no successor holding the budget, and no supervisor watching",
     category: "AI tools",
     reference: ["", "automation", ["processes", "notifications"]]
   },

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1379.0",
+  "version": "1.1383.0",
   "name": "@joshuafolkken/kit",
   "description": "Development toolkit for AI-assisted projects: formatting, AI assistant rules and a Git/GitHub Issue workflow for any repository, plus lint, type check, tests and hooks for Node projects",
   "keywords": [

package/prompts/collaboration-workflow/upstream-interrupt.md

@@ -18,7 +18,7 @@
 1. **起票する** — `pnpm josh issue:file "<title>" --body-file <path> --depth <n> --route interrupt --label priority:high`。上限は効かない（`wip-cap.md` →「割り込み起票 — 上限が効かない側」の条件 2）
 2. **止まらずに直す** — 壊れた機構を迂回しない（回避策の禁止と、検証ゲートを緩めない規則はここでも変わらない）。`backlogrun` の中では、その割り込みを次の子にし、修正が着地してから塞がれていた子へ戻る。プールから選ぶランでは `priority:high` が先頭に並べ、epic の下では `wip-cap.md` の手順 3 で挿入する。名前を指定したランのドライバーは指定された Issue しか出さないので、`pnpm josh lane:launch <N>` で自分で dispatch する。バッチの外では `wip-cap.md` の手順 4 が変わらず効く — 起票まで済ませ、打つべき `fullrun #<N>` を報告して止まる
 3. **再開できるなら自分で再開し、動くことを確かめる** — 修正のマージ後、再開の手段がある答えには人の打ち直しを求めない。手渡し済みの記録、所有者が死んだ記録、監督プロセスの停止（`warning` Telegram）には `pnpm josh run:wake --start`、`run:carry` の `standing` には `pnpm josh run:carry --resume "<invocation>" --owner "$PPID"` を自分で打つ。そのあと `pnpm josh run:wake --list` が監督プロセスを示し、そのログに次の子の dispatch が現れることを確かめて報告する
-4. **人に打ち直しを求めるのは再開の手段が無いときだけ** — `expired`（8 時間の上限を使い切った）、`mismatch`（別の起動の記録）、別の生きた所有者の `busy`。新しい承認を宣言するのは人だけ、という規則も変わらない
+4. **人に打ち直しを求めるのは再開の手段が無いときだけ** — `mismatch`（別の起動の記録）、別の生きた所有者の `busy`。新しい承認を宣言するのは人だけ、という規則も変わらない
 5. **`needs-decision` を付けない** — ランが自分で直せる不具合は人の判断を要さない（`.claude/skills/workflow-commands/backlogrun-park.md` → "Only a person's judgement carries `needs-decision`"）
 
 手順:

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

@@ -8,7 +8,6 @@ import {
 	type BudgetDecision,
 	type BudgetInput,
 } from './backlog-budget'
-import { backlog_idle } from './backlog-idle'
 
 // The thin half of `josh backlog:budget` (joshuafolkken/kit#1632): read the loop's state off the
 // command line, hand it to the pure decision, print the verdict on stdout and the reason on stderr
@@ -18,7 +17,6 @@ const ARGV_OFFSET = 2
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const JSON_KEY = 'budget'
-const EXHAUSTED_ANSWER: BacklogAnswer = 'exhausted'
 
 const USAGE = `Usage: josh backlog:budget --answer <${backlog_budget.ANSWERS.join('|')}> --started <ISO-8601> [--active <ISO-8601>, required unless the watch is off] [--merged <count>] [--running <count>] [--max <count>] [--idle <minutes>, 0 to turn the watch off] [--json]`
 
@@ -71,7 +69,7 @@ function to_count(raw: string | undefined): number | undefined {
 
 // A flag that was given but could not be read makes the whole invocation unreadable. Falling back to
 // the default instead would answer a question nobody asked — a mistyped `--idle 0` would read as the
-// default 30-minute watch and hold a run open that was asked to finish at its first empty backlog.
+// default watch and hold a run open that was asked to finish at its first empty backlog.
 function is_readable(raw: string | undefined, parsed: number | undefined): boolean {
 	return raw === undefined || parsed !== undefined
 }
@@ -165,27 +163,11 @@ function build_input(values: ParsedValues, now_ms: number): BudgetInput | undefi
 	return input_of(values, { answer, now_ms, started_at_ms })
 }
 
-// The idle window, carried only on the watch an empty backlog opens — the one `idle_decision` reaches,
-// not the draining watch a reached bound returns while children still run — so `backlog:offer` can
-// record when that wait ends (joshuafolkken/kit#3430).
-function idle_of(input: BudgetInput, verdict: string): string | undefined {
-	const is_idle_watch =
-		verdict === backlog_budget.WATCH_VERDICT &&
-		input.answer === EXHAUSTED_ANSWER &&
-		backlog_budget.is_finish(input)
-	const window = is_idle_watch ? backlog_idle.window_of(input) : undefined
-
-	return window === undefined ? undefined : backlog_idle.text_of(window)
-}
-
 function print_json(input: BudgetInput, decision: BudgetDecision): void {
 	const { verdict, reason } = decision
-	const idle = idle_of(input, verdict)
 	const is_finish = backlog_budget.is_finish(input)
 
-	console.info(
-		JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish, ...(idle !== undefined && { idle }) }),
-	)
+	console.info(JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish }))
 }
 
 function refuse(): number {

package/scripts/backlog/backlog-budget.ts

@@ -1,12 +1,17 @@
 // `josh backlog:budget` — whether a `backlogrun` may start more work, keep watching, or finish.
 //
 // `backlog:next` says what may start; it says nothing about when the run itself should end. Without
-// this a run would finish the moment the backlog read empty, so an issue a person opted in minutes
+// this a run would finish the moment nothing could proceed, so an issue a person opted in minutes
 // later would need a whole new session.
 //
 // **The idle watch is on by default and the maximum is not.** A `backlogrun` with neither flag given
-// watches an empty backlog for `DEFAULT_IDLE_MINUTES` before it finishes, and takes as many issues as
-// the backlog holds. `--idle 0` is how the watch is turned off.
+// watches for `IDLE_WAIT_HOURS` once nothing can proceed before it finishes, and takes as many issues
+// as the backlog holds. `--idle 0` is how the watch is turned off.
+//
+// **Every reason nothing can proceed is watched, not only an empty backlog.** Everything opted in
+// waiting on a person, and a listing that could not be read, both change without this run doing
+// anything — a person opts the prerequisite in, GitHub answers again — so ending on either would miss
+// the issue opted in minutes later, which is the one thing the watch exists to catch.
 //
 // The decision is a command's rather than the loop's own arithmetic, for the reason `josh delegate`
 // and `josh review:level` are commands: a count and an elapsed time kept in an agent's head are a
@@ -14,29 +19,23 @@
 
 const MS_PER_MINUTE = 60_000
 const MINUTES_PER_HOUR = 60
-// The whole-run bound, decided here like the idle watch and the maximum rather than by an agent reading
-// a clock.
-const WHOLE_RUN_BUDGET_HOURS = 8
-const WHOLE_RUN_BUDGET_MINUTES = WHOLE_RUN_BUDGET_HOURS * MINUTES_PER_HOUR
-const WHOLE_RUN_BUDGET_MS = WHOLE_RUN_BUDGET_MINUTES * MS_PER_MINUTE
 
-// **The default idle watch, and why it is this number.**
-//
-// - **Below it the watch is a coin flip.** What it waits for is a person noticing the run has gone
-//   quiet, filing an issue and applying `auto-ok`. Ten minutes does not reliably outlast that.
-// - **Above it the run pays for nothing.** At `IDLE_POLL_MINUTES` a 30-minute watch is six asks —
-//   about one child's worth of turns, spent while the run holds no working tree and no lane.
-// - **It is about the length of one child** — 12 to 28 minutes measured — so a run that has emptied its backlog waits roughly as long as one more issue would have taken.
-const DEFAULT_IDLE_MINUTES = 30
+// **How long a run with nothing to do waits, and the only time bound a run has.** It is counted from
+// when the run last had work, never from its start: a run still working, or still inside this wait,
+// is not ended by its age. Eight hours is one unattended night — a person who opts an issue in before
+// they sleep, or after they wake, finds the run still there to pick it up.
+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
 
-// **What a watching run sleeps between asks, and it is not the loop's 60-second polling interval.**
-// That one is sized to a child's `fullrun`, which finishes in minutes; a watch is waiting on a person
-// to file an issue and opt it in, which happens on human timescales. Polling a watch every minute
-// would spend thirty of the parent session's own requests — each one billing the whole session
-// history — to learn nothing thirty times. `backlogrun-progress.md` → "Waiting, and never waiting forever" holds
+// **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
+// 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 IDLE_POLL_MINUTES = 5
+const OFFER_INTERVAL_SECONDS = 60
+const MS_PER_SECOND = 1000
+const OFFER_INTERVAL_MS = OFFER_INTERVAL_SECONDS * MS_PER_SECOND
 
 const RUN_VERDICT = 'run'
 const WATCH_VERDICT = 'watch'
@@ -69,7 +68,7 @@ interface BudgetInput {
 	// otherwise be measured against a maximum that cannot see it.
 	running: number
 	started_at_ms: number
-	// When this run last had work — the most recent ask that was not `exhausted`, or the run's start.
+	// When this run last had work — its most recent launch or collected child, or the run's start.
 	// Refreshing it is what restarts the idle watch when a candidate appears during one.
 	active_at_ms: number
 	now_ms: number
@@ -87,22 +86,28 @@ interface BudgetDecision {
 	reason: string
 }
 
-const WHOLE_RUN_REASON = `The whole-run bound of ${String(WHOLE_RUN_BUDGET_HOURS)} hours has passed. An unattended run that has not finished overnight needs a person, not more waiting.`
-
-const PARKED_REASON =
-	'Nothing opted in can proceed without a person. Report the parked issues and finish.'
-
-const UNREADABLE_REASON =
-	'The backlog listing could not be read, so nothing was offered. Report what the command printed and finish — it is not an empty backlog.'
-
 const BLOCKED_REASON =
 	'Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.'
 
 const TRIAGE_REASON =
 	'An opted-in candidate carries neither `run:solo` nor `run:lane`, so nothing starts until it is judged. Read each issue named above, record its order and one of the two labels with a comment, then ask again.'
 
-const NO_IDLE_WATCH_REASON =
-	'The backlog is empty and the idle watch was turned off with `--idle 0`, so the run finishes here.'
+// What the run is waiting on, by the answer that opened the watch — the opening of every sentence a
+// watch or its ending prints, so a person reads which of the three it was.
+const EMPTY_BACKLOG = 'The backlog is empty'
+const WAITING_ON: Readonly<Partial<Record<BacklogAnswer, string>>> = {
+	exhausted: EMPTY_BACKLOG,
+	parked: 'Nothing opted in can proceed without a person',
+	unreadable: 'The backlog listing could not be read',
+}
+
+function waiting_on(answer: BacklogAnswer): string {
+	return WAITING_ON[answer] ?? EMPTY_BACKLOG
+}
+
+function no_idle_watch_reason(answer: BacklogAnswer): string {
+	return `${waiting_on(answer)} and the idle watch was turned off with \`--idle 0\`, so the run finishes here.`
+}
 
 function to_minutes(duration_ms: number): string {
 	return String(Math.ceil(duration_ms / MS_PER_MINUTE))
@@ -119,39 +124,29 @@ function draining_reason(running: number, reason: string): string {
 	return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish — ${reason}`
 }
 
-function idle_expired_reason(idle_budget_ms: number): string {
-	return `The backlog stayed empty for the whole ${to_minutes(idle_budget_ms)}-minute idle watch. Report what was done, including how many were picked up during the watch, and finish.`
-}
-
-// Never longer than the watch has left: "about 2 minutes left, ask again in 5 minutes" would overrun
-// the budget a person declared, and a sentence that contradicts itself is read as neither half.
-function next_ask_minutes(left_ms: number): string {
-	const left_minutes = Number(to_minutes(left_ms))
-
-	return String(Math.min(IDLE_POLL_MINUTES, left_minutes))
+function idle_expired_reason(answer: BacklogAnswer, idle_budget_ms: number): string {
+	return `${waiting_on(answer)}, and stayed so for the whole ${to_minutes(idle_budget_ms)}-minute idle watch. Report what was done, including how many were picked up during the watch, and finish.`
 }
 
-function idle_watch_reason(left_ms: number): string {
-	return `The backlog is empty and the idle watch has about ${to_minutes(left_ms)} minutes left. Release the working tree, ask again in ${next_ask_minutes(left_ms)} minutes, and restart the watch the moment a candidate appears.`
+function idle_watch_reason(answer: BacklogAnswer, left_ms: number): string {
+	return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left. Release the working tree, ask again in ${String(OFFER_INTERVAL_SECONDS)} seconds, and restart the watch the moment a candidate appears.`
 }
 
 // **A watch that opens while children are still in lanes is not the idle watch's ordinary shape**: the
-// backlog can answer `exhausted` while this run's own children are still merging. Two things the
-// sentence above would get wrong there — the working tree is still held, because the hold is released
-// at the *last* child's merge, and a five-minute poll would leave a merge unnoticed for five minutes.
+// backlog can offer nothing while this run's own children are still merging. The sentence above
+// would get one thing wrong there — the working tree is still held, because the hold is released at
+// the *last* child's merge.
 //
-// **The watch runs down while they drain, and the sentence does not promise otherwise.** Pausing it
-// would mean moving `active_at` on an ask that answered `exhausted`, which is the one thing that
-// moment is defined not to do — so a drain longer than the budget ends the run at the drain. That is
-// the honest ending: the backlog was empty at every ask, which is exactly what the watch measures.
-function running_watch_reason(running: number, left_ms: number): string {
-	return `The backlog is empty and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree until they merge and poll at the polling interval, not the idle poll — the watch is running down meanwhile.`
+// **The watch runs down while they drain, and restarts at each one collected.** A collected child is
+// work, so it moves `active_at`; an ask that offered nothing never does.
+function running_watch_reason(answer: BacklogAnswer, running: number, left_ms: number): string {
+	return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree until they merge and poll at the polling interval — the watch is running down meanwhile.`
 }
 
 function watching_reason(input: BudgetInput, left_ms: number): string {
-	if (input.running === 0) return idle_watch_reason(left_ms)
+	if (input.running === 0) return idle_watch_reason(input.answer, left_ms)
 
-	return running_watch_reason(input.running, left_ms)
+	return running_watch_reason(input.answer, input.running, left_ms)
 }
 
 // What the maximum has already taken: merged issues and the children still running. Counting only
@@ -169,32 +164,10 @@ function run_reason(input: BudgetInput): string {
 	return `Start at most ${String(max_issues - taken_by(input))} more: this run's maximum is ${String(max_issues)}, with ${String(input.merged)} merged and ${String(input.running)} running.`
 }
 
-// The two answers that end a run whatever the budgets say. Neither is a budget decision — the graph
-// said so — but both reach this command, because the loop asks one question rather than branching on
-// `backlog:next`'s word itself and then asking a second.
-const ANSWER_STOP_REASONS: Readonly<Partial<Record<BacklogAnswer, string>>> = {
-	parked: PARKED_REASON,
-	unreadable: UNREADABLE_REASON,
-}
-
-function whole_run_reason(input: BudgetInput): string | undefined {
-	if (input.now_ms - input.started_at_ms < WHOLE_RUN_BUDGET_MS) return undefined
-
-	return WHOLE_RUN_REASON
-}
-
-// The answer-level stops come first, ahead of every budget. Both of them say something the person
-// has to act on — issues are parked, or the listing could not be read — and the reason printed here
-// is quoted verbatim into the completion report, so a budget reason in front of one would report a
-// tidy ending for a run whose backlog actually broke.
-function stop_reason(input: BudgetInput): string | undefined {
-	return ANSWER_STOP_REASONS[input.answer] ?? whole_run_reason(input)
-}
-
 // Every ending goes through here, so no ending abandons a lane. Children already started have to
-// merge and be reported whatever ended the run — the maximum, a parked backlog, a listing that could
-// not be read, or the whole-run bound — so a `stop` while any of them is still running would leave
-// open lanes behind and merged work unmentioned.
+// merge and be reported whatever ended the run — the maximum, or a watch that ran out or was turned
+// off — so a `stop` while any of them is still running would leave open lanes behind and merged work
+// unmentioned.
 function stopping(input: BudgetInput, reason: string): BudgetDecision {
 	if (input.running === 0) return { verdict: STOP_VERDICT, reason }
 
@@ -212,30 +185,31 @@ function max_decision(input: BudgetInput): BudgetDecision | undefined {
 	return stopping(input, max_reached_reason(input.merged, max_issues))
 }
 
-// An empty backlog is watched rather than acted on, which is now the default — and the watch lives
-// *inside* the whole-run bound, which `stop_reason` has already applied above. Only `--idle 0` takes
-// the other branch, where an empty backlog is the run's ending.
+// Nothing can proceed, so the run watches rather than ends — whichever of the three answers said so.
+// The watch is the run's only time bound: it is counted from `active_at_ms`, so a run is never ended
+// by how long ago it started. Only `--idle 0` takes the other branch, where the first such answer is
+// the run's ending.
 function idle_decision(input: BudgetInput): BudgetDecision {
 	const { idle_budget_ms } = input
 
-	if (idle_budget_ms === undefined) return stopping(input, NO_IDLE_WATCH_REASON)
+	if (idle_budget_ms === undefined) return stopping(input, no_idle_watch_reason(input.answer))
 
 	const left_ms = idle_budget_ms - (input.now_ms - input.active_at_ms)
 
-	if (left_ms <= 0) return stopping(input, idle_expired_reason(idle_budget_ms))
+	if (left_ms > 0) return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) }
 
-	return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) }
+	return stopping(input, idle_expired_reason(input.answer, idle_budget_ms))
 }
 
-// Whether a `stop` for this input is the run finishing — the idle watch ending on an empty backlog —
-// rather than stopping on something a person must act on: a parked backlog, an unreadable listing, the
-// maximum or the whole-run bound. The two end the carry record differently (`--end` against
-// `--end --stopped`), and `backlog:drive` reads which one from here.
+// Whether a `stop` for this input is the run finishing — the watch ending on an empty backlog —
+// rather than stopping on something a person must act on: the maximum, issues still waiting on a
+// person, or a listing that never became readable. The two end the carry record differently (`--end`
+// against `--end --stopped`), and `backlog:drive` reads which one from here.
 function is_finish(input: BudgetInput): boolean {
-	return stop_reason(input) === undefined && max_decision(input) === undefined
+	return input.answer === 'exhausted' && max_decision(input) === undefined
 }
 
-// The answers whose decision no count changes, once the bounds above have been applied.
+// The answers whose decision no count changes, once the maximum above has been applied.
 const FIXED_DECISIONS: Readonly<Partial<Record<BacklogAnswer, BudgetDecision>>> = {
 	blocked: { verdict: WATCH_VERDICT, reason: BLOCKED_REASON },
 	untriaged: { verdict: TRIAGE_VERDICT, reason: TRIAGE_REASON },
@@ -248,15 +222,7 @@ function answer_decision(input: BudgetInput): BudgetDecision {
 }
 
 function decide(input: BudgetInput): BudgetDecision {
-	const reason = stop_reason(input)
-
-	if (reason !== undefined) return stopping(input, reason)
-
-	const capped = max_decision(input)
-
-	if (capped !== undefined) return capped
-
-	return answer_decision(input)
+	return max_decision(input) ?? answer_decision(input)
 }
 
 const backlog_budget = {
@@ -264,25 +230,22 @@ const backlog_budget = {
 	BLOCKED_REASON,
 	DEFAULT_IDLE_MINUTES,
 	DEFAULT_IDLE_MS,
-	IDLE_POLL_MINUTES,
+	IDLE_WAIT_HOURS,
 	MS_PER_MINUTE,
-	NO_IDLE_WATCH_REASON,
-	PARKED_REASON,
+	OFFER_INTERVAL_MS,
 	RUN_VERDICT,
 	STOP_VERDICT,
 	TRIAGE_REASON,
 	TRIAGE_VERDICT,
-	UNREADABLE_REASON,
+	WAITING_ON,
 	WATCH_VERDICT,
-	WHOLE_RUN_BUDGET_HOURS,
-	WHOLE_RUN_BUDGET_MS,
-	WHOLE_RUN_REASON,
 	decide,
 	draining_reason,
 	idle_expired_reason,
 	idle_watch_reason,
 	is_finish,
 	max_reached_reason,
+	no_idle_watch_reason,
 	run_reason,
 	running_watch_reason,
 	taken_by,

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

@@ -13,10 +13,12 @@ import { run_carry, type RunCarry } from '#scripts/run/carry/run-carry'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_merge_cli, type MergeResult } from '#scripts/run/merge/run-merge-cli'
 import { z } from 'zod'
+import { backlog_budget } from './backlog-budget'
 import {
 	backlog_drive,
 	type DriveEnd,
 	type DriveState,
+	type LoopConfig,
 	type LoopPorts,
 	type OfferRead,
 } from './backlog-drive'
@@ -46,7 +48,6 @@ const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const should_forward_stderr = true
 const POLL_MS = 5000
-const OFFER_MS = 60_000
 const FIRST_LINE = 0
 
 // The `--json` object `backlog:offer` prints, keyed under its `JSON_KEY`.
@@ -71,7 +72,7 @@ async function read_record(): Promise<RunCarry | undefined> {
 
 	const read = run_carry.read_carry(run_carry.carry_path(target))
 
-	return read.kind === 'carried' || read.kind === 'expired' ? read.carry : undefined
+	return read.kind === 'carried' ? read.carry : undefined
 }
 
 async function read_offer(
@@ -204,6 +205,11 @@ async function seeded_lanes(context: DriveContext): Promise<ReadonlyArray<string
 	return backlog_drive_restore.restore(lanes, events, carry.merged_issues ?? [])
 }
 
+// The interval between two asks is `backlog:budget`'s own, so the driver keeps the one its reason prints.
+function loop_config(window_ms: number | undefined): LoopConfig {
+	return { poll_ms: POLL_MS, offer_ms: backlog_budget.OFFER_INTERVAL_MS, window_ms }
+}
+
 async function drive(context: DriveContext): Promise<number> {
 	const seeded = await seeded_lanes(context)
 
@@ -212,7 +218,7 @@ async function drive(context: DriveContext): Promise<number> {
 	const initial =
 		context.stopped === undefined ? fresh : backlog_drive.merge_stopped(context.stopped, fresh)
 	const last = { state: { ...initial, exclude: [...context.exclude] } }
-	const config = { poll_ms: POLL_MS, offer_ms: OFFER_MS, window_ms: context.window_ms }
+	const config = loop_config(context.window_ms)
 	const end = await backlog_drive.run_loop(last.state, config, ports_of(context, seeded, last))
 
 	console.info(end_line(end))
@@ -258,6 +264,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 const backlog_drive_cli = {
 	end_line,
 	finish: backlog_drive_finish.finish,
+	loop_config,
 	merge,
 	merge_token,
 	offer_argv: backlog_drive_offer_argv.offer_argv,

package/scripts/backlog/backlog-drive.ts

@@ -140,9 +140,12 @@ function ended(reason: string, state: DriveState, token?: string, issue?: string
 	}
 }
 
+// Only an empty backlog drains: `backlog:offer` marks the drain on `exhausted` alone, so a watch over a
+// parked or unreadable backlog has no retrospective for `run:step` to fire and stays the driver's.
 function is_drain(read: OfferRead, state: DriveState): boolean {
 	return (
 		read.verdict === WATCH_VERDICT &&
+		read.answer === 'exhausted' &&
 		state.in_flight.length === 0 &&
 		read.is_retrospective_owed === true
 	)
@@ -352,8 +355,8 @@ async function run_pass(
 
 interface LoopConfig {
 	poll_ms: number
-	// The floor between two `backlog:offer` asks while nothing was collected — the same one-minute
-	// cadence the wake supervisor polls the backlog on, so an idle stretch is not a network hammer.
+	// The floor between two `backlog:offer` asks while nothing was collected, running or idle alike —
+	// `backlog_budget.OFFER_INTERVAL_MS`, the interval the wake supervisor polls on too.
 	offer_ms: number
 	// How long one invocation may wait before returning `window`, or `undefined` for no bound. A headless
 	// parent's foreground call is capped by its shell's timeout, so it passes one under that cap.

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

@@ -125,27 +125,19 @@ const budget_read_schema = z.object({
 	[BUDGET_JSON_KEY]: z.string(),
 	reason: z.string(),
 	is_finish: z.boolean(),
-	idle: z.string().optional(),
 })
 
 interface BudgetRead {
 	verdict: string
 	reason: string
 	is_finish: boolean
-	// The idle watch's window, as `backlog_idle.text_of` wrote it, when the budget opened one.
-	idle?: string | undefined
 }
 
 function budget_of(out: string): BudgetRead | undefined {
 	const read = json_value.parse_with(out, budget_read_schema)
 	if (read === undefined) return undefined
 
-	return {
-		verdict: read[BUDGET_JSON_KEY],
-		reason: read.reason,
-		is_finish: read.is_finish,
-		idle: read.idle,
-	}
+	return { verdict: read[BUDGET_JSON_KEY], reason: read.reason, is_finish: read.is_finish }
 }
 
 function to_tokens(out: string): ReadonlyArray<string> {
@@ -225,12 +217,6 @@ async function decide(values: ParsedValues, counts: OfferCounts): Promise<number
 
 	await mark_drain(decision.verdict, offer.answer, counts.running)
 
-	// The idle window with the ask that read it, once per watching poll, so `run:board` counts the next
-	// check from the poll that ran rather than guessing one.
-	if (decision.idle !== undefined) {
-		await run_event_stream_emit.emit_changed(run_event_stream.EVENT_KIND.IDLE, decision.idle)
-	}
-
 	return emit(decision, offer, values.json === true)
 }
 

package/scripts/epic/epic-candidate-confirm.ts

@@ -111,7 +111,7 @@ function is_still_runnable(
 // A read that failed withholds the candidate rather than confirming it. "Could not tell" is not
 // "nothing blocks it", and this is the one direction the guard may not fail in, because that answer
 // *starts* work — the same reason `epic-busy.ts` answers `wait` for a listing it could not read. The
-// caller then offers the next candidate or waits, and the whole-run timeout bounds the wait.
+// caller then offers the next candidate or waits, and the idle wait bounds the wait.
 async function read_or_withhold(
 	candidate: EpicChild,
 	read_blockers: BlockersReader,