@joshuafolkken/kit 1.1373.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-YLBBSSTF.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-UTHMB4O2.js";
+} from "./chunk-2X2ART5G.js";
 import {
   timed_fetch
 } from "./chunk-FZ6FUSBM.js";
 import "./chunk-CDY4NFQG.js";
 import {
   hook_decision
-} from "./chunk-7WKYHEGU.js";
+} from "./chunk-LC56R53A.js";
 import {
   time_density_hook,
   time_hook_transcript,
   time_reported_failure
-} from "./chunk-SLSFIWTX.js";
+} from "./chunk-TT742SIO.js";
 import {
   lane_child_marker
-} from "./chunk-Z5TMJIPW.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-NZN2UFI6.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

@@ -46,6 +46,35 @@ var git_utilities = {
   get_git_command_for_spawn
 };
 
+// scripts/git/git-location-environment.ts
+var GIT_LOCATION_VARIABLES = [
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_COMMON_DIR",
+  "GIT_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_NAMESPACE",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_WORK_TREE"
+];
+function location_free_environment() {
+  return Object.fromEntries(GIT_LOCATION_VARIABLES.map((name) => [name, void 0]));
+}
+function forget(name) {
+  Reflect.deleteProperty(process.env, name);
+}
+function restore_one(name, value) {
+  if (value === void 0) forget(name);
+  else process.env[name] = value;
+}
+function clear_git_location_variables() {
+  const previous = GIT_LOCATION_VARIABLES.map((name) => [name, process.env[name]]);
+  for (const [name] of previous) forget(name);
+  return () => {
+    for (const [name, value] of previous) restore_one(name, value);
+  };
+}
+var git_location_environment = { clear_git_location_variables, location_free_environment };
+
 // scripts/git/git-spawn-sync.ts
 var SUCCESS_EXIT_CODE = 0;
 var C_LOCALE = { LC_ALL: "C", LANGUAGE: "C" };
@@ -67,7 +96,10 @@ function read(args, options = {}) {
   return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
 }
 function origin_url(cwd) {
-  return read(["config", "--get", "remote.origin.url"], { cwd });
+  return read(["config", "--get", "remote.origin.url"], {
+    cwd,
+    env: git_location_environment.location_free_environment()
+  });
 }
 function toplevel(timeout = GIT_TIMEOUT_MS) {
   return run(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
@@ -1835,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"]]
   },
@@ -2448,7 +2480,10 @@ var MAINTENANCE_COMMANDS = {
     script: "scripts/version/latest-update.ts",
     description: "Update all dependencies to latest",
     category: "Maintenance",
-    reference: ["", "developer", ["files", "network"]]
+    reference: ["", "developer", ["files", "network"]],
+    // `JOSH_PLAYWRIGHT_BROWSERS` widens the browsers a Playwright bump installs, and a project
+    // keeps that setting in its `.env`.
+    tsx_arguments: OPTIONAL_ENV_FILE_FLAGS
   }
 };
 
@@ -2536,7 +2571,7 @@ var PROJECT_COMMANDS = {
   },
   adopt: {
     script: "scripts/adopt/adopt.ts",
-    description: "Upgrade every installed @joshuafolkken toolkit here and open the pull request",
+    description: "Upgrade the @joshuafolkken toolkits and other dependencies here, open the PR",
     category: "Project",
     reference: ["[--dry-run]", "developer", ["files", "git", "network", "processes"]]
   }
@@ -2562,7 +2597,7 @@ var VERSIONING_COMMANDS = {
   // before chaining here, exactly as it already does for `latest:update`.
   ranges: {
     script: "scripts/version/publishable-range-check.ts",
-    description: "Check that every published dependency range still resolves for a consumer",
+    description: "Check that every published dependency range still resolves for a consumer and no peer range falls below an installed toolkit",
     category: "Versioning",
     reference: ["", "developer", ["network"]]
   },

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1373.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": [
@@ -264,10 +264,10 @@
     "eslint_d": "^15.0.3",
     "globals": "^17.13.0",
     "lefthook": "^2.2.1",
-    "prettier": "^3.9.9",
+    "prettier": "^3.9.10",
     "prettier-plugin-svelte": "^4.1.1",
     "prettier-plugin-tailwindcss": "^0.8.1",
-    "rollup": "^4.64.4",
+    "rollup": "^4.64.5",
     "rollup-plugin-dts": "^6.5.1",
     "secretlint": "^13.0.7",
     "typescript": "^6.0.3",
@@ -289,7 +289,7 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "12.11.2+sha512.25a51652a196785af5f28bda6dfe8dc582ebefa4ac1d180221ce1390231c5fb76637822ea4b6e4633ce74acdcb0a77f725af11bad38177fdeddaee818a955cb9",
+      "version": "12.12.0+sha512.2ee06ac86db554cf384421461220f0e336a487bfd41b2acd04e17a86b1487832fe45e8d1743f7fc52acc77de12d2356b536fedf8229fc483239e40b13d474449",
       "onFail": "download"
     }
   },

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/adopt/adopt-logic.ts

@@ -8,7 +8,10 @@ import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
 // The decisions `josh adopt` makes before any step runs: whether this repository may adopt at all,
 // which repository the issue is opened in, and what the run is carrying.
 
-const ADOPT_ORIGIN = 'Opened by `josh adopt` in this repository.'
+// It names `josh latest` because the issue title names only the toolkits: without this sentence the
+// other dependency bumps in the pull request have nothing in the issue that accounts for them.
+const ADOPT_ORIGIN =
+	'Opened by `josh adopt` in this repository, which also ran `josh latest` — the other dependencies and the pnpm pin are updated alongside.'
 const INCOMPLETE_HEADLINE =
 	'Refusing to adopt: these declared toolkits would fall out of the plan, and the run would sync the rest without them.'
 const INCOMPLETE_EFFECT =

package/scripts/adopt/adopt.ts

@@ -13,9 +13,11 @@ import { adopt_toolkits } from './adopt-toolkits'
 //
 // It is `josh propagate` seen from the other end: propagation stands in the supplier and pushes one
 // released version out to every consumer, adoption stands in the consumer and pulls whatever is
-// newest in. The step sequence is literally the same one — `propagate_run.STEP_ORDER`, run through
-// `propagate_run.run_target` — so the working-tree pre-check, the ordering and the return to the
-// default branch cannot drift between the two.
+// newest in. The step sequence is the same one with `josh latest` added — `propagate_run
+// .ADOPT_STEP_ORDER`, derived from `STEP_ORDER` and run through `propagate_run.run_target` — so the
+// working-tree pre-check, the ordering and the return to the default branch cannot drift between the
+// two. `josh latest` is adoption's alone: catching a consumer up means its other dependencies and its
+// pnpm pin too, in the same pull request, where propagation carries one exact release and nothing else.
 //
 // It stops at the open pull request. Merging is what `pnpm josh followup` does, under an
 // authorization a CLI does not have.
@@ -62,7 +64,7 @@ function run_sequence(target: PropagateTarget, plan: ReleasePlan | undefined): n
 		plan === undefined ? propagate_steps.describe_step : propagate_steps.create_step_runner(plan)
 	const reason = plan === undefined ? DRY_RUN_REASON : propagate_run.PROPAGATED_REASON
 
-	return report(propagate_run.run_target(target, step, reason))
+	return report(propagate_run.run_target(target, step, reason, propagate_run.ADOPT_STEP_ORDER))
 }
 
 // A declared toolkit that cannot be carried stops the run, whichever of the two ways it fell out —
@@ -158,6 +160,7 @@ const adopt = {
 	KNOWN_FLAGS,
 	NOTHING_TO_ADOPT,
 	parse_options,
+	run_sequence,
 	run_here,
 	run,
 }

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,