@joshuafolkken/kit 1.1379.0 → 1.1387.0

package/.claude/skills/workflow-commands/backlogrun-progress.md

@@ -106,12 +106,11 @@ the epic body; what merged the epic's task list.
 
 | Setting | Value | Meaning |
 | --- | --- | --- |
-| Polling interval | 60 s | **In flight, a floor between two asks, never a clock** — the wake is `lane:await`'s completion or the watcher's arrival exit, never a report. **With nothing in flight no wake comes: it is the parent's own clock.** |
-| `backlogrun` idle-watch poll | 5 min | Not the interval above, and a floor in the same sense. |
+| Polling interval | 60 s | **In flight, a floor between two asks, never a clock** — the wake is `lane:await`'s completion or the watcher's arrival exit, never a report. **With nothing in flight no wake comes: it is the parent's own clock.** A `backlogrun` idle watch is polled at this same interval. |
 | Silent delegated unit | 30 min | Not the child's duration — the time its output has gone **unchanged**. Past it, ask `run:liveness` and book a stopped unit as a failure. |
 | Stale `in-progress` | 90 min | Past it, the other session is gone. |
 | Publish wait | 10 min | `josh propagate`'s own budget. A failed publish never appears. |
-| Whole run | 8 h | Past it, the run needs a person. |
+| `backlogrun` idle watch | 8 h | Counted from when the run's hands became free, never from its start; `pnpm josh backlog:budget` decides it. |
 
 Each timeout **ends the wait and reports** — none is retried indefinitely. Rationale for the figures:
 `docs/maintainers/backlogrun-progress-rationale.md` → "Why the parent waits on classification, not a

package/.claude/skills/workflow-commands/backlogrun-steps.md

@@ -29,7 +29,7 @@ provenance of each rule: `docs/maintainers/backlogrun-steps-rationale.md` → "W
 | The bound | What it limits | Counted by |
 | --- | --- | --- |
 | `--max` | merges per invocation — a run's own filing competes for it | `run:carry --merged` |
-| `--idle`, and the 8-hour whole-run bound | how long the run looks for more | the record's `started_at` |
+| `--idle` (8 hours unless typed) | how long the run waits once nothing can proceed | `--active`, the moment its hands became free |
 | **Ten filings per invocation** | additions to the pool on **every** filing route (`prerequisite.md`) — `route:tier-a`, `route:interrupt` and a review branch-2 filing are exempt from the depth test (`observation-filing.md`), never from this ceiling | `run:carry --filed` |
 | The WIP cap on open issues | the pool across invocations | `prompts/collaboration-workflow/wip-cap.md` |
 
@@ -75,8 +75,6 @@ and `--filed 1`, and **`--cut` is the session's last write**.
 | `busy` / `mismatch` / `unreadable` / `unknown` | **Stop; do not open a lane** — report what it printed; never resume into another invocation's record |
 | `over` | **End the conversation**; retype the invocation in a fresh session |
 | `standing` | **Stop; do not open a lane**: report `pnpm josh run:carry --resume "<invocation>" --owner "$PPID"` and `pnpm josh run:carry --end` for the person to choose — a crash from a run-tooling defect this run has since fixed you resume yourself (`upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合") |
-| `expired` | On standard output: report, stop and `--end` it. On standard error ahead of `began`: a new run replaced it |
-
 **End the record when the run ends** — `pnpm josh run:report`, then `pnpm josh run:carry --end`, **never
 batched with it**, and `pnpm josh run:wake --stop` in the same turn. **A run that ends by _stopping_**
 (a `stop` verdict or the consecutive-failure guard) **ends with `pnpm josh run:carry --end --stopped
@@ -140,7 +138,7 @@ section the row names:
 
 **A candidate only in another repository is never a token** — report it with its checkout. The budgets,
 verdicts and stops are the driver's own: `docs/maintainers/backlogrun-driver.md` (rationale:
-`docs/maintainers/backlogrun-steps-rationale.md` → "Why the idle watch defaults to 30 minutes";
+`docs/maintainers/backlogrun-steps-rationale.md` → "Why the idle watch lasts 8 hours from when the hands became free";
 `docs/maintainers/backlogrun-steps-rationale.md` → "Why the cost check skips a watch").
 
 Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the loop's contract is shaped this way"

package/.claude/skills/workflow-commands/retrospective.md

@@ -60,8 +60,7 @@ Issue, as after any filing.
 `issue:file`'s default applies the label and the next run picks the improvements up without waiting
 for a person. **`backlogrun-steps.md` → "What one invocation approves" is that default's single
 source**; it is written there, beside the brakes that bound it, rather than restated here. Every brake still counts a retrospective's filings: the
-ten-per-invocation ceiling, the WIP cap, `--max`, the 150,000-token session budget and the 8-hour
-whole-run bound.
+ten-per-invocation ceiling, the WIP cap, `--max` and the 150,000-token session budget.
 
 **Close with `pnpm josh run:carry --retrospective --summary "<result>" --owner "$PPID"`.** It marks the
 retrospective run on the carry record, so `run:step` prints `stop` from then on rather than the step a

package/dist/hooks/batch-guard.js

@@ -9,12 +9,12 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-7ZM464OW.js";
-import "./chunk-DHSKBAQ2.js";
-import "./chunk-E7LZL5AN.js";
-import "./chunk-TORRSNDJ.js";
-import "./chunk-NBEAGPS4.js";
-import "./chunk-RW4XMF47.js";
+} from "./chunk-LMWBRJIP.js";
+import "./chunk-EAQEGME7.js";
+import "./chunk-EBSHN25W.js";
+import "./chunk-SL4GQ2XP.js";
+import "./chunk-J3KSS7II.js";
+import "./chunk-2YSW3CXH.js";
 import "./chunk-NEC4AT4Z.js";
 export {
   DISABLED_VALUES,

package/dist/hooks/{chunk-RW4XMF47.js → chunk-2YSW3CXH.js}

@@ -25,134 +25,6 @@ function is_record(value) {
 }
 var json_value = { parse_or_undefined, parse_with, is_record };
 
-// scripts/backlog/backlog-budget.ts
-var MS_PER_MINUTE = 6e4;
-var MINUTES_PER_HOUR = 60;
-var WHOLE_RUN_BUDGET_HOURS = 8;
-var WHOLE_RUN_BUDGET_MINUTES = WHOLE_RUN_BUDGET_HOURS * MINUTES_PER_HOUR;
-var WHOLE_RUN_BUDGET_MS = WHOLE_RUN_BUDGET_MINUTES * MS_PER_MINUTE;
-var DEFAULT_IDLE_MINUTES = 30;
-var DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE;
-var IDLE_POLL_MINUTES = 5;
-var RUN_VERDICT = "run";
-var WATCH_VERDICT = "watch";
-var STOP_VERDICT = "stop";
-var TRIAGE_VERDICT = "triage";
-var ANSWERS = ["blocked", "candidates", "exhausted", "parked", "unreadable", "untriaged"];
-var 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.`;
-var PARKED_REASON = "Nothing opted in can proceed without a person. Report the parked issues and finish.";
-var UNREADABLE_REASON = "The backlog listing could not be read, so nothing was offered. Report what the command printed and finish \u2014 it is not an empty backlog.";
-var BLOCKED_REASON = "Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.";
-var 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.";
-var NO_IDLE_WATCH_REASON = "The backlog is empty and the idle watch was turned off with `--idle 0`, so the run finishes here.";
-function to_minutes(duration_ms) {
-  return String(Math.ceil(duration_ms / MS_PER_MINUTE));
-}
-function max_reached_reason(merged, max_issues) {
-  return `This run's maximum of ${String(max_issues)} is reached, with ${String(merged)} merged. Report what was done, including how many were picked up during an idle watch, and finish.`;
-}
-function draining_reason(running, reason) {
-  return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish \u2014 ${reason}`;
-}
-function idle_expired_reason(idle_budget_ms) {
-  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.`;
-}
-function next_ask_minutes(left_ms) {
-  const left_minutes = Number(to_minutes(left_ms));
-  return String(Math.min(IDLE_POLL_MINUTES, left_minutes));
-}
-function idle_watch_reason(left_ms) {
-  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 running_watch_reason(running, left_ms) {
-  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 \u2014 the watch is running down meanwhile.`;
-}
-function watching_reason(input, left_ms) {
-  if (input.running === 0) return idle_watch_reason(left_ms);
-  return running_watch_reason(input.running, left_ms);
-}
-function taken_by(input) {
-  return input.merged + input.running;
-}
-function run_reason(input) {
-  const { max_issues } = input;
-  if (max_issues === void 0) return "No maximum was given, so start every issue offered.";
-  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.`;
-}
-var ANSWER_STOP_REASONS = {
-  parked: PARKED_REASON,
-  unreadable: UNREADABLE_REASON
-};
-function whole_run_reason(input) {
-  if (input.now_ms - input.started_at_ms < WHOLE_RUN_BUDGET_MS) return void 0;
-  return WHOLE_RUN_REASON;
-}
-function stop_reason(input) {
-  return ANSWER_STOP_REASONS[input.answer] ?? whole_run_reason(input);
-}
-function stopping(input, reason) {
-  if (input.running === 0) return { verdict: STOP_VERDICT, reason };
-  return { verdict: WATCH_VERDICT, reason: draining_reason(input.running, reason) };
-}
-function max_decision(input) {
-  const { max_issues } = input;
-  if (max_issues === void 0 || taken_by(input) < max_issues) return void 0;
-  return stopping(input, max_reached_reason(input.merged, max_issues));
-}
-function idle_decision(input) {
-  const { idle_budget_ms } = input;
-  if (idle_budget_ms === void 0) return stopping(input, NO_IDLE_WATCH_REASON);
-  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));
-  return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) };
-}
-function is_finish(input) {
-  return stop_reason(input) === void 0 && max_decision(input) === void 0;
-}
-var FIXED_DECISIONS = {
-  blocked: { verdict: WATCH_VERDICT, reason: BLOCKED_REASON },
-  untriaged: { verdict: TRIAGE_VERDICT, reason: TRIAGE_REASON }
-};
-function answer_decision(input) {
-  if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
-  return FIXED_DECISIONS[input.answer] ?? idle_decision(input);
-}
-function decide(input) {
-  const reason = stop_reason(input);
-  if (reason !== void 0) return stopping(input, reason);
-  const capped = max_decision(input);
-  if (capped !== void 0) return capped;
-  return answer_decision(input);
-}
-var backlog_budget = {
-  ANSWERS,
-  BLOCKED_REASON,
-  DEFAULT_IDLE_MINUTES,
-  DEFAULT_IDLE_MS,
-  IDLE_POLL_MINUTES,
-  MS_PER_MINUTE,
-  NO_IDLE_WATCH_REASON,
-  PARKED_REASON,
-  RUN_VERDICT,
-  STOP_VERDICT,
-  TRIAGE_REASON,
-  TRIAGE_VERDICT,
-  UNREADABLE_REASON,
-  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,
-  run_reason,
-  running_watch_reason,
-  taken_by
-};
-
 // scripts/git/constants.ts
 import { platform } from "node:os";
 var GIT_COMMAND_UNIX = "/usr/bin/git";
@@ -952,23 +824,6 @@ var process_identity = {
   resolve_own_start
 };
 
-// scripts/josh/stamp-record.ts
-var NONE_READ = { kind: "none" };
-var UNREADABLE_READ = { kind: "unreadable" };
-function is_older_than(iso, max_age_ms, now) {
-  const at = Date.parse(iso);
-  if (Number.isNaN(at)) return true;
-  return now.getTime() - at > max_age_ms;
-}
-function classify(raw, spec, now) {
-  if (raw === void 0) return NONE_READ;
-  const record = spec.parse(raw);
-  if (record === void 0) return UNREADABLE_READ;
-  const is_expired2 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
-  return { kind: is_expired2 ? "expired" : "carried", record };
-}
-var stamp_record = { classify, is_older_than };
-
 // scripts/backlog/backlog-budget-cli.ts
 import { fileURLToPath } from "node:url";
 
@@ -1116,55 +971,125 @@ var cli_flags = {
   is_value_unusable
 };
 
-// scripts/backlog/backlog-idle.ts
-var TEXT_PATTERN = /^idle since (?<since>\S+) until (?<until>\S+) \((?<bound>idle|whole-run)\) asked (?<asked>\S+)$/u;
-var IDLE_BOUND = "idle";
-var WHOLE_RUN_BOUND = "whole-run";
-function window_of(input) {
-  if (input.idle_budget_ms === void 0) return void 0;
-  const idle_until = input.active_at_ms + input.idle_budget_ms;
-  const run_until = input.started_at_ms + backlog_budget.WHOLE_RUN_BUDGET_MS;
-  const bound = run_until < idle_until ? WHOLE_RUN_BOUND : IDLE_BOUND;
-  return {
-    since_ms: input.active_at_ms,
-    until_ms: Math.min(idle_until, run_until),
-    bound,
-    asked_ms: input.now_ms
-  };
+// scripts/backlog/backlog-budget.ts
+var MS_PER_MINUTE = 6e4;
+var MINUTES_PER_HOUR = 60;
+var IDLE_WAIT_HOURS = 8;
+var DEFAULT_IDLE_MINUTES = IDLE_WAIT_HOURS * MINUTES_PER_HOUR;
+var DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE;
+var OFFER_INTERVAL_SECONDS = 60;
+var MS_PER_SECOND3 = 1e3;
+var OFFER_INTERVAL_MS = OFFER_INTERVAL_SECONDS * MS_PER_SECOND3;
+var RUN_VERDICT = "run";
+var WATCH_VERDICT = "watch";
+var STOP_VERDICT = "stop";
+var TRIAGE_VERDICT = "triage";
+var ANSWERS = ["blocked", "candidates", "exhausted", "parked", "unreadable", "untriaged"];
+var BLOCKED_REASON = "Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.";
+var 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.";
+var EMPTY_BACKLOG = "The backlog is empty";
+var WAITING_ON = {
+  exhausted: EMPTY_BACKLOG,
+  parked: "Nothing opted in can proceed without a person",
+  unreadable: "The backlog listing could not be read"
+};
+function waiting_on(answer) {
+  return WAITING_ON[answer] ?? EMPTY_BACKLOG;
+}
+function no_idle_watch_reason(answer) {
+  return `${waiting_on(answer)} and the idle watch was turned off with \`--idle 0\`, so the run finishes here.`;
+}
+function to_minutes(duration_ms) {
+  return String(Math.ceil(duration_ms / MS_PER_MINUTE));
+}
+function max_reached_reason(merged, max_issues) {
+  return `This run's maximum of ${String(max_issues)} is reached, with ${String(merged)} merged. Report what was done, including how many were picked up during an idle watch, and finish.`;
+}
+function draining_reason(running, reason) {
+  return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish \u2014 ${reason}`;
 }
-function iso_of(ms) {
-  return new Date(ms).toISOString();
+function idle_expired_reason(answer, idle_budget_ms) {
+  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 text_of(window) {
-  const { since_ms, until_ms, bound, asked_ms } = window;
-  return `idle since ${iso_of(since_ms)} until ${iso_of(until_ms)} (${bound}) asked ${iso_of(asked_ms)}`;
+function idle_watch_reason(answer, left_ms) {
+  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.`;
 }
-function is_bound(value) {
-  return value === IDLE_BOUND || value === WHOLE_RUN_BOUND;
+function running_watch_reason(answer, running, left_ms) {
+  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 \u2014 the watch is running down meanwhile.`;
 }
-function window_from(groups, bound) {
-  const since_ms = Date.parse(String(groups["since"]));
-  const until_ms = Date.parse(String(groups["until"]));
-  const asked_ms = Date.parse(String(groups["asked"]));
-  return Number.isNaN(since_ms + until_ms + asked_ms) ? void 0 : { since_ms, until_ms, bound, asked_ms };
+function watching_reason(input, left_ms) {
+  if (input.running === 0) return idle_watch_reason(input.answer, left_ms);
+  return running_watch_reason(input.answer, input.running, left_ms);
+}
+function taken_by(input) {
+  return input.merged + input.running;
+}
+function run_reason(input) {
+  const { max_issues } = input;
+  if (max_issues === void 0) return "No maximum was given, so start every issue offered.";
+  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.`;
+}
+function stopping(input, reason) {
+  if (input.running === 0) return { verdict: STOP_VERDICT, reason };
+  return { verdict: WATCH_VERDICT, reason: draining_reason(input.running, reason) };
 }
-function parse(text) {
-  const groups = TEXT_PATTERN.exec(text)?.groups;
-  if (groups === void 0 || !is_bound(groups["bound"])) return void 0;
-  return window_from(groups, groups["bound"]);
+function max_decision(input) {
+  const { max_issues } = input;
+  if (max_issues === void 0 || taken_by(input) < max_issues) return void 0;
+  return stopping(input, max_reached_reason(input.merged, max_issues));
 }
-function next_check_ms(window) {
-  const poll_ms = backlog_budget.IDLE_POLL_MINUTES * backlog_budget.MS_PER_MINUTE;
-  return Math.min(window.asked_ms + poll_ms, window.until_ms);
+function idle_decision(input) {
+  const { idle_budget_ms } = input;
+  if (idle_budget_ms === void 0) 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 { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) };
+  return stopping(input, idle_expired_reason(input.answer, idle_budget_ms));
+}
+function is_finish(input) {
+  return input.answer === "exhausted" && max_decision(input) === void 0;
 }
-var backlog_idle = { next_check_ms, parse, text_of, window_of };
+var FIXED_DECISIONS = {
+  blocked: { verdict: WATCH_VERDICT, reason: BLOCKED_REASON },
+  untriaged: { verdict: TRIAGE_VERDICT, reason: TRIAGE_REASON }
+};
+function answer_decision(input) {
+  if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
+  return FIXED_DECISIONS[input.answer] ?? idle_decision(input);
+}
+function decide(input) {
+  return max_decision(input) ?? answer_decision(input);
+}
+var backlog_budget = {
+  ANSWERS,
+  BLOCKED_REASON,
+  DEFAULT_IDLE_MINUTES,
+  DEFAULT_IDLE_MS,
+  IDLE_WAIT_HOURS,
+  MS_PER_MINUTE,
+  OFFER_INTERVAL_MS,
+  RUN_VERDICT,
+  STOP_VERDICT,
+  TRIAGE_REASON,
+  TRIAGE_VERDICT,
+  WAITING_ON,
+  WATCH_VERDICT,
+  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
+};
 
 // scripts/backlog/backlog-budget-cli.ts
 var ARGV_OFFSET = 2;
 var SUCCESS_EXIT_CODE2 = 0;
 var FAILURE_EXIT_CODE2 = 1;
 var JSON_KEY = "budget";
-var EXHAUSTED_ANSWER = "exhausted";
 var 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]`;
 var OPTIONS = {
   active: { type: "string" },
@@ -1243,18 +1168,10 @@ function build_input(values, now_ms) {
   if (!are_values_readable(values)) return void 0;
   return input_of(values, { answer, now_ms, started_at_ms });
 }
-function idle_of(input, verdict) {
-  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) : void 0;
-  return window === void 0 ? void 0 : backlog_idle.text_of(window);
-}
 function print_json(input, decision) {
   const { verdict, reason } = decision;
-  const idle = idle_of(input, verdict);
   const is_finish2 = backlog_budget.is_finish(input);
-  console.info(
-    JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: is_finish2, ...idle !== void 0 && { idle } })
-  );
+  console.info(JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: is_finish2 }));
 }
 function refuse() {
   console.error(USAGE);
@@ -1363,7 +1280,7 @@ function argument_tokens(invocation) {
     tokens: true
   })?.tokens;
 }
-function parse2(invocation) {
+function parse(invocation) {
   const tokens = argument_tokens(invocation);
   if (tokens === void 0) return void 0;
   const stop = tokens.findIndex((token) => token.kind !== "positional");
@@ -1380,7 +1297,7 @@ function joined(command, rendered) {
   return [command, ...rendered].join(TOKEN_SEPARATOR);
 }
 function rebuild(invocation) {
-  const parsed = parse2(invocation);
+  const parsed = parse(invocation);
   if (parsed === void 0) return void 0;
   return joined(BACKLOG_COMMAND, [
     ...parsed.issues.map((issue) => issue_token(issue)),
@@ -1391,12 +1308,12 @@ function issue_numbers(invocation) {
   const tokens = tokens_of(invocation);
   const stop = tokens.findIndex((token) => token.startsWith(FLAG_PREFIX));
   const leading = stop === NOT_FOUND ? tokens : tokens.slice(FIRST_TOKEN, stop);
-  const issues = parse2(leading.join(TOKEN_SEPARATOR))?.issues;
+  const issues = parse(leading.join(TOKEN_SEPARATOR))?.issues;
   if (issues === void 0 || issues.length === EMPTY_LENGTH) return void 0;
   return issues;
 }
 function has_only(invocation) {
-  return parse2(invocation)?.flags.includes(ONLY_FLAG) === true;
+  return parse(invocation)?.flags.includes(ONLY_FLAG) === true;
 }
 var run_invocation = {
   has_only,
@@ -1424,7 +1341,7 @@ function next_added(carry, additions) {
 }
 function add_issues(target, carry, additions) {
   const next = { ...carry, added: next_added(carry, additions) };
-  stamp_file.write_stamp(target, next);
+  stamp_file.replace_stamp(target, next);
   return next;
 }
 var run_carry_added = { add_issues, ordered };
@@ -1517,7 +1434,7 @@ function apply_change(target, carry, change, now = /* @__PURE__ */ new Date()) {
     done: next_done(carry, effective.done),
     retrospective: effective.retrospective === true || carry.retrospective
   };
-  stamp_file.write_stamp(target, next);
+  stamp_file.replace_stamp(target, next);
   return next;
 }
 var run_carry_change = { apply_change };
@@ -1695,7 +1612,7 @@ var ASSISTANT_TYPE = "assistant";
 function is_priced_line(data) {
   return data.type === ASSISTANT_TYPE && data.message?.model !== SYNTHETIC_MODEL;
 }
-function classify2(data) {
+function classify(data) {
   if (!is_priced_line(data)) return { kind: "skipped" };
   const usage = data.message?.usage;
   return usage ? { kind: "record", record: to_record(data, usage) } : { kind: "no_usage" };
@@ -1703,7 +1620,7 @@ function classify2(data) {
 function parse_line(line) {
   if (line.trim() === "") return { kind: "skipped" };
   const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
-  return parsed.success ? classify2(parsed.data) : { kind: "malformed" };
+  return parsed.success ? classify(parsed.data) : { kind: "malformed" };
 }
 function later_instant(left, right) {
   if (left === void 0) return right;
@@ -2108,8 +2025,6 @@ var run_carry_conversation = {
 // scripts/run/carry/run-carry.ts
 var CARRY_PREFIX = "josh-run-carry-";
 var REPOSITORY_DIRECTORY_INDEX = 1;
-var CARRY_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
-var CARRY_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS;
 var NO_INCREMENT3 = 0;
 var MAX_CUTS = 6;
 var END_COMMAND = "pnpm josh run:carry --end";
@@ -2150,24 +2065,16 @@ async function repository_directory() {
 function parse_carry(raw) {
   return json_value.parse_with(raw, run_carry_schema);
 }
-function started_at_of(carry) {
-  return carry.started_at;
-}
-var CARRY_SPEC = {
-  parse: parse_carry,
-  timestamp_of: started_at_of,
-  max_age_ms: CARRY_MAX_AGE_MS
-};
-function is_expired(carry, now) {
-  return stamp_record.is_older_than(started_at_of(carry), CARRY_MAX_AGE_MS, now);
-}
-function classify3(raw, now) {
-  const read3 = stamp_record.classify(raw, CARRY_SPEC, now);
-  if (!("record" in read3)) return read3;
-  return { kind: read3.kind, carry: read3.record };
+function classify2(raw) {
+  if (raw === void 0) return { kind: "none" };
+  const carry = parse_carry(raw);
+  if (carry === void 0 || Number.isNaN(Date.parse(carry.started_at))) {
+    return { kind: "unreadable" };
+  }
+  return { kind: "carried", carry };
 }
-function read_carry(target, now = /* @__PURE__ */ new Date()) {
-  return classify3(stamp_file.read_stamp_text(target), now);
+function read_carry(target) {
+  return classify2(stamp_file.read_stamp_text(target));
 }
 function owner_of(pid, read3 = process_identity.read_start, transcript = run_carry_conversation.own_transcript()) {
   return { pid, start: read3(pid), transcript };
@@ -2190,10 +2097,6 @@ function begin_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */
   const carry = fresh_carry(invocation, owner, now);
   return stamp_file.create_stamp(target, carry) ? carry : void 0;
 }
-function replace_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
-  stamp_file.remove_stamp(target);
-  return begin_carry(target, invocation, owner, now);
-}
 function adopt_carry(target, carry, owner = NO_OWNER) {
   const next = {
     ...carry,
@@ -2216,6 +2119,11 @@ function is_owned_by(carry, owner) {
 function is_foreign_live_owner(carry, owner) {
   return is_owner_live(carry) && !is_owned_by(carry, owner);
 }
+function is_held_by_another(carry, is_live = is_owner_live) {
+  const caller = owner_of(process.pid);
+  const is_own = carry.owner_pid === caller.pid && carry.owner_start === caller.start;
+  return !is_own && is_live(carry);
+}
 function is_handed_off_to(carry, invocation) {
   return carry.is_handed_off === true && carry.invocation === invocation;
 }
@@ -2235,8 +2143,7 @@ function end_carry(target) {
   stamp_file.remove_stamp(target);
 }
 function retrospective_done_of(read3) {
-  if (read3.kind !== "carried" && read3.kind !== "expired") return false;
-  return read3.carry.retrospective === true;
+  return read3.kind === "carried" && read3.carry.retrospective === true;
 }
 function remaining_of(carry) {
   if (carry === void 0) return void 0;
@@ -2252,9 +2159,6 @@ function done_note(carry) {
 function describe_carry(carry) {
   return `${carry.invocation} started ${carry.started_at}; ${String(carry.merged)} merged, ${String(carry.filed)} filed, ${String(carry.failures)} failed in a row, ${String(carry.outages)} outage(s) in a row, ${String(carry.cuts)} cut(s) crossed${done_note(carry)}`;
 }
-function expired_message(carry) {
-  return `The ${String(CARRY_MAX_AGE_HOURS)}-hour whole-run bound is spent: ${describe_carry(carry)}. Clear it with \`${END_COMMAND}\`.`;
-}
 function mismatch_message(carry, invocation) {
   return `A different invocation is carried here \u2014 ${describe_carry(carry)}. This one is \`${invocation}\`. End the standing record with \`${END_COMMAND}\` once you know its run is over, then begin again.`;
 }
@@ -2286,8 +2190,6 @@ function unknown_message() {
   return "This repository\u2019s git directory could not be read, so no run record was established.";
 }
 var run_carry = {
-  CARRY_MAX_AGE_HOURS,
-  CARRY_MAX_AGE_MS,
   END_COMMAND,
   MAX_CUTS,
   NO_OWNER,
@@ -2298,18 +2200,17 @@ var run_carry = {
   busy_message,
   carry_path,
   claim_command,
-  classify: classify3,
+  classify: classify2,
   classify_claim,
   count_refused_message,
   is_at_cut_cap,
   describe_carry,
   end_carry,
-  expired_message,
   mismatch_message,
   fresh_carry,
   is_count_refused,
-  is_expired,
   is_foreign_live_owner,
+  is_held_by_another,
   is_owner_live,
   lost_message,
   nothing_to_resume_message,
@@ -2317,7 +2218,6 @@ var run_carry = {
   parse_carry,
   read_carry,
   remaining_of,
-  replace_carry,
   repository_directory,
   retrospective_done_of,
   standing_message,
@@ -2421,7 +2321,6 @@ export {
   ports,
   process_identity,
   process_owner_schema,
-  backlog_budget,
   PORCELAIN_FLAG,
   git_utilities,
   has_timed_out,
@@ -2430,8 +2329,8 @@ export {
   git_location_environment,
   git_spawn_sync,
   git_command,
-  stamp_record,
   cli_flags,
+  backlog_budget,
   issue_number_shape,
   run_invocation,
   lane_paths,

package/dist/hooks/{chunk-4RWRP3FF.js → chunk-DCY2GWHC.js}

@@ -1,18 +1,18 @@
 import {
   investigation_reads
-} from "./chunk-QARPP36N.js";
+} from "./chunk-WNFJLBXI.js";
 import {
   lane_guard_policy
-} from "./chunk-DHSKBAQ2.js";
+} from "./chunk-EAQEGME7.js";
 import {
   hook_decision
-} from "./chunk-E7LZL5AN.js";
+} from "./chunk-EBSHN25W.js";
 import {
   time_spans
-} from "./chunk-TORRSNDJ.js";
+} from "./chunk-SL4GQ2XP.js";
 import {
   json_value
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 
 // scripts/delegation/duplicate-read-guard.ts
 import { statSync } from "node:fs";

package/dist/hooks/{chunk-DHSKBAQ2.js → chunk-EAQEGME7.js}

@@ -1,6 +1,6 @@
 import {
   lane_child_marker
-} from "./chunk-NBEAGPS4.js";
+} from "./chunk-J3KSS7II.js";
 
 // scripts/lane/lane-guard-policy.ts
 var DEFAULT_MODE = "refuse";