@joshuafolkken/kit 1.1373.0 → 1.1383.0

package/dist/hooks/{chunk-NZN2UFI6.js → chunk-4MGHBTOM.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";
@@ -521,6 +393,37 @@ function read_spawn_stderr(result) {
 
 // scripts/git/git-spawn-sync.ts
 import { execaSync } from "execa";
+
+// 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" };
 function run2(args, options = {}) {
@@ -541,7 +444,10 @@ function read2(args, options = {}) {
   return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
 }
 function origin_url(cwd) {
-  return read2(["config", "--get", "remote.origin.url"], { cwd });
+  return read2(["config", "--get", "remote.origin.url"], {
+    cwd,
+    env: git_location_environment.location_free_environment()
+  });
 }
 function toplevel(timeout = GIT_TIMEOUT_MS) {
   return run2(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
@@ -918,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";
 
@@ -1082,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 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 taken_by(input) {
+  return input.merged + input.running;
 }
-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 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 backlog_idle = { next_check_ms, parse, text_of, window_of };
+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(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 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" },
@@ -1209,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);
@@ -1329,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");
@@ -1346,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)),
@@ -1357,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,
@@ -1661,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" };
@@ -1669,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;
@@ -2074,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";
@@ -2116,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 };
@@ -2156,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,
@@ -2201,8 +2138,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;
@@ -2218,9 +2154,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.`;
 }
@@ -2252,8 +2185,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,
@@ -2264,17 +2195,15 @@ 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_owner_live,
   lost_message,
@@ -2283,7 +2212,6 @@ var run_carry = {
   parse_carry,
   read_carry,
   remaining_of,
-  replace_carry,
   repository_directory,
   retrospective_done_of,
   standing_message,
@@ -2387,15 +2315,16 @@ export {
   ports,
   process_identity,
   process_owner_schema,
-  backlog_budget,
   PORCELAIN_FLAG,
   git_utilities,
   has_timed_out,
   git_spawn,
+  GIT_LOCATION_VARIABLES,
+  git_location_environment,
   git_spawn_sync,
   git_command,
-  stamp_record,
   cli_flags,
+  backlog_budget,
   issue_number_shape,
   run_invocation,
   lane_paths,