@joshuafolkken/kit 1.1010.0 → 1.1050.0

package/dist/hooks/{chunk-EZLHXKJ6.js → chunk-RLDX5SOC.js}

@@ -1,18 +1,19 @@
 import {
   lane_child_marker,
   run_issue_number
-} from "./chunk-GBJUERYK.js";
+} from "./chunk-WQ4OSBSS.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_blocks,
   cost_usage,
+  file_reader,
   json_value,
   lane_paths,
   stamp_file,
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-PAXMLGSS.js";
+} from "./chunk-7VPDUBRN.js";
 import {
   ENV_FILE_NAME,
   LANE_SEAT_KEY,
@@ -152,7 +153,7 @@ var git_utilities = {
 };
 
 // scripts/git/git-push-transport.ts
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 
 // scripts/git/git-execa-error.ts
 function get_exit_code(error) {
@@ -165,25 +166,20 @@ function has_timed_out(error) {
   if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
   return error.timedOut === true;
 }
+var TIMEOUT_EXIT_CODE = "timeout";
 function create_spawn_error(command, exit_code) {
   const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
   const error_message = `git ${command} exited with code ${exit_code_string}`;
   return new Error(error_message, { cause: { exit_code: exit_code_string } });
 }
 
-// scripts/git/git-push-transport.ts
-var MS_PER_SECOND = 1e3;
-var PUSH_TIMEOUT_SECONDS = 120;
-var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
-var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
-var PUSH_TIMEOUT_MESSAGE = "git push timed out";
-var PUSH_TIMEOUT_EXIT_CODE = "timeout";
+// scripts/git/git-ssh-keepalive.ts
+import { execa } from "execa";
 var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
 var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
 var SSH_LEGACY_VARIABLE = "GIT_SSH";
 var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
 var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
-var PUSH_SUBCOMMAND = "push";
 function to_environment_value(name) {
   return process.env[name]?.trim() ?? "";
 }
@@ -201,19 +197,33 @@ async function has_configured_ssh_command() {
     return false;
   }
 }
-async function to_push_options() {
+async function to_environment() {
   const should_keep_alive = !await has_configured_ssh_command();
+  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
+}
+var git_ssh_keepalive = {
+  to_environment
+};
+
+// scripts/git/git-push-transport.ts
+var MS_PER_SECOND = 1e3;
+var PUSH_TIMEOUT_SECONDS = 120;
+var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
+var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
+var PUSH_TIMEOUT_MESSAGE = "git push timed out";
+var PUSH_SUBCOMMAND = "push";
+async function to_push_options() {
   return {
     stdio: "inherit",
     timeout: PUSH_TIMEOUT_MS,
-    env: should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {}
+    env: await git_ssh_keepalive.to_environment()
   };
 }
 async function did_push_time_out(arguments_list) {
   const git_command_bin = git_utilities.get_git_command_for_spawn();
   const options = await to_push_options();
   try {
-    await execa(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    await execa2(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
     return false;
   } catch (error) {
     if (has_timed_out(error)) return true;
@@ -228,7 +238,7 @@ function to_retry_notice(arguments_list) {
 }
 function create_timeout_error(arguments_list) {
   const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
-  return new Error(message, { cause: { exit_code: PUSH_TIMEOUT_EXIT_CODE } });
+  return new Error(message, { cause: { exit_code: TIMEOUT_EXIT_CODE } });
 }
 async function push(arguments_list) {
   if (!await did_push_time_out(arguments_list)) return;
@@ -241,23 +251,56 @@ var git_push_transport = {
 };
 
 // scripts/git/git-spawn.ts
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 async function read(arguments_) {
   const git_cmd = git_utilities.get_git_command_for_spawn();
-  const { stdout } = await execa2(git_cmd, arguments_);
+  const { stdout } = await execa3(git_cmd, arguments_);
   return stdout.trimEnd();
 }
+var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
+var MS_PER_SECOND2 = 1e3;
+function to_remote_error(command, error, timeout_ms) {
+  if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
+  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND2));
+  return new Error(`git ${command} timed out after ${seconds}s`, {
+    cause: { exit_code: TIMEOUT_EXIT_CODE }
+  });
+}
+async function spawn_remote(arguments_, options) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  try {
+    const { stdout } = await execa3(git_cmd, arguments_, options);
+    return typeof stdout === "string" ? stdout.trimEnd() : "";
+  } catch (error) {
+    throw to_remote_error(arguments_[0] ?? "", error, options.timeout);
+  }
+}
+async function read_remote(arguments_, timeout_ms = REMOTE_TIMEOUT_MS) {
+  return await spawn_remote(arguments_, {
+    timeout: timeout_ms,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output_remote(command, arguments_list) {
+  await spawn_remote([command, ...arguments_list], {
+    stdio: "inherit",
+    timeout: REMOTE_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
 async function with_output(command, arguments_list) {
   const git_command_bin = git_utilities.get_git_command_for_spawn();
   try {
-    await execa2(git_command_bin, [command, ...arguments_list], { stdio: "inherit" });
+    await execa3(git_command_bin, [command, ...arguments_list], { stdio: "inherit" });
   } catch (error) {
     throw create_spawn_error(command, get_exit_code(error));
   }
 }
 var git_spawn = {
   read,
-  with_output
+  read_remote,
+  with_output,
+  with_output_remote
 };
 
 // scripts/git/git-command.ts
@@ -432,7 +475,7 @@ async function push2() {
   }
 }
 async function pull_fast_forward() {
-  await git_spawn.with_output("pull", ["--ff-only"]);
+  await git_spawn.with_output_remote("pull", ["--ff-only"]);
 }
 var SHORT_NAME_FORMAT = "--format=%(refname:short)";
 var REMOTES_FLAG = "--remotes";
@@ -839,18 +882,18 @@ function trimmed(value) {
   const result = value?.trim();
   return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
 }
-function override_value(role, field, environment) {
+function override_value(role, field, environment2) {
   const key = ENV_KEYS[role][field];
-  const value = trimmed(environment[key]);
+  const value = trimmed(environment2[key]);
   if (value !== void 0) return { key, value };
   if (role !== WORKER) return { key, value: void 0 };
   const legacy = LEGACY_WORKER_KEYS[field];
-  const legacy_value = trimmed(environment[legacy]);
+  const legacy_value = trimmed(environment2[legacy]);
   return legacy_value === void 0 ? { key, value: void 0 } : { key: legacy, value: legacy_value };
 }
-function model_override(role, environment, provider) {
+function model_override(role, environment2, provider) {
   const key = ENV_KEYS[role].model;
-  return provider === OPENAI_PROVIDER ? { key, value: void 0 } : override_value(role, "model", environment);
+  return provider === OPENAI_PROVIDER ? { key, value: void 0 } : override_value(role, "model", environment2);
 }
 function rejection(key, value, expected) {
   return { kind: "rejected", note: `${key}=${value} ${expected}, so the agent was not started` };
@@ -859,35 +902,35 @@ function resolved_effort(override, fallback) {
   const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback);
   return parsed.success ? { kind: "effort", effort: parsed.data } : rejection(override.key, override.value ?? "", "is not an allowed effort");
 }
-function has_session(environment, keys) {
-  return keys.some((key) => trimmed(environment[key]) !== void 0);
+function has_session(environment2, keys) {
+  return keys.some((key) => trimmed(environment2[key]) !== void 0);
 }
 function session_rejection(is_conflicting) {
   const note = is_conflicting ? "both Codex and Claude Code sessions were detected" : "no Codex or Claude Code session was detected";
   return { kind: "rejected", note };
 }
 var HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
-function handed_provider(environment) {
-  const value = trimmed(environment[HANDED_PROVIDER_KEY]);
+function handed_provider(environment2) {
+  const value = trimmed(environment2[HANDED_PROVIDER_KEY]);
   if (value === void 0) return session_rejection(false);
   const parsed = PROVIDER_SCHEMA.safeParse(value);
   return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value, "is not an allowed provider");
 }
-function detected_provider(environment) {
-  const has_codex = has_session(environment, [CODEX_SESSION_KEY]);
-  const has_claude = has_session(environment, agent_session_environment.PARENT_SESSION_KEYS);
+function detected_provider(environment2) {
+  const has_codex = has_session(environment2, [CODEX_SESSION_KEY]);
+  const has_claude = has_session(environment2, agent_session_environment.PARENT_SESSION_KEYS);
   if (has_codex === has_claude) return has_codex ? session_rejection(true) : void 0;
   return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
 }
-function resolve_provider(environment = process.env) {
-  return detected_provider(environment) ?? handed_provider(environment);
+function resolve_provider(environment2 = process.env) {
+  return detected_provider(environment2) ?? handed_provider(environment2);
 }
-function has_completion_callback(environment = process.env) {
-  const selected = resolve_provider(environment);
+function has_completion_callback(environment2 = process.env) {
+  const selected = resolve_provider(environment2);
   return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
 }
-function handoff_environment(environment = process.env) {
-  const selected = resolve_provider(environment);
+function handoff_environment(environment2 = process.env) {
+  const selected = resolve_provider(environment2);
   return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
 }
 function validate(profile, model_key) {
@@ -901,19 +944,19 @@ function phase_effort(role, phase, fallback) {
   if (!parsed.success) return fallback;
   return PHASE_EFFORT[role]?.[parsed.data] ?? fallback;
 }
-function overridden_effort(profile, phase, environment) {
-  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment).value);
+function overridden_effort(profile, phase, environment2) {
+  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment2).value);
   return parsed.success ? parsed.data : phase_effort(profile.role, phase, profile.effort);
 }
-function with_phase_effort(profile, phase, environment = process.env) {
-  return { ...profile, effort: overridden_effort(profile, phase, environment) };
+function with_phase_effort(profile, phase, environment2 = process.env) {
+  return { ...profile, effort: overridden_effort(profile, phase, environment2) };
 }
-function resolve(role, environment = process.env, phase) {
-  const selected = resolve_provider(environment);
+function resolve(role, environment2 = process.env, phase) {
+  const selected = resolve_provider(environment2);
   if (selected.kind === "rejected") return selected;
   const defaults = PROVIDER_PROFILES[selected.provider][role];
-  const model = model_override(role, environment, selected.provider);
-  const effort = override_value(role, "effort", environment);
+  const model = model_override(role, environment2, selected.provider);
+  const effort = override_value(role, "effort", environment2);
   const resolved = resolved_effort(effort, phase_effort(role, phase, defaults.effort));
   if (resolved.kind === "rejected") return resolved;
   const profile = {
@@ -1311,10 +1354,10 @@ function load_handoff(handoff_path, max_bytes) {
   }
   return { kind: "ok", handoff };
 }
-function describe_list(label, items) {
-  if (items.length === 0) return `${label}: ${EMPTY_LIST_NOTE}`;
+function describe_list(label2, items) {
+  if (items.length === 0) return `${label2}: ${EMPTY_LIST_NOTE}`;
   const bullets = items.map((item) => `  - ${item}`).join("\n");
-  return `${label}:
+  return `${label2}:
 ${bullets}`;
 }
 function describe_handoff(handoff) {
@@ -1670,6 +1713,7 @@ var IN_PROGRESS_LABEL = "in-progress";
 var NEEDS_DECISION_LABEL = "needs-decision";
 var RUN_SOLO_LABEL = "run:solo";
 var RUN_LANE_LABEL = "run:lane";
+var PRIORITY_HIGH_LABEL = "priority:high";
 var NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
 var ALREADY_DONE_LABEL = "already-done";
 var INTERRUPT_ROUTE_LABEL = "route:interrupt";
@@ -1739,6 +1783,11 @@ var WORKFLOW_LABELS = [
     color: "0e8a16",
     description: "Judged safe to run beside others in a backlogrun"
   },
+  {
+    name: PRIORITY_HIGH_LABEL,
+    color: "e99695",
+    description: "Offered first in a backlogrun; only a person removes it"
+  },
   ...FILING_ROUTE_LABELS,
   ...DEPTH_LABELS
 ];
@@ -1765,11 +1814,11 @@ var REPOSITORY_LABELS = [
   ...RELEASE_CLASSIFICATION_LABELS
 ];
 function has_any_label(labels, wanted) {
-  return (labels ?? []).some((label) => wanted.has(label.name.toLowerCase()));
+  return (labels ?? []).some((label2) => wanted.has(label2.name.toLowerCase()));
 }
 function label_name_of(labels, wanted) {
   const target = wanted.toLowerCase();
-  return labels.find((label) => label.toLowerCase() === target);
+  return labels.find((label2) => label2.toLowerCase() === target);
 }
 function has_label_name(labels, wanted) {
   return label_name_of(labels, wanted) !== void 0;
@@ -2002,14 +2051,14 @@ function main_worktree(repository_path) {
   if (path.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
   return path.dirname(git_directory);
 }
-function discover_repositories(repository_path, environment = process.env) {
+function discover_repositories(repository_path, environment2 = process.env) {
   const main2 = main_worktree(repository_path);
   const current_owner2 = resolve_current_owner(main2);
   if (current_owner2 === void 0) return /* @__PURE__ */ new Map();
   return repo_map_logic.build_repository_map(
     scan_siblings(path.dirname(main2)),
     current_owner2,
-    environment[OVERRIDE_ENV_KEY]
+    environment2[OVERRIDE_ENV_KEY]
   );
 }
 var repo_discovery = {
@@ -2037,36 +2086,97 @@ function current_owner(repository_path = process.cwd()) {
 }
 var repo_party = { FIRST_PARTY, THIRD_PARTY, UNKNOWN, classify: classify3, current_owner, target_owner };
 
-// scripts/lane/lane-registry.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
-import path3 from "node:path";
-
-// scripts/git/git-ls-remote.ts
-var LS_REMOTE_COMMAND = "ls-remote";
-var HEADS_FLAG = "--heads";
-var ORIGIN_REMOTE = "origin";
-var HEADS_REF_PREFIX = "refs/heads/";
-function ls_remote_branch_arguments(branch_name) {
-  return [LS_REMOTE_COMMAND, HEADS_FLAG, ORIGIN_REMOTE, `${HEADS_REF_PREFIX}${branch_name}`];
+// scripts/lane/lane-reap.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+var PGREP_COMMAND = "pgrep";
+var MATCH_FULL_COMMAND_LINE = "-f";
+var CHILDREN_OF_FLAG = "-P";
+var PS_COMMAND = "/bin/ps";
+var PARENT_FORMAT = ["-o", "ppid=", "-p"];
+var TERMINATE_SIGNAL = "SIGTERM";
+var PROBE_TIMEOUT_MS = 2e3;
+var LOWEST_CHILD_PID = 2;
+function parse_pids(printed) {
+  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
 }
-
-// scripts/git/repository-lock.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
-import { setTimeout as sleep } from "node:timers/promises";
+function run_probe(command, args) {
+  try {
+    return execFileSync2(command, [...args], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return "";
+  }
+}
+function parent_of(pid) {
+  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
+}
+function terminate(pid) {
+  try {
+    process.kill(pid, TERMINATE_SIGNAL);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SYSTEM_PROBES = {
+  matching: (pattern) => parse_pids(run_probe(PGREP_COMMAND, [MATCH_FULL_COMMAND_LINE, pattern])),
+  children_of: (pid) => parse_pids(run_probe(PGREP_COMMAND, [CHILDREN_OF_FLAG, String(pid)])),
+  parent_of,
+  terminate
+};
+function ancestry_of(pid, probes) {
+  const ancestry = /* @__PURE__ */ new Set([pid]);
+  let current = probes.parent_of(pid);
+  while (current !== void 0 && !ancestry.has(current)) {
+    ancestry.add(current);
+    current = probes.parent_of(current);
+  }
+  return ancestry;
+}
+function own_ancestry(probes = SYSTEM_PROBES) {
+  return ancestry_of(process.pid, probes);
+}
+function tree_of(roots, probes) {
+  const tree = [];
+  const pending = [...roots];
+  let next = pending.shift();
+  while (next !== void 0) {
+    if (!tree.includes(next)) {
+      tree.push(next);
+      pending.push(...probes.children_of(next));
+    }
+    next = pending.shift();
+  }
+  return tree;
+}
+function reap_child(issue, probes = SYSTEM_PROBES) {
+  const own = own_ancestry(probes);
+  const pattern = lane_child_invocation.process_pattern(issue);
+  const roots = probes.matching(pattern).filter((pid) => !own.has(pid));
+  const doomed = tree_of(roots, probes).filter((pid) => !own.has(pid));
+  return doomed.filter((pid) => probes.terminate(pid));
+}
+var lane_reap = {
+  own_ancestry,
+  parse_pids,
+  reap_child
+};
 
 // scripts/josh/process-identity.ts
-import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
+import { execFileSync as execFileSync3, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { readFileSync as readFileSync3, rmSync } from "node:fs";
 import { createServer } from "node:net";
 import path2 from "node:path";
-var PS_COMMAND = "/bin/ps";
+var PS_COMMAND2 = "/bin/ps";
 var FORMAT_FLAG = "-o";
 var START_TIME_FORMAT = "lstart=";
 var PID_FLAG = "-p";
 var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
-var PROBE_TIMEOUT_MS = 2e3;
+var PROBE_TIMEOUT_MS2 = 2e3;
 var LIVENESS_SIGNAL = 0;
 var LOWEST_REAL_PID = 1;
 var PROC_START_FIELD_INDEX = 19;
@@ -2100,12 +2210,12 @@ function read_proc_start(pid) {
 }
 function read_ps_start(pid) {
   try {
-    const printed = execFileSync2(
-      PS_COMMAND,
+    const printed = execFileSync3(
+      PS_COMMAND2,
       [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
       {
         encoding: "utf8",
-        timeout: PROBE_TIMEOUT_MS,
+        timeout: PROBE_TIMEOUT_MS2,
         stdio: ["ignore", "pipe", "ignore"],
         env: PROBE_ENVIRONMENT
       }
@@ -2183,7 +2293,7 @@ function beacon_target(token) {
 function is_live_beacon(target) {
   return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
     stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS
+    timeout: PROBE_TIMEOUT_MS2
   }).status === 0;
 }
 function has_matching_start(pid, recorded_start, read2) {
@@ -2223,975 +2333,1002 @@ var process_identity = {
   resolve_own_start
 };
 
-// scripts/git/git-common-directory.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
-var OWN_GIT_DIRECTORY = 0;
-var COMMON_GIT_DIRECTORY = 1;
-var PROBE_TIMEOUT_MS2 = 2e3;
-function read_directories(cwd) {
-  const git = git_utilities.get_git_command_for_spawn();
-  const output = execFileSync3(git, [...git_command.GIT_DIRECTORY_ARGUMENTS], {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
-    timeout: PROBE_TIMEOUT_MS2
-  });
-  return output.trim().split("\n");
+// scripts/run/run-carry.ts
+import { z as z5 } from "zod";
+
+// scripts/run/run-carry-streak.ts
+var NO_INCREMENT = 0;
+var OUTAGE_FOLD_WINDOW_MS = 12e4;
+function has_increment(value) {
+  return (value ?? NO_INCREMENT) > NO_INCREMENT;
 }
-function select_linked(directories) {
-  const own = directories[OWN_GIT_DIRECTORY];
-  const common = directories[COMMON_GIT_DIRECTORY];
-  return own !== void 0 && common !== void 0 && own !== common ? common : void 0;
+function next_failures(carry, change) {
+  if (has_increment(change.merged)) return NO_INCREMENT;
+  return carry.failures + (change.failures ?? NO_INCREMENT);
 }
-function resolve2(cwd) {
-  try {
-    return select_linked(read_directories(cwd));
-  } catch {
-    return void 0;
-  }
+function is_within_fold_window(last_outage_at, now) {
+  if (last_outage_at === void 0) return false;
+  const last = Date.parse(last_outage_at);
+  if (Number.isNaN(last)) return false;
+  return now.getTime() - last <= OUTAGE_FOLD_WINDOW_MS;
 }
-function repository(cwd) {
-  try {
-    return read_directories(cwd)[COMMON_GIT_DIRECTORY];
-  } catch {
-    return void 0;
-  }
+function folded_outage(carry) {
+  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
 }
-var git_common_directory = { repository, resolve: resolve2, select_linked };
-
-// scripts/git/repository-lock.ts
-var POLL_INTERVAL_MS = 200;
-function lock_path(prefix, cwd = process.cwd()) {
-  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd);
+function counted_outage(carry, change, now) {
+  const outages = carry.outages + (change.outages ?? NO_INCREMENT);
+  return { outages, last_outage_at: now.toISOString() };
 }
-function parse_owner(raw) {
-  if (raw === void 0) return void 0;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
+function next_outage(carry, change, now) {
+  if (has_increment(change.outages)) {
+    return is_within_fold_window(carry.last_outage_at, now) ? folded_outage(carry) : counted_outage(carry, change, now);
   }
+  const is_reachable = has_increment(change.merged) || has_increment(change.failures);
+  return is_reachable ? { outages: NO_INCREMENT, last_outage_at: void 0 } : folded_outage(carry);
 }
-function read_owner(target) {
-  return parse_owner(stamp_file.read_stamp_text(target));
-}
-function is_owner_gone(owner) {
-  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
-}
-function restore(aside, target) {
-  try {
-    linkSync(aside, target);
-  } catch {
-  }
+function next_state(carry, change, now) {
+  const outage = next_outage(carry, change, now);
+  return {
+    failures: next_failures(carry, change),
+    outages: outage.outages,
+    last_outage_at: outage.last_outage_at
+  };
 }
-function stale_record(target, is_gone2) {
-  const raw = stamp_file.read_stamp_text(target);
-  const owner = parse_owner(raw);
-  return owner !== void 0 && is_gone2(owner) ? raw : void 0;
+var run_carry_streak = { OUTAGE_FOLD_WINDOW_MS, next_state };
+
+// scripts/run/run-carry-change.ts
+var NO_INCREMENT2 = 0;
+function next_done(carry, done) {
+  if (done === void 0) return carry.done;
+  const current = carry.done ?? [];
+  return current.includes(done) ? current : [...current, done];
 }
-function move_aside(target) {
-  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
-  try {
-    renameSync(target, aside);
-    return aside;
-  } catch {
-    return void 0;
-  }
+function next_merged_issues(carry, issue) {
+  if (issue === void 0) return carry.merged_issues;
+  return [...carry.merged_issues ?? [], issue];
 }
-function clear_stale(target, is_gone2 = is_owner_gone) {
-  const raw = stale_record(target, is_gone2);
-  if (raw === void 0) return;
-  const aside = move_aside(target);
-  if (aside === void 0) return;
-  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
-  rmSync2(aside, { force: true });
+function is_duplicate_merge(carry, change) {
+  const issue = change.merged_issue;
+  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
 }
-function claim(target) {
-  clear_stale(target);
-  return stamp_file.create_stamp(target, process_identity.own_fields());
+function next_counts(carry, change) {
+  const cuts = change.cuts ?? NO_INCREMENT2;
+  return {
+    merged: carry.merged + (change.merged ?? NO_INCREMENT2),
+    filed: carry.filed + (change.filed ?? NO_INCREMENT2),
+    cuts: carry.cuts + cuts,
+    is_handed_off: cuts > NO_INCREMENT2
+  };
 }
-function release(target) {
-  const owner = read_owner(target);
-  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
-    stamp_file.remove_stamp(target);
-  }
+function apply_change(target, carry, change, now = /* @__PURE__ */ new Date()) {
+  if (is_duplicate_merge(carry, change)) return carry;
+  const streak = run_carry_streak.next_state(carry, change, now);
+  const next = {
+    ...carry,
+    ...next_counts(carry, change),
+    merged_issues: next_merged_issues(carry, change.merged_issue),
+    failures: streak.failures,
+    outages: streak.outages,
+    last_outage_at: streak.last_outage_at,
+    done: next_done(carry, change.done),
+    retrospective: change.retrospective === true || carry.retrospective
+  };
+  stamp_file.write_stamp(target, next);
+  return next;
 }
-async function acquire(target, max_wait_ms) {
-  const deadline = Date.now() + max_wait_ms;
-  while (!claim(target)) {
-    if (Date.now() >= deadline) return false;
-    await sleep(POLL_INTERVAL_MS);
-  }
-  return true;
+var run_carry_change = { apply_change };
+
+// scripts/backlog/backlog-budget-cli.ts
+import { fileURLToPath } from "node:url";
+
+// scripts/git/changed-paths.ts
+function to_paths(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
 }
-async function with_lock(work, target, max_wait_ms) {
-  if (!await acquire(target, max_wait_ms)) return void 0;
-  try {
-    return await work();
-  } finally {
-    release(target);
-  }
+async function read_changed_paths(is_staged) {
+  if (is_staged) return to_paths(await git_command.diff_cached_names());
+  const tracked = to_paths(await git_command.diff_main_names());
+  const untracked = to_paths(await git_command.untracked_names());
+  return [...tracked, ...untracked];
 }
-var repository_lock = { clear_stale, lock_path, with_lock };
+var changed_paths = { read_changed_paths, to_paths };
 
-// scripts/git/git-worktree.ts
-var WORKTREE = "worktree";
-var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
-var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
-async function locked(arguments_) {
-  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
-  const output = await repository_lock.with_lock(
-    async () => await git_spawn.read(arguments_),
-    target,
-    WORKTREE_LOCK_MAX_WAIT_MS
-  );
-  if (output === void 0) {
-    throw new Error(
-      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
-    );
-  }
-  return output;
-}
-async function worktree_list() {
-  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
-}
-async function worktree_add(directory, branch_name, start_point) {
-  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
-  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name]);
-}
-async function worktree_add_detached(directory, commit2) {
-  return await locked([WORKTREE, "add", "--detach", directory, commit2]);
+// scripts/josh/path-decision.ts
+var STAGED_FLAG = "--staged";
+var JSON_FLAG = "--json";
+var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
+var FAILURE_EXIT_CODE = 1;
+var MAX_LISTED_PATHS = 5;
+function has_unknown_flag(argv, known) {
+  return argv.some((argument) => !known.includes(argument));
 }
-async function worktree_remove(directory) {
-  return await locked([WORKTREE, "remove", "--force", directory]);
+function parse_options(argv) {
+  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
+  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
 }
-async function worktree_prune() {
-  return await locked([WORKTREE, "prune"]);
+function format_path_list(paths) {
+  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
+  if (paths.length <= MAX_LISTED_PATHS) return listed;
+  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
 }
-async function ls_remote_branch(branch_name) {
-  return await git_spawn.read(ls_remote_branch_arguments(branch_name));
+function print_decision(key, answer, reason, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [key]: answer, reason }));
+    return;
+  }
+  console.info(answer);
+  console.error(reason);
 }
-async function branch_delete(branch_name) {
-  return await git_spawn.read(["branch", "-D", branch_name]);
+async function run_path_decision(argv, command) {
+  const options = parse_options(argv);
+  if (options === void 0) {
+    console.error(command.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const paths = await changed_paths.read_changed_paths(options.is_staged);
+  const answer = command.decide(paths);
+  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
+  return 0;
 }
-var git_worktree = {
-  branch_delete,
-  ls_remote_branch,
-  worktree_add,
-  worktree_add_detached,
-  worktree_list,
-  worktree_prune,
-  worktree_remove
+var path_decision = {
+  format_path_list,
+  has_unknown_flag,
+  JSON_FLAG,
+  KNOWN_FLAGS,
+  MAX_LISTED_PATHS,
+  parse_options,
+  print_decision,
+  run_path_decision,
+  STAGED_FLAG
 };
 
-// scripts/lane/lane-environment.ts
-var LANE_OUTPUT_KEY = "JOSH_LANE_OUTPUT";
-var LANE_PROVIDER_KEY = "JOSH_LANE_AGENT_PROVIDER";
-var LANE_ROLE_KEY = "JOSH_LANE_AGENT_ROLE";
-var LANE_MODEL_KEY = "JOSH_LANE_AGENT_MODEL";
-var LANE_EFFORT_KEY = "JOSH_LANE_AGENT_EFFORT";
-var ASSIGNMENT_SEPARATOR = "=";
-var EXPORT_PREFIX = "export ";
-var QUOTE_CHARACTERS = /* @__PURE__ */ new Set(['"', "'"]);
-var MIN_QUOTED_LENGTH = 2;
-var FIRST_CHARACTER_END = 1;
-var LAST_CHARACTER_START = -1;
-function strip_export(line) {
-  const trimmed2 = line.trimStart();
-  return trimmed2.startsWith(EXPORT_PREFIX) ? trimmed2.slice(EXPORT_PREFIX.length).trimStart() : trimmed2;
+// scripts/lib/cli-flags.ts
+import { parseArgs } from "node:util";
+function refuse_unknown_flags(argv, known_flags, command) {
+  const unknown = argv.filter((argument) => !known_flags.includes(argument));
+  if (unknown.length === 0) return void 0;
+  const usage = `Usage: josh ${command} [${known_flags.join("] [")}]`;
+  return `Unknown argument(s): ${unknown.join(" ")}
+${usage}`;
+}
+function parse_or_undefined(config) {
+  try {
+    return parseArgs(config);
+  } catch {
+    return void 0;
+  }
 }
-function is_key_line(line, key) {
-  const body = strip_export(line);
-  if (!body.startsWith(key)) return false;
-  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
+var cli_flags = { refuse_unknown_flags, parse_or_undefined };
+
+// scripts/backlog/backlog-budget-cli.ts
+var ARGV_OFFSET = 2;
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE2 = 1;
+var JSON_KEY = "budget";
+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" },
+  answer: { type: "string" },
+  idle: { type: "string" },
+  json: { type: "boolean" },
+  max: { type: "string" },
+  merged: { type: "string" },
+  running: { type: "string" },
+  started: { type: "string" }
+};
+function read_arguments(argv) {
+  return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS, strict: true })?.values;
 }
-function is_seed_line(line) {
-  return is_key_line(line, PORT_SEED_KEY);
+function text_of(value) {
+  return typeof value === "string" ? value : void 0;
 }
-function is_seat_line(line) {
-  return is_key_line(line, LANE_SEAT_KEY);
+function to_answer(raw) {
+  return backlog_budget.ANSWERS.find((answer) => answer === raw);
 }
-function is_output_line(line) {
-  return is_key_line(line, LANE_OUTPUT_KEY);
+function to_time_ms(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? void 0 : parsed;
 }
-function split_lines(content) {
-  const trimmed2 = content.trimEnd();
-  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
+var COUNT_PATTERN = /^\d+$/u;
+function to_count(raw) {
+  if (raw === void 0 || !COUNT_PATTERN.test(raw)) return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
 }
-function is_quoted(raw) {
-  const first = raw.slice(0, FIRST_CHARACTER_END);
-  if (!QUOTE_CHARACTERS.has(first)) return false;
-  return raw.length >= MIN_QUOTED_LENGTH && raw.endsWith(first);
+function is_readable(raw, parsed) {
+  return raw === void 0 || parsed !== void 0;
 }
-function unquote(raw) {
-  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : raw;
+var COUNT_NAMES = ["idle", "max", "merged", "running"];
+function counts_of(values) {
+  return {
+    idle: to_count(text_of(values.idle)),
+    max: to_count(text_of(values.max)),
+    merged: to_count(text_of(values.merged)),
+    running: to_count(text_of(values.running))
+  };
 }
-function assignment_value(line) {
-  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
+function are_counts_readable(values, counts) {
+  return COUNT_NAMES.every((name) => is_readable(text_of(values[name]), counts[name]));
 }
-function read_assignment(content, key) {
-  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
-  return line === void 0 ? void 0 : assignment_value(line);
+var NO_IDLE_MINUTES = 0;
+function to_idle_ms(idle_minutes) {
+  if (idle_minutes === void 0) return backlog_budget.DEFAULT_IDLE_MS;
+  if (idle_minutes === NO_IDLE_MINUTES) return void 0;
+  return idle_minutes * backlog_budget.MS_PER_MINUTE;
 }
-function read_root_seed(content) {
-  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
+function is_watch_readable(values) {
+  if (to_idle_ms(to_count(text_of(values.idle))) === void 0) return true;
+  return text_of(values.active) !== void 0;
 }
-function read_lane_seat(content) {
-  const raw = read_assignment(content, LANE_SEAT_KEY);
-  return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
+function are_values_readable(values) {
+  return is_readable(text_of(values.active), to_time_ms(text_of(values.active))) && is_watch_readable(values) && are_counts_readable(values, counts_of(values));
 }
-function read_lane_ports(content) {
-  const environment = {
-    [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
-    [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
-  };
+function input_of(values, base) {
+  const counts = counts_of(values);
   return {
-    development: ports.resolve_development_port(environment),
-    preview: ports.resolve_preview_port(environment)
+    ...base,
+    active_at_ms: to_time_ms(text_of(values.active)) ?? base.started_at_ms,
+    merged: counts.merged ?? 0,
+    running: counts.running ?? 0,
+    max_issues: counts.max,
+    idle_budget_ms: to_idle_ms(counts.idle)
   };
 }
-function read_lane_output(content) {
-  const line = split_lines(content).findLast((entry) => is_output_line(entry));
-  const raw = line === void 0 ? void 0 : assignment_value(line);
-  return raw === void 0 || raw.length === 0 ? void 0 : raw;
-}
-function read_lane_profile(content) {
-  return agent_role_profile.parse({
-    provider: read_assignment(content, LANE_PROVIDER_KEY),
-    role: read_assignment(content, LANE_ROLE_KEY),
-    model: read_assignment(content, LANE_MODEL_KEY),
-    effort: read_assignment(content, LANE_EFFORT_KEY)
-  });
+function build_input(values, now_ms) {
+  const answer = to_answer(text_of(values.answer));
+  if (answer === void 0) return void 0;
+  const started_at_ms = to_time_ms(text_of(values.started));
+  if (started_at_ms === void 0) return void 0;
+  if (!are_values_readable(values)) return void 0;
+  return input_of(values, { answer, now_ms, started_at_ms });
 }
-function replace_assignment(lines, keep, assignment, key) {
-  return lines.flatMap((entry, index) => {
-    if (index === keep) return [assignment];
-    return is_key_line(entry, key) ? [] : [entry];
-  });
+function refuse() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE2;
 }
-function upsert_assignment(content, key, value) {
-  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
-  const lines = split_lines(content);
-  const last = lines.findLastIndex((entry) => is_key_line(entry, key));
-  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
-  return `${body.join("\n")}
-`;
+function run(argv, now_ms = Date.now()) {
+  const values = read_arguments(argv);
+  if (values === void 0) return refuse();
+  const input = build_input(values, now_ms);
+  if (input === void 0) return refuse();
+  const { verdict, reason } = backlog_budget.decide(input);
+  if (values.json === true) {
+    console.info(
+      JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: backlog_budget.is_finish(input) })
+    );
+    return SUCCESS_EXIT_CODE;
+  }
+  path_decision.print_decision(JSON_KEY, verdict, reason, false);
+  return SUCCESS_EXIT_CODE;
 }
-function lane_file_content(root_content, seat) {
-  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
+function main(argv) {
+  process.exitCode = run(argv);
 }
-function with_lane_output(content, output, profile) {
-  const recorded = upsert_assignment(content, LANE_OUTPUT_KEY, `"${output}"`);
-  if (profile === void 0) return recorded;
-  const with_provider = upsert_assignment(recorded, LANE_PROVIDER_KEY, profile.provider);
-  const with_role = upsert_assignment(with_provider, LANE_ROLE_KEY, profile.role);
-  const with_model = upsert_assignment(with_role, LANE_MODEL_KEY, profile.model);
-  return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
-}
-var lane_environment = {
-  LANE_OUTPUT_KEY,
-  LANE_PROVIDER_KEY,
-  LANE_ROLE_KEY,
-  is_output_line,
-  is_seat_line,
-  is_seed_line,
-  lane_file_content,
-  read_lane_output,
-  read_lane_profile,
-  read_lane_ports,
-  read_lane_seat,
-  read_root_seed,
-  with_lane_output
+var backlog_budget_cli = {
+  JSON_KEY,
+  OPTIONS,
+  SUCCESS_EXIT_CODE,
+  USAGE,
+  build_input,
+  main,
+  read_arguments,
+  run,
+  to_answer,
+  to_count,
+  to_time_ms
 };
+if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
 
-// scripts/lane/lane-registry.ts
-var WORKTREE_PREFIX = "worktree ";
-var BRANCH_PREFIX = "branch refs/heads/";
-var BLOCK_SEPARATOR = "\n\n";
-var ISSUE_PATTERN = /^[1-9]\d*$/u;
-function line_value(lines, prefix) {
-  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
+// scripts/run/run-invocation.ts
+var BACKLOG_COMMAND = "backlogrun";
+var KNOWN_FLAGS2 = ["--max", "--idle"];
+var ONLY_FLAG = "--only";
+var ISSUE_PREFIX = "#";
+var TOKEN_SEPARATOR = " ";
+var FIRST_TOKEN = 0;
+var FIRST_ARGUMENT_INDEX = 1;
+var VALUE_OFFSET = 1;
+var FLAG_PAIR_LENGTH = 2;
+var ONLY_STEP = 1;
+var EMPTY_LENGTH2 = 0;
+var NOT_FOUND2 = -1;
+function tokens_of(invocation) {
+  return invocation.split(TOKEN_SEPARATOR).filter((token) => token.length > EMPTY_LENGTH2);
 }
-function seat_from_content(content) {
-  const seat = lane_environment.read_lane_seat(content);
-  if (seat === void 0) return void 0;
-  const port_pair = lane_environment.read_lane_ports(content);
-  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
+function flag_token(token, raw) {
+  const flag = KNOWN_FLAGS2.find((known) => known === token);
+  const value = backlog_budget_cli.to_count(raw);
+  if (flag === void 0 || value === void 0) return void 0;
+  return `${flag} ${String(value)}`;
 }
-var EMPTY_SEAT = {
-  seat: void 0,
-  development_port: void 0,
-  preview_port: void 0
+function read_flag(tokens, index) {
+  const token = tokens[index] ?? "";
+  if (token === ONLY_FLAG) return { part: ONLY_FLAG, advance: ONLY_STEP };
+  const part = flag_token(token, tokens[index + VALUE_OFFSET]);
+  return part === void 0 ? void 0 : { part, advance: FLAG_PAIR_LENGTH };
+}
+function flag_tokens(tokens, start) {
+  const rendered = [];
+  let index = start;
+  while (index < tokens.length) {
+    const read2 = read_flag(tokens, index);
+    if (read2 === void 0) return void 0;
+    rendered.push(read2.part);
+    index += read2.advance;
+  }
+  return rendered;
+}
+function issue_of(token) {
+  if (!token.startsWith(ISSUE_PREFIX)) return void 0;
+  const digits = token.slice(ISSUE_PREFIX.length);
+  if (!run_issue_number.ISSUE_NUMBER_PATTERN.test(digits)) return void 0;
+  const issue = Number(digits);
+  return Number.isSafeInteger(issue) ? issue : void 0;
+}
+function take_leading_prefixed(args) {
+  const stop = args.findIndex((token) => !token.startsWith(ISSUE_PREFIX));
+  return args.slice(FIRST_TOKEN, stop === NOT_FOUND2 ? args.length : stop);
+}
+function leading_issues(tokens) {
+  const issues = [];
+  const prefixed = take_leading_prefixed(tokens.slice(FIRST_ARGUMENT_INDEX));
+  for (const token of prefixed) {
+    const issue = issue_of(token);
+    if (issue === void 0) return void 0;
+    issues.push(issue);
+  }
+  return issues;
+}
+function issue_token(issue) {
+  return `${ISSUE_PREFIX}${String(issue)}`;
+}
+function joined(command, rendered) {
+  return [command, ...rendered].join(TOKEN_SEPARATOR);
+}
+function rebuilt_backlog(tokens) {
+  const issues = leading_issues(tokens);
+  if (issues === void 0) return void 0;
+  const flags = flag_tokens(tokens, FIRST_ARGUMENT_INDEX + issues.length);
+  if (flags === void 0) return void 0;
+  return joined(BACKLOG_COMMAND, [...issues.map((issue) => issue_token(issue)), ...flags]);
+}
+function rebuild(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  return rebuilt_backlog(tokens);
+}
+function issue_numbers(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  const issues = leading_issues(tokens);
+  if (issues === void 0 || issues.length === EMPTY_LENGTH2) return void 0;
+  return issues;
+}
+function has_only(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return false;
+  return tokens.slice(FIRST_ARGUMENT_INDEX).includes(ONLY_FLAG);
+}
+var run_invocation = {
+  has_only,
+  issue_numbers,
+  rebuild
 };
-function held_seat(content) {
-  if (content === void 0) return EMPTY_SEAT;
-  return seat_from_content(content) ?? EMPTY_SEAT;
+
+// scripts/run/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_COMMAND2 = "pnpm josh run:carry --end";
+var RESUME_COMMAND = "pnpm josh run:carry --resume";
+var READ_COMMAND2 = "pnpm josh run:carry --json";
+var OWNER_ARGUMENT = '--owner "$PPID"';
+var NONE_READ2 = { kind: "none" };
+var UNREADABLE_READ3 = { kind: "unreadable" };
+var NO_OWNER = {};
+var run_carry_schema = z5.object({
+  invocation: z5.string(),
+  started_at: z5.string(),
+  merged: z5.number(),
+  merged_issues: z5.array(z5.number()).optional(),
+  filed: z5.number(),
+  cuts: z5.number(),
+  // Defaulted, so a record written before this field existed parses with a zero streak rather than
+  // failing to read — the same backward-compatibility the optional owner fields below carry.
+  failures: z5.number().default(0),
+  // Defaulted for the same backward-compatibility as `failures` (joshuafolkken/kit#2240).
+  outages: z5.number().default(0),
+  // Optional, so a record written before the outage fold existed still parses (joshuafolkken/kit#2317).
+  last_outage_at: z5.string().optional(),
+  // Optional, so a record written by the previous shape still parses. Read as "no owner declared",
+  // which is the not-provably-live answer rather than a live one.
+  owner_pid: z5.number().optional(),
+  owner_start: z5.string().optional(),
+  is_handed_off: z5.boolean().optional(),
+  done: z5.array(z5.number()).optional(),
+  // Optional, so a record written before the retrospective existed still parses (joshuafolkken/kit#2328).
+  retrospective: z5.boolean().optional()
+});
+function carry_path(git_directory) {
+  return stamp_file.stamp_path(CARRY_PREFIX, git_directory);
 }
-function read_environment(directory) {
+async function repository_directory() {
+  const directories = await git_command.git_directories();
+  return directories[REPOSITORY_DIRECTORY_INDEX];
+}
+function parse_carry(raw) {
   try {
-    return readFileSync4(path3.join(directory, ENV_FILE_NAME), "utf8");
+    const parsed = run_carry_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
   } catch {
     return void 0;
   }
 }
-function branch_issue(branch2) {
-  if (!branch2?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
-  const issue = branch2.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
-  return ISSUE_PATTERN.test(issue) ? issue : void 0;
-}
-function is_gone(directory) {
-  return !existsSync2(directory);
-}
-function build_lane(issue, branch2, directory, is_stranded) {
-  const content = is_stranded ? void 0 : read_environment(directory);
-  const held = held_seat(content);
-  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
-  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
-  return {
-    issue,
-    branch: branch2,
-    directory,
-    seat: held.seat,
-    development_port: held.development_port,
-    preview_port: held.preview_port,
-    output,
-    profile,
-    is_stranded
-  };
+function is_expired2(carry, now) {
+  const started = Date.parse(carry.started_at);
+  if (Number.isNaN(started)) return true;
+  return now.getTime() - started > CARRY_MAX_AGE_MS;
 }
-function is_lane_directory(root, issue, directory) {
-  return directory === lane_paths.lane_directory(root, issue);
+function classify4(raw, now) {
+  if (raw === void 0) return NONE_READ2;
+  const carry = parse_carry(raw);
+  if (carry === void 0) return UNREADABLE_READ3;
+  return { kind: is_expired2(carry, now) ? "expired" : "carried", carry };
 }
-function parse_block(block, root) {
-  const lines = block.split("\n");
-  const directory = line_value(lines, WORKTREE_PREFIX);
-  const branch2 = line_value(lines, BRANCH_PREFIX);
-  const issue = branch_issue(branch2);
-  if (directory === void 0 || branch2 === void 0 || issue === void 0) return void 0;
-  if (!is_lane_directory(root, issue, directory)) return void 0;
-  return build_lane(issue, branch2, directory, is_gone(directory));
+function read_carry(target, now = /* @__PURE__ */ new Date()) {
+  return classify4(stamp_file.read_stamp_text(target), now);
 }
-function is_lane(lane) {
-  return lane !== void 0;
+function owner_of(pid, read2 = process_identity.read_start) {
+  return { pid, start: read2(pid) };
 }
-async function worktree_blocks() {
-  const listing = await git_worktree.worktree_list();
-  return listing.split(BLOCK_SEPARATOR);
+function fresh_carry(invocation, owner, now) {
+  return {
+    invocation,
+    started_at: now.toISOString(),
+    merged: NO_INCREMENT3,
+    filed: NO_INCREMENT3,
+    cuts: NO_INCREMENT3,
+    failures: NO_INCREMENT3,
+    outages: NO_INCREMENT3,
+    owner_pid: owner.pid,
+    owner_start: owner.start
+  };
 }
-async function main_repository_root() {
-  return repo_discovery.main_worktree(await git_command.repository_root());
+function begin_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+  const carry = fresh_carry(invocation, owner, now);
+  return stamp_file.create_stamp(target, carry) ? carry : void 0;
 }
-async function list_lanes() {
-  const root = lane_paths.lane_root(await main_repository_root());
-  const blocks = await worktree_blocks();
-  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
-  return lanes.toSorted((left, right) => Number(left.issue) - Number(right.issue));
+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 used_seats(lanes) {
-  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
+function adopt_carry(target, carry, owner = NO_OWNER) {
+  const next = {
+    ...carry,
+    owner_pid: owner.pid,
+    owner_start: owner.start,
+    is_handed_off: false
+  };
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, next) ? next : void 0;
 }
-function unreadable_lanes(lanes) {
-  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
+function is_owner_live(carry) {
+  return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false;
 }
-function find_lane(lanes, issue) {
-  return lanes.find((lane) => lane.issue === issue);
+function is_owned_by(carry, owner) {
+  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
 }
-async function find_open_lane(issue) {
-  return find_lane(await list_lanes(), issue);
+function is_foreign_live_owner(carry, owner) {
+  return is_owner_live(carry) && !is_owned_by(carry, owner);
 }
-var lane_registry = {
-  find_lane,
-  find_open_lane,
-  list_lanes,
-  main_repository_root,
-  parse_block,
-  read_environment,
-  unreadable_lanes,
-  used_seats
-};
-
-// scripts/backlog/backlog-budget-cli.ts
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-
-// scripts/git/changed-paths.ts
-function to_paths(raw) {
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+function is_handed_off_to(carry, invocation) {
+  return carry.is_handed_off === true && carry.invocation === invocation;
 }
-async function read_changed_paths(is_staged) {
-  if (is_staged) return to_paths(await git_command.diff_cached_names());
-  const tracked = to_paths(await git_command.diff_main_names());
-  const untracked = to_paths(await git_command.untracked_names());
-  return [...tracked, ...untracked];
+function classify_claim(carry, request) {
+  if (is_handed_off_to(carry, request.invocation)) return "resume";
+  if (is_foreign_live_owner(carry, request.owner)) return "busy";
+  if (carry.invocation !== request.invocation) return "mismatch";
+  return request.is_adoption ? "resume" : "standing";
 }
-var changed_paths = { read_changed_paths, to_paths };
-
-// scripts/josh/path-decision.ts
-var STAGED_FLAG = "--staged";
-var JSON_FLAG = "--json";
-var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
-var FAILURE_EXIT_CODE = 1;
-var MAX_LISTED_PATHS = 5;
-function has_unknown_flag(argv, known) {
-  return argv.some((argument) => !known.includes(argument));
+function is_count_refused(carry, owner) {
+  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
 }
-function parse_options(argv) {
-  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
-  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
+function is_at_cut_cap(carry) {
+  return carry.cuts >= MAX_CUTS;
 }
-function format_path_list(paths) {
-  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
-  if (paths.length <= MAX_LISTED_PATHS) return listed;
-  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
+function end_carry(target) {
+  stamp_file.remove_stamp(target);
 }
-function print_decision(key, answer, reason, is_json) {
-  if (is_json) {
-    console.info(JSON.stringify({ [key]: answer, reason }));
-    return;
-  }
-  console.info(answer);
-  console.error(reason);
+function retrospective_done_of(read2) {
+  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
+  return read2.carry.retrospective === true;
 }
-async function run_path_decision(argv, command) {
-  const options = parse_options(argv);
-  if (options === void 0) {
-    console.error(command.usage);
-    return FAILURE_EXIT_CODE;
-  }
-  const paths = await changed_paths.read_changed_paths(options.is_staged);
-  const answer = command.decide(paths);
-  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
-  return 0;
+function remaining_of(carry) {
+  if (carry === void 0) return void 0;
+  const declared = run_invocation.issue_numbers(carry.invocation);
+  if (declared === void 0) return void 0;
+  const done = carry.done ?? [];
+  return declared.filter((issue) => !done.includes(issue));
 }
-var path_decision = {
-  format_path_list,
-  has_unknown_flag,
-  JSON_FLAG,
-  KNOWN_FLAGS,
-  MAX_LISTED_PATHS,
-  parse_options,
-  print_decision,
-  run_path_decision,
-  STAGED_FLAG
-};
-
-// scripts/backlog/backlog-budget-cli.ts
-var ARGV_OFFSET = 2;
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE2 = 1;
-var JSON_KEY = "budget";
-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" },
-  answer: { type: "string" },
-  idle: { type: "string" },
-  json: { type: "boolean" },
-  max: { type: "string" },
-  merged: { type: "string" },
-  running: { type: "string" },
-  started: { type: "string" }
-};
-function read_arguments(argv) {
-  try {
-    return parseArgs({ args: [...argv], options: OPTIONS, strict: true }).values;
-  } catch {
-    return void 0;
-  }
+function done_note(carry) {
+  const done = carry.done ?? [];
+  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
 }
-function text_of(value) {
-  return typeof value === "string" ? value : void 0;
+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 to_answer(raw) {
-  return backlog_budget.ANSWERS.find((answer) => answer === raw);
+function expired_message(carry) {
+  return `The ${String(CARRY_MAX_AGE_HOURS)}-hour whole-run bound is spent: ${describe_carry(carry)}. Clear it with \`${END_COMMAND2}\`.`;
 }
-function to_time_ms(raw) {
-  if (raw === void 0) return void 0;
-  const parsed = Date.parse(raw);
-  return Number.isNaN(parsed) ? void 0 : parsed;
+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_COMMAND2}\` once you know its run is over, then begin again.`;
 }
-var COUNT_PATTERN = /^\d+$/u;
-function to_count(raw) {
-  if (raw === void 0 || !COUNT_PATTERN.test(raw)) return void 0;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) ? parsed : void 0;
+function busy_message2(carry) {
+  return `A live run holds this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was established. Wait for that run, or end its record with \`${END_COMMAND2}\` once you know it is over.`;
 }
-function is_readable(raw, parsed) {
-  return raw === void 0 || parsed !== void 0;
+function standing_message(carry) {
+  return `A run record is standing here that no cut handed off \u2014 ${describe_carry(carry)}. Nothing was established. Carry that budget with \`${RESUME_COMMAND} "${carry.invocation}" ${OWNER_ARGUMENT}\`, or discard it with \`${END_COMMAND2}\` and begin again.`;
 }
-var COUNT_NAMES = ["idle", "max", "merged", "running"];
-function counts_of(values) {
-  return {
-    idle: to_count(text_of(values.idle)),
-    max: to_count(text_of(values.max)),
-    merged: to_count(text_of(values.merged)),
-    running: to_count(text_of(values.running))
-  };
+function count_refused_message(carry) {
+  if (carry.is_handed_off === true) {
+    return `This budget was handed off at a cut and is waiting for its successor \u2014 ${describe_carry(carry)}. Nothing was counted; the cutting session must not advance a handed-off budget.`;
+  }
+  return `A live run owns this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was counted; only its owner advances the budget.`;
 }
-function are_counts_readable(values, counts) {
-  return COUNT_NAMES.every((name) => is_readable(text_of(values[name]), counts[name]));
+function lost_message() {
+  return `Another process established a run record here first, so nothing was established. Read it with \`${READ_COMMAND2}\`.`;
 }
-var NO_IDLE_MINUTES = 0;
-function to_idle_ms(idle_minutes) {
-  if (idle_minutes === void 0) return backlog_budget.DEFAULT_IDLE_MS;
-  if (idle_minutes === NO_IDLE_MINUTES) return void 0;
-  return idle_minutes * backlog_budget.MS_PER_MINUTE;
+function nothing_to_resume_message() {
+  return `Nothing is carried here, so there is no budget to resume. Begin one with \`pnpm josh run:carry --begin "<invocation>"\`.`;
 }
-function is_watch_readable(values) {
-  if (to_idle_ms(to_count(text_of(values.idle))) === void 0) return true;
-  return text_of(values.active) !== void 0;
+function unreadable_message3() {
+  return `A run record is here but could not be read; clear it with \`${END_COMMAND2}\` once you know no run is using it.`;
 }
-function are_values_readable(values) {
-  return is_readable(text_of(values.active), to_time_ms(text_of(values.active))) && is_watch_readable(values) && are_counts_readable(values, counts_of(values));
+function unknown_message3() {
+  return "This repository\u2019s git directory could not be read, so no run record was established.";
 }
-function input_of(values, base) {
-  const counts = counts_of(values);
-  return {
-    ...base,
-    active_at_ms: to_time_ms(text_of(values.active)) ?? base.started_at_ms,
-    merged: counts.merged ?? 0,
-    running: counts.running ?? 0,
-    max_issues: counts.max,
-    idle_budget_ms: to_idle_ms(counts.idle)
-  };
+var run_carry = {
+  CARRY_MAX_AGE_HOURS,
+  CARRY_MAX_AGE_MS,
+  END_COMMAND: END_COMMAND2,
+  MAX_CUTS,
+  NO_OWNER,
+  RESUME_COMMAND,
+  adopt_carry,
+  apply_change: run_carry_change.apply_change,
+  begin_carry,
+  busy_message: busy_message2,
+  carry_path,
+  classify: classify4,
+  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_expired2,
+  is_foreign_live_owner,
+  is_owner_live,
+  lost_message,
+  nothing_to_resume_message,
+  owner_of,
+  parse_carry,
+  read_carry,
+  remaining_of,
+  replace_carry,
+  repository_directory,
+  retrospective_done_of,
+  standing_message,
+  unknown_message: unknown_message3,
+  unreadable_message: unreadable_message3
+};
+
+// scripts/lane/lane-registry.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path3 from "node:path";
+
+// scripts/git/git-ls-remote.ts
+var LS_REMOTE_COMMAND = "ls-remote";
+var HEADS_FLAG = "--heads";
+var ORIGIN_REMOTE = "origin";
+var HEADS_REF_PREFIX = "refs/heads/";
+function ls_remote_branch_arguments(branch_name) {
+  return [LS_REMOTE_COMMAND, HEADS_FLAG, ORIGIN_REMOTE, `${HEADS_REF_PREFIX}${branch_name}`];
 }
-function build_input(values, now_ms) {
-  const answer = to_answer(text_of(values.answer));
-  if (answer === void 0) return void 0;
-  const started_at_ms = to_time_ms(text_of(values.started));
-  if (started_at_ms === void 0) return void 0;
-  if (!are_values_readable(values)) return void 0;
-  return input_of(values, { answer, now_ms, started_at_ms });
+
+// scripts/git/repository-lock.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// scripts/git/git-common-directory.ts
+import { execFileSync as execFileSync4 } from "node:child_process";
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS3 = 2e3;
+function read_directories(cwd) {
+  const git = git_utilities.get_git_command_for_spawn();
+  const output = execFileSync4(git, [...git_command.GIT_DIRECTORY_ARGUMENTS], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: PROBE_TIMEOUT_MS3
+  });
+  return output.trim().split("\n");
 }
-function refuse() {
-  console.error(USAGE);
-  return FAILURE_EXIT_CODE2;
+function select_linked(directories) {
+  const own = directories[OWN_GIT_DIRECTORY];
+  const common = directories[COMMON_GIT_DIRECTORY];
+  return own !== void 0 && common !== void 0 && own !== common ? common : void 0;
 }
-function run(argv, now_ms = Date.now()) {
-  const values = read_arguments(argv);
-  if (values === void 0) return refuse();
-  const input = build_input(values, now_ms);
-  if (input === void 0) return refuse();
-  const { verdict, reason } = backlog_budget.decide(input);
-  if (values.json === true) {
-    console.info(
-      JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: backlog_budget.is_finish(input) })
-    );
-    return SUCCESS_EXIT_CODE;
+function resolve2(cwd) {
+  try {
+    return select_linked(read_directories(cwd));
+  } catch {
+    return void 0;
   }
-  path_decision.print_decision(JSON_KEY, verdict, reason, false);
-  return SUCCESS_EXIT_CODE;
 }
-function main(argv) {
-  process.exitCode = run(argv);
+function repository(cwd) {
+  try {
+    return read_directories(cwd)[COMMON_GIT_DIRECTORY];
+  } catch {
+    return void 0;
+  }
 }
-var backlog_budget_cli = {
-  JSON_KEY,
-  OPTIONS,
-  SUCCESS_EXIT_CODE,
-  USAGE,
-  build_input,
-  main,
-  read_arguments,
-  run,
-  to_answer,
-  to_count,
-  to_time_ms
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
+var git_common_directory = { repository, resolve: resolve2, select_linked };
 
-// scripts/run/run-invocation.ts
-var BACKLOG_COMMAND = "backlogrun";
-var KNOWN_FLAGS2 = ["--max", "--idle"];
-var ONLY_FLAG = "--only";
-var ISSUE_PREFIX = "#";
-var TOKEN_SEPARATOR = " ";
-var FIRST_TOKEN = 0;
-var FIRST_ARGUMENT_INDEX = 1;
-var VALUE_OFFSET = 1;
-var FLAG_PAIR_LENGTH = 2;
-var ONLY_STEP = 1;
-var EMPTY_LENGTH2 = 0;
-var NOT_FOUND2 = -1;
-function tokens_of(invocation) {
-  return invocation.split(TOKEN_SEPARATOR).filter((token) => token.length > EMPTY_LENGTH2);
-}
-function flag_token(token, raw) {
-  const flag = KNOWN_FLAGS2.find((known) => known === token);
-  const value = backlog_budget_cli.to_count(raw);
-  if (flag === void 0 || value === void 0) return void 0;
-  return `${flag} ${String(value)}`;
-}
-function read_flag(tokens, index) {
-  const token = tokens[index] ?? "";
-  if (token === ONLY_FLAG) return { part: ONLY_FLAG, advance: ONLY_STEP };
-  const part = flag_token(token, tokens[index + VALUE_OFFSET]);
-  return part === void 0 ? void 0 : { part, advance: FLAG_PAIR_LENGTH };
+// scripts/git/repository-lock.ts
+var POLL_INTERVAL_MS = 200;
+function lock_path(prefix, cwd = process.cwd()) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd);
 }
-function flag_tokens(tokens, start) {
-  const rendered = [];
-  let index = start;
-  while (index < tokens.length) {
-    const read2 = read_flag(tokens, index);
-    if (read2 === void 0) return void 0;
-    rendered.push(read2.part);
-    index += read2.advance;
+function parse_owner(raw) {
+  if (raw === void 0) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
   }
-  return rendered;
 }
-function issue_of(token) {
-  if (!token.startsWith(ISSUE_PREFIX)) return void 0;
-  const digits = token.slice(ISSUE_PREFIX.length);
-  if (!run_issue_number.ISSUE_NUMBER_PATTERN.test(digits)) return void 0;
-  const issue = Number(digits);
-  return Number.isSafeInteger(issue) ? issue : void 0;
+function read_owner(target) {
+  return parse_owner(stamp_file.read_stamp_text(target));
 }
-function take_leading_prefixed(args) {
-  const stop = args.findIndex((token) => !token.startsWith(ISSUE_PREFIX));
-  return args.slice(FIRST_TOKEN, stop === NOT_FOUND2 ? args.length : stop);
+function is_owner_gone(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
 }
-function leading_issues(tokens) {
-  const issues = [];
-  const prefixed = take_leading_prefixed(tokens.slice(FIRST_ARGUMENT_INDEX));
-  for (const token of prefixed) {
-    const issue = issue_of(token);
-    if (issue === void 0) return void 0;
-    issues.push(issue);
+function restore(aside, target) {
+  try {
+    linkSync(aside, target);
+  } catch {
   }
-  return issues;
 }
-function issue_token(issue) {
-  return `${ISSUE_PREFIX}${String(issue)}`;
+function stale_record(target, is_gone2) {
+  const raw = stamp_file.read_stamp_text(target);
+  const owner = parse_owner(raw);
+  return owner !== void 0 && is_gone2(owner) ? raw : void 0;
 }
-function joined(command, rendered) {
-  return [command, ...rendered].join(TOKEN_SEPARATOR);
+function move_aside(target) {
+  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
+  try {
+    renameSync(target, aside);
+    return aside;
+  } catch {
+    return void 0;
+  }
 }
-function rebuilt_backlog(tokens) {
-  const issues = leading_issues(tokens);
-  if (issues === void 0) return void 0;
-  const flags = flag_tokens(tokens, FIRST_ARGUMENT_INDEX + issues.length);
-  if (flags === void 0) return void 0;
-  return joined(BACKLOG_COMMAND, [...issues.map((issue) => issue_token(issue)), ...flags]);
+function clear_stale(target, is_gone2 = is_owner_gone) {
+  const raw = stale_record(target, is_gone2);
+  if (raw === void 0) return;
+  const aside = move_aside(target);
+  if (aside === void 0) return;
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
+  rmSync2(aside, { force: true });
 }
-function rebuild(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
-  return rebuilt_backlog(tokens);
+function claim(target) {
+  clear_stale(target);
+  return stamp_file.create_stamp(target, process_identity.own_fields());
 }
-function issue_numbers(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
-  const issues = leading_issues(tokens);
-  if (issues === void 0 || issues.length === EMPTY_LENGTH2) return void 0;
-  return issues;
+function release(target) {
+  const owner = read_owner(target);
+  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
+    stamp_file.remove_stamp(target);
+  }
 }
-function has_only(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return false;
-  return tokens.slice(FIRST_ARGUMENT_INDEX).includes(ONLY_FLAG);
+async function acquire(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(POLL_INTERVAL_MS);
+  }
+  return true;
 }
-var run_invocation = {
-  has_only,
-  issue_numbers,
-  rebuild
-};
-
-// scripts/run/run-carry.ts
-import { z as z5 } from "zod";
+async function with_lock(work, target, max_wait_ms) {
+  if (!await acquire(target, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target);
+  }
+}
+var repository_lock = { clear_stale, lock_path, with_lock };
 
-// scripts/run/run-carry-streak.ts
-var NO_INCREMENT = 0;
-var OUTAGE_FOLD_WINDOW_MS = 12e4;
-function has_increment(value) {
-  return (value ?? NO_INCREMENT) > NO_INCREMENT;
+// scripts/git/git-worktree.ts
+var WORKTREE = "worktree";
+var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
+var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
+async function locked(arguments_) {
+  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
+  const output = await repository_lock.with_lock(
+    async () => await git_spawn.read(arguments_),
+    target,
+    WORKTREE_LOCK_MAX_WAIT_MS
+  );
+  if (output === void 0) {
+    throw new Error(
+      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
+    );
+  }
+  return output;
 }
-function next_failures(carry, change) {
-  if (has_increment(change.merged)) return NO_INCREMENT;
-  return carry.failures + (change.failures ?? NO_INCREMENT);
+async function worktree_list() {
+  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
+}
+async function worktree_add(directory, branch_name, start_point) {
+  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
+  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name]);
 }
-function is_within_fold_window(last_outage_at, now) {
-  if (last_outage_at === void 0) return false;
-  const last = Date.parse(last_outage_at);
-  if (Number.isNaN(last)) return false;
-  return now.getTime() - last <= OUTAGE_FOLD_WINDOW_MS;
+async function worktree_add_detached(directory, commit2) {
+  return await locked([WORKTREE, "add", "--detach", directory, commit2]);
 }
-function folded_outage(carry) {
-  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
+async function worktree_remove(directory) {
+  return await locked([WORKTREE, "remove", "--force", directory]);
 }
-function counted_outage(carry, change, now) {
-  const outages = carry.outages + (change.outages ?? NO_INCREMENT);
-  return { outages, last_outage_at: now.toISOString() };
+async function worktree_prune() {
+  return await locked([WORKTREE, "prune"]);
 }
-function next_outage(carry, change, now) {
-  if (has_increment(change.outages)) {
-    return is_within_fold_window(carry.last_outage_at, now) ? folded_outage(carry) : counted_outage(carry, change, now);
-  }
-  const is_reachable = has_increment(change.merged) || has_increment(change.failures);
-  return is_reachable ? { outages: NO_INCREMENT, last_outage_at: void 0 } : folded_outage(carry);
+async function ls_remote_branch(branch_name) {
+  return await git_spawn.read(ls_remote_branch_arguments(branch_name));
 }
-function next_state(carry, change, now) {
-  const outage = next_outage(carry, change, now);
-  return {
-    failures: next_failures(carry, change),
-    outages: outage.outages,
-    last_outage_at: outage.last_outage_at
-  };
+async function branch_delete(branch_name) {
+  return await git_spawn.read(["branch", "-D", branch_name]);
 }
-var run_carry_streak = { OUTAGE_FOLD_WINDOW_MS, next_state };
+var git_worktree = {
+  branch_delete,
+  ls_remote_branch,
+  worktree_add,
+  worktree_add_detached,
+  worktree_list,
+  worktree_prune,
+  worktree_remove
+};
 
-// scripts/run/run-carry-change.ts
-var NO_INCREMENT2 = 0;
-function next_done(carry, done) {
-  if (done === void 0) return carry.done;
-  const current = carry.done ?? [];
-  return current.includes(done) ? current : [...current, done];
+// scripts/lane/lane-environment.ts
+var LANE_OUTPUT_KEY = "JOSH_LANE_OUTPUT";
+var LANE_PROVIDER_KEY = "JOSH_LANE_AGENT_PROVIDER";
+var LANE_ROLE_KEY = "JOSH_LANE_AGENT_ROLE";
+var LANE_MODEL_KEY = "JOSH_LANE_AGENT_MODEL";
+var LANE_EFFORT_KEY = "JOSH_LANE_AGENT_EFFORT";
+var ASSIGNMENT_SEPARATOR = "=";
+var EXPORT_PREFIX = "export ";
+var QUOTE_CHARACTERS = /* @__PURE__ */ new Set(['"', "'"]);
+var MIN_QUOTED_LENGTH = 2;
+var FIRST_CHARACTER_END = 1;
+var LAST_CHARACTER_START = -1;
+function strip_export(line) {
+  const trimmed2 = line.trimStart();
+  return trimmed2.startsWith(EXPORT_PREFIX) ? trimmed2.slice(EXPORT_PREFIX.length).trimStart() : trimmed2;
 }
-function next_merged_issues(carry, issue) {
-  if (issue === void 0) return carry.merged_issues;
-  return [...carry.merged_issues ?? [], issue];
+function is_key_line(line, key) {
+  const body = strip_export(line);
+  if (!body.startsWith(key)) return false;
+  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
 }
-function is_duplicate_merge(carry, change) {
-  const issue = change.merged_issue;
-  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
+function is_seed_line(line) {
+  return is_key_line(line, PORT_SEED_KEY);
 }
-function next_counts(carry, change) {
-  const cuts = change.cuts ?? NO_INCREMENT2;
-  return {
-    merged: carry.merged + (change.merged ?? NO_INCREMENT2),
-    filed: carry.filed + (change.filed ?? NO_INCREMENT2),
-    cuts: carry.cuts + cuts,
-    is_handed_off: cuts > NO_INCREMENT2
-  };
+function is_seat_line(line) {
+  return is_key_line(line, LANE_SEAT_KEY);
 }
-function apply_change(target, carry, change, now = /* @__PURE__ */ new Date()) {
-  if (is_duplicate_merge(carry, change)) return carry;
-  const streak = run_carry_streak.next_state(carry, change, now);
-  const next = {
-    ...carry,
-    ...next_counts(carry, change),
-    merged_issues: next_merged_issues(carry, change.merged_issue),
-    failures: streak.failures,
-    outages: streak.outages,
-    last_outage_at: streak.last_outage_at,
-    done: next_done(carry, change.done),
-    retrospective: change.retrospective === true || carry.retrospective
-  };
-  stamp_file.write_stamp(target, next);
-  return next;
+function is_output_line(line) {
+  return is_key_line(line, LANE_OUTPUT_KEY);
 }
-var run_carry_change = { apply_change };
-
-// scripts/run/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_COMMAND2 = "pnpm josh run:carry --end";
-var RESUME_COMMAND = "pnpm josh run:carry --resume";
-var READ_COMMAND2 = "pnpm josh run:carry --json";
-var OWNER_ARGUMENT = '--owner "$PPID"';
-var NONE_READ2 = { kind: "none" };
-var UNREADABLE_READ3 = { kind: "unreadable" };
-var NO_OWNER = {};
-var run_carry_schema = z5.object({
-  invocation: z5.string(),
-  started_at: z5.string(),
-  merged: z5.number(),
-  merged_issues: z5.array(z5.number()).optional(),
-  filed: z5.number(),
-  cuts: z5.number(),
-  // Defaulted, so a record written before this field existed parses with a zero streak rather than
-  // failing to read — the same backward-compatibility the optional owner fields below carry.
-  failures: z5.number().default(0),
-  // Defaulted for the same backward-compatibility as `failures` (joshuafolkken/kit#2240).
-  outages: z5.number().default(0),
-  // Optional, so a record written before the outage fold existed still parses (joshuafolkken/kit#2317).
-  last_outage_at: z5.string().optional(),
-  // Optional, so a record written by the previous shape still parses. Read as "no owner declared",
-  // which is the not-provably-live answer rather than a live one.
-  owner_pid: z5.number().optional(),
-  owner_start: z5.string().optional(),
-  is_handed_off: z5.boolean().optional(),
-  done: z5.array(z5.number()).optional(),
-  // Optional, so a record written before the retrospective existed still parses (joshuafolkken/kit#2328).
-  retrospective: z5.boolean().optional()
-});
-function carry_path(git_directory) {
-  return stamp_file.stamp_path(CARRY_PREFIX, git_directory);
+function split_lines(content) {
+  const trimmed2 = content.trimEnd();
+  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
 }
-async function repository_directory() {
-  const directories = await git_command.git_directories();
-  return directories[REPOSITORY_DIRECTORY_INDEX];
+function is_quoted(raw) {
+  const first = raw.slice(0, FIRST_CHARACTER_END);
+  if (!QUOTE_CHARACTERS.has(first)) return false;
+  return raw.length >= MIN_QUOTED_LENGTH && raw.endsWith(first);
 }
-function parse_carry(raw) {
-  try {
-    const parsed = run_carry_schema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : void 0;
-  } catch {
-    return void 0;
-  }
+function unquote(raw) {
+  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : raw;
 }
-function is_expired2(carry, now) {
-  const started = Date.parse(carry.started_at);
-  if (Number.isNaN(started)) return true;
-  return now.getTime() - started > CARRY_MAX_AGE_MS;
+function assignment_value(line) {
+  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
 }
-function classify4(raw, now) {
-  if (raw === void 0) return NONE_READ2;
-  const carry = parse_carry(raw);
-  if (carry === void 0) return UNREADABLE_READ3;
-  return { kind: is_expired2(carry, now) ? "expired" : "carried", carry };
+function read_assignment(content, key) {
+  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
+  return line === void 0 ? void 0 : assignment_value(line);
 }
-function read_carry(target, now = /* @__PURE__ */ new Date()) {
-  return classify4(stamp_file.read_stamp_text(target), now);
+function read_root_seed(content) {
+  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
 }
-function owner_of(pid, read2 = process_identity.read_start) {
-  return { pid, start: read2(pid) };
+function read_lane_seat(content) {
+  const raw = read_assignment(content, LANE_SEAT_KEY);
+  return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
 }
-function fresh_carry(invocation, owner, now) {
+function read_lane_ports(content) {
+  const environment2 = {
+    [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
+    [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
+  };
   return {
-    invocation,
-    started_at: now.toISOString(),
-    merged: NO_INCREMENT3,
-    filed: NO_INCREMENT3,
-    cuts: NO_INCREMENT3,
-    failures: NO_INCREMENT3,
-    outages: NO_INCREMENT3,
-    owner_pid: owner.pid,
-    owner_start: owner.start
+    development: ports.resolve_development_port(environment2),
+    preview: ports.resolve_preview_port(environment2)
   };
 }
-function begin_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
-  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 read_lane_output(content) {
+  const line = split_lines(content).findLast((entry) => is_output_line(entry));
+  const raw = line === void 0 ? void 0 : assignment_value(line);
+  return raw === void 0 || raw.length === 0 ? void 0 : raw;
 }
-function adopt_carry(target, carry, owner = NO_OWNER) {
-  const next = {
-    ...carry,
-    owner_pid: owner.pid,
-    owner_start: owner.start,
-    is_handed_off: false
-  };
-  stamp_file.remove_stamp(target);
-  return stamp_file.create_stamp(target, next) ? next : void 0;
+function read_lane_profile(content) {
+  return agent_role_profile.parse({
+    provider: read_assignment(content, LANE_PROVIDER_KEY),
+    role: read_assignment(content, LANE_ROLE_KEY),
+    model: read_assignment(content, LANE_MODEL_KEY),
+    effort: read_assignment(content, LANE_EFFORT_KEY)
+  });
 }
-function is_owner_live(carry) {
-  return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false;
+function replace_assignment(lines, keep, assignment, key) {
+  return lines.flatMap((entry, index) => {
+    if (index === keep) return [assignment];
+    return is_key_line(entry, key) ? [] : [entry];
+  });
 }
-function is_owned_by(carry, owner) {
-  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
+function upsert_assignment(content, key, value) {
+  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
+  const lines = split_lines(content);
+  const last = lines.findLastIndex((entry) => is_key_line(entry, key));
+  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
+  return `${body.join("\n")}
+`;
 }
-function is_foreign_live_owner(carry, owner) {
-  return is_owner_live(carry) && !is_owned_by(carry, owner);
+function lane_file_content(root_content, seat) {
+  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
 }
-function is_handed_off_to(carry, invocation) {
-  return carry.is_handed_off === true && carry.invocation === invocation;
+function with_lane_output(content, output, profile) {
+  const recorded = upsert_assignment(content, LANE_OUTPUT_KEY, `"${output}"`);
+  if (profile === void 0) return recorded;
+  const with_provider = upsert_assignment(recorded, LANE_PROVIDER_KEY, profile.provider);
+  const with_role = upsert_assignment(with_provider, LANE_ROLE_KEY, profile.role);
+  const with_model = upsert_assignment(with_role, LANE_MODEL_KEY, profile.model);
+  return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
 }
-function classify_claim(carry, request) {
-  if (is_handed_off_to(carry, request.invocation)) return "resume";
-  if (is_foreign_live_owner(carry, request.owner)) return "busy";
-  if (carry.invocation !== request.invocation) return "mismatch";
-  return request.is_adoption ? "resume" : "standing";
+var lane_environment = {
+  LANE_OUTPUT_KEY,
+  LANE_PROVIDER_KEY,
+  LANE_ROLE_KEY,
+  is_output_line,
+  is_seat_line,
+  is_seed_line,
+  lane_file_content,
+  read_lane_output,
+  read_lane_profile,
+  read_lane_ports,
+  read_lane_seat,
+  read_root_seed,
+  with_lane_output
+};
+
+// scripts/lane/lane-registry.ts
+var WORKTREE_PREFIX = "worktree ";
+var BRANCH_PREFIX = "branch refs/heads/";
+var BLOCK_SEPARATOR = "\n\n";
+var ISSUE_PATTERN = /^[1-9]\d*$/u;
+function line_value(lines, prefix) {
+  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
 }
-function is_count_refused(carry, owner) {
-  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
+function seat_from_content(content) {
+  const seat = lane_environment.read_lane_seat(content);
+  if (seat === void 0) return void 0;
+  const port_pair = lane_environment.read_lane_ports(content);
+  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
 }
-function is_at_cut_cap(carry) {
-  return carry.cuts >= MAX_CUTS;
+var EMPTY_SEAT = {
+  seat: void 0,
+  development_port: void 0,
+  preview_port: void 0
+};
+function held_seat(content) {
+  if (content === void 0) return EMPTY_SEAT;
+  return seat_from_content(content) ?? EMPTY_SEAT;
 }
-function end_carry(target) {
-  stamp_file.remove_stamp(target);
+function read_environment(directory) {
+  return file_reader.read_if_readable(path3.join(directory, ENV_FILE_NAME));
 }
-function retrospective_done_of(read2) {
-  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
-  return read2.carry.retrospective === true;
+function branch_issue(branch2) {
+  if (!branch2?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
+  const issue = branch2.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
+  return ISSUE_PATTERN.test(issue) ? issue : void 0;
 }
-function remaining_of(carry) {
-  if (carry === void 0) return void 0;
-  const declared = run_invocation.issue_numbers(carry.invocation);
-  if (declared === void 0) return void 0;
-  const done = carry.done ?? [];
-  return declared.filter((issue) => !done.includes(issue));
+function is_gone(directory) {
+  return !existsSync2(directory);
 }
-function done_note(carry) {
-  const done = carry.done ?? [];
-  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
+function build_lane(issue, branch2, directory, is_stranded) {
+  const content = is_stranded ? void 0 : read_environment(directory);
+  const held = held_seat(content);
+  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
+  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
+  return {
+    issue,
+    branch: branch2,
+    directory,
+    seat: held.seat,
+    development_port: held.development_port,
+    preview_port: held.preview_port,
+    output,
+    profile,
+    is_stranded
+  };
 }
-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 is_lane_directory(root, issue, directory) {
+  return directory === lane_paths.lane_directory(root, issue);
 }
-function expired_message(carry) {
-  return `The ${String(CARRY_MAX_AGE_HOURS)}-hour whole-run bound is spent: ${describe_carry(carry)}. Clear it with \`${END_COMMAND2}\`.`;
+function parse_block(block, root) {
+  const lines = block.split("\n");
+  const directory = line_value(lines, WORKTREE_PREFIX);
+  const branch2 = line_value(lines, BRANCH_PREFIX);
+  const issue = branch_issue(branch2);
+  if (directory === void 0 || branch2 === void 0 || issue === void 0) return void 0;
+  if (!is_lane_directory(root, issue, directory)) return void 0;
+  return build_lane(issue, branch2, directory, is_gone(directory));
 }
-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_COMMAND2}\` once you know its run is over, then begin again.`;
+function is_lane(lane) {
+  return lane !== void 0;
 }
-function busy_message2(carry) {
-  return `A live run holds this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was established. Wait for that run, or end its record with \`${END_COMMAND2}\` once you know it is over.`;
+async function worktree_blocks() {
+  const listing = await git_worktree.worktree_list();
+  return listing.split(BLOCK_SEPARATOR);
 }
-function standing_message(carry) {
-  return `A run record is standing here that no cut handed off \u2014 ${describe_carry(carry)}. Nothing was established. Carry that budget with \`${RESUME_COMMAND} "${carry.invocation}" ${OWNER_ARGUMENT}\`, or discard it with \`${END_COMMAND2}\` and begin again.`;
+async function main_repository_root() {
+  return repo_discovery.main_worktree(await git_command.repository_root());
 }
-function count_refused_message(carry) {
-  if (carry.is_handed_off === true) {
-    return `This budget was handed off at a cut and is waiting for its successor \u2014 ${describe_carry(carry)}. Nothing was counted; the cutting session must not advance a handed-off budget.`;
-  }
-  return `A live run owns this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was counted; only its owner advances the budget.`;
+async function list_lanes() {
+  const root = lane_paths.lane_root(await main_repository_root());
+  const blocks = await worktree_blocks();
+  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
+  return lanes.toSorted((left, right) => Number(left.issue) - Number(right.issue));
 }
-function lost_message() {
-  return `Another process established a run record here first, so nothing was established. Read it with \`${READ_COMMAND2}\`.`;
+function used_seats(lanes) {
+  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
 }
-function nothing_to_resume_message() {
-  return `Nothing is carried here, so there is no budget to resume. Begin one with \`pnpm josh run:carry --begin "<invocation>"\`.`;
+function unreadable_lanes(lanes) {
+  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
 }
-function unreadable_message3() {
-  return `A run record is here but could not be read; clear it with \`${END_COMMAND2}\` once you know no run is using it.`;
+function find_lane(lanes, issue) {
+  return lanes.find((lane) => lane.issue === issue);
 }
-function unknown_message3() {
-  return "This repository\u2019s git directory could not be read, so no run record was established.";
+async function find_open_lane(issue) {
+  return find_lane(await list_lanes(), issue);
 }
-var run_carry = {
-  CARRY_MAX_AGE_HOURS,
-  CARRY_MAX_AGE_MS,
-  END_COMMAND: END_COMMAND2,
-  MAX_CUTS,
-  NO_OWNER,
-  RESUME_COMMAND,
-  adopt_carry,
-  apply_change: run_carry_change.apply_change,
-  begin_carry,
-  busy_message: busy_message2,
-  carry_path,
-  classify: classify4,
-  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_expired2,
-  is_foreign_live_owner,
-  is_owner_live,
-  lost_message,
-  nothing_to_resume_message,
-  owner_of,
-  parse_carry,
-  read_carry,
-  remaining_of,
-  replace_carry,
-  repository_directory,
-  retrospective_done_of,
-  standing_message,
-  unknown_message: unknown_message3,
-  unreadable_message: unreadable_message3
+var lane_registry = {
+  find_lane,
+  find_open_lane,
+  list_lanes,
+  main_repository_root,
+  parse_block,
+  read_environment,
+  unreadable_lanes,
+  used_seats
 };
 
 // scripts/run/run-progress-clock.ts
@@ -3338,9 +3475,9 @@ var run_progress_clock = {
 // scripts/run/run-watcher-guard.ts
 var WATCHER_TICK_MS = 3e4;
 var TICK_MULTIPLIER = 3;
-var MS_PER_SECOND2 = 1e3;
+var MS_PER_SECOND3 = 1e3;
 var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
-var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND2;
+var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND3;
 var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding`;
 var OK_RESULT = { kind: "ok" };
 async function has_lanes_in_flight() {
@@ -3359,6 +3496,114 @@ var run_watcher_guard = {
   has_lanes_in_flight
 };
 
+// scripts/run/run-headless.ts
+var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
+var HEADLESS_VALUE = "1";
+function environment() {
+  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
+}
+function is_headless(source = process.env) {
+  return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
+}
+function is_driving(read2) {
+  return read2?.kind === "carried" && read2.carry.is_handed_off !== true;
+}
+async function read_carry_here() {
+  const repository2 = await run_carry.repository_directory();
+  return repository2 === void 0 ? void 0 : run_carry.read_carry(run_carry.carry_path(repository2));
+}
+async function must_keep_waiting(source = process.env) {
+  const is_candidate2 = is_headless(source) && lane_child_marker.marked_issue(source) === void 0;
+  if (!is_candidate2 || !await run_watcher_guard.has_lanes_in_flight()) return false;
+  return is_driving(await read_carry_here());
+}
+async function current_carry() {
+  const read2 = await read_carry_here();
+  return read2?.kind === "carried" ? read2.carry : void 0;
+}
+function is_owned_here(carry, ancestry) {
+  return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
+}
+function driven_here(read2, ancestry) {
+  if (read2?.kind !== "carried" || !is_driving(read2)) return void 0;
+  return is_owned_here(read2.carry, ancestry) ? read2.carry : void 0;
+}
+async function driving_carry(source = process.env, ancestry = lane_reap.own_ancestry) {
+  if (lane_child_marker.marked_issue(source) !== void 0) return void 0;
+  return driven_here(await read_carry_here(), ancestry);
+}
+async function is_backlog_parent(source = process.env, ancestry = lane_reap.own_ancestry) {
+  return await driving_carry(source, ancestry) !== void 0;
+}
+var run_headless = {
+  HEADLESS_ENV_KEY,
+  current_carry,
+  driving_carry,
+  environment,
+  is_backlog_parent,
+  is_headless,
+  is_owned_here,
+  must_keep_waiting
+};
+
+// scripts/issue/issue-cite.ts
+var GITHUB_URL_PREFIX = "https://github.com/";
+var ISSUE_PATH = "/issues/";
+var SUMMARY_SEPARATOR = " \u2014 ";
+var REPO_QUALIFIED = /^([^\s/#]+\/[^\s/#]+)#(\d+)$/u;
+var BARE_NUMBER = /^#?(\d+)$/u;
+function issue_url(slug, number) {
+  return `${GITHUB_URL_PREFIX}${slug}${ISSUE_PATH}${number}`;
+}
+function citation_line(slug, number, summary) {
+  return `[#${number}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`;
+}
+function citer(slug, titles) {
+  return function cite(number) {
+    if (slug === void 0) return `#${number}`;
+    const title = titles.get(number);
+    return title === void 0 ? `[#${number}](${issue_url(slug, number)})` : citation_line(slug, number, title);
+  };
+}
+function qualified_target(token) {
+  const match = REPO_QUALIFIED.exec(token);
+  if (match === null) return void 0;
+  const [, repo = "", number = ""] = match;
+  return { number, repo };
+}
+function bare_target(token, default_repo) {
+  const match = BARE_NUMBER.exec(token);
+  if (match === null) return void 0;
+  const [, number = ""] = match;
+  return { number, repo: default_repo };
+}
+function parse_target(token, default_repo) {
+  return qualified_target(token) ?? bare_target(token, default_repo);
+}
+function label(target) {
+  return target.repo === void 0 ? `#${target.number}` : `${target.repo}#${target.number}`;
+}
+function missing_line(target) {
+  return `\u2716 ${label(target)}: issue does not resolve \u2014 check the number and the repository`;
+}
+function unreadable_line(target) {
+  return `\u2716 ${label(target)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
+}
+function no_repo_line(target) {
+  return `\u2716 ${label(target)}: could not read this repository \u2014 check gh auth and the origin remote`;
+}
+var issue_cite = {
+  SUMMARY_SEPARATOR,
+  citation_line,
+  citer,
+  issue_url,
+  label,
+  missing_line,
+  no_repo_line,
+  parse_target,
+  unreadable_line
+};
+
 // scripts/git/git-gh-api-path.ts
 var FULL_PAGE_QUERY = "?per_page=100";
 function repo_api_path(repo) {
@@ -3421,6 +3666,35 @@ var git_gh_api_path = {
   commit_status_api_path
 };
 
+// scripts/lib/error-message.ts
+function message_of(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var error_text = { message_of };
+
+// scripts/git/git-gh-exec.ts
+import { execa as execa5, execaSync as execaSync2 } from "execa";
+
+// scripts/git/git-gh-check.ts
+import { execa as execa4 } from "execa";
+var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
+var gh_check = {};
+async function run_gh_check() {
+  try {
+    await execa4("gh", ["--version"]);
+  } catch {
+    delete gh_check.promise;
+    throw new Error(GH_NOT_INSTALLED_MSG);
+  }
+}
+async function check_gh_installed() {
+  gh_check.promise ??= run_gh_check();
+  await gh_check.promise;
+}
+
+// scripts/git/git-gh-failure.ts
+import { z as z7 } from "zod";
+
 // scripts/git/parse-json-array.ts
 var MALFORMED_JSON = /* @__PURE__ */ Symbol("malformed-json");
 function parse_json_loose(raw_json) {
@@ -3461,28 +3735,7 @@ var parse_json = {
   read_json_listing
 };
 
-// scripts/git/git-gh-exec.ts
-import { execa as execa4, execaSync as execaSync2 } from "execa";
-
-// scripts/git/git-gh-check.ts
-import { execa as execa3 } from "execa";
-var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
-var gh_check = {};
-async function run_gh_check() {
-  try {
-    await execa3("gh", ["--version"]);
-  } catch {
-    delete gh_check.promise;
-    throw new Error(GH_NOT_INSTALLED_MSG);
-  }
-}
-async function check_gh_installed() {
-  gh_check.promise ??= run_gh_check();
-  await gh_check.promise;
-}
-
 // scripts/git/git-gh-failure.ts
-import { z as z7 } from "zod";
 var error_document_schema = z7.object({ status: z7.union([z7.string(), z7.number()]).optional() }).catch({});
 var GH_FAILURE_FIELD = "gh_failure";
 function has_gh_failure(error) {
@@ -3520,8 +3773,12 @@ function direct_environment() {
   const removed = agent_session_environment.removed_proxy_environment();
   return Object.keys(removed).length > 0 ? { env: removed } : {};
 }
-function to_spawn_options(timeout_ms) {
-  return { ...to_timeout_option(timeout_ms), ...direct_environment() };
+function to_spawn_options(timeout_ms, cwd) {
+  return {
+    ...to_timeout_option(timeout_ms),
+    ...direct_environment(),
+    ...cwd !== void 0 && { cwd }
+  };
 }
 var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
 function has_stderr_field(error) {
@@ -3533,13 +3790,10 @@ function has_stdout_field(error) {
 function to_timeout_prefix(error) {
   return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
 }
-function to_error_message(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 function to_gh_error(error) {
   const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
   const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
-  const summary = stderr.length > 0 ? stderr : to_error_message(error);
+  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
   const detail = stdout.length > 0 ? `${summary}
 ${stdout}` : summary;
   return gh_failure.attach(
@@ -3547,10 +3801,11 @@ ${stdout}` : summary;
     gh_failure.classify_stdout(stdout)
   );
 }
-async function exec_gh_command(arguments_, timeout_ms) {
+async function exec_gh_command(arguments_, timeout_ms, cwd) {
   await check_gh_installed();
+  const options = to_spawn_options(timeout_ms, cwd);
   try {
-    const { stdout } = await execa4("gh", arguments_, to_spawn_options(timeout_ms));
+    const { stdout } = await execa5("gh", arguments_, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -3558,9 +3813,9 @@ async function exec_gh_command(arguments_, timeout_ms) {
 }
 async function exec_gh_command_with_stdin(input) {
   await check_gh_installed();
-  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms) };
+  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
   try {
-    const { stdout } = await execa4("gh", input.args, options);
+    const { stdout } = await execa5("gh", input.args, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -3571,14 +3826,26 @@ function parse_status_line(output) {
   const { status: status2 } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
   return status2 === void 0 ? void 0 : Number(status2);
 }
+function status_of_failure(error) {
+  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+}
 async function exec_gh_api_status(path4, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
     await check_gh_installed();
-    const { stdout } = await execa4("gh", ["api", "--include", "--silent", path4], options);
+    const { stdout } = await execa5("gh", ["api", "--include", "--silent", path4], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return status_of_failure(error);
+  }
+}
+function exec_gh_api_status_sync(path4, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  try {
+    const { stdout } = execaSync2("gh", ["api", "--include", "--silent", path4], options);
     return parse_status_line(stdout);
   } catch (error) {
-    return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+    return status_of_failure(error);
   }
 }
 var METHOD_FLAG = "--method";
@@ -3605,16 +3872,19 @@ function to_gh_api_args(request) {
 }
 async function exec_gh_api(request) {
   const args = to_gh_api_args(request);
-  if (request.body === void 0) return await exec_gh_command(args, request.timeout_ms);
+  if (request.body === void 0) {
+    return await exec_gh_command(args, request.timeout_ms, request.cwd);
+  }
   return await exec_gh_command_with_stdin({
     args,
     stdin_body: request.body,
-    timeout_ms: request.timeout_ms
+    timeout_ms: request.timeout_ms,
+    cwd: request.cwd
   });
 }
 function exec_gh_api_sync(request) {
   const body_option = request.body === void 0 ? {} : { input: request.body };
-  const options = { ...body_option, ...to_spawn_options(request.timeout_ms) };
+  const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
   try {
     const { stdout } = execaSync2("gh", to_gh_api_args(request), options);
     return stdout.trimEnd();
@@ -3622,19 +3892,29 @@ function exec_gh_api_sync(request) {
     throw to_gh_error(error);
   }
 }
+function read_gh_api_sync(request) {
+  try {
+    return exec_gh_api_sync(request);
+  } catch {
+    return void 0;
+  }
+}
 var git_gh_exec = {
   direct_environment,
   exec_gh_command,
   exec_gh_command_with_stdin,
   exec_gh_api,
   exec_gh_api_sync,
+  read_gh_api_sync,
   exec_gh_api_status,
+  exec_gh_api_status_sync,
   parse_status_line
 };
 
 export {
   shell_segments,
   bash_triggers,
+  issue_cite,
   run_progress_clock,
   tail_commands,
   filing_cap,
@@ -3644,7 +3924,6 @@ export {
   agent_role_profile,
   backlog_budget,
   git_command,
-  lane_child_invocation,
   run_hold,
   run_cut,
   run_tail,
@@ -3664,17 +3943,19 @@ export {
   lane_park,
   repo_origin,
   repo_party,
+  process_identity,
+  run_invocation,
+  run_carry,
+  lane_registry,
+  run_watcher_guard,
+  run_headless,
   FULL_PAGE_QUERY,
   git_gh_api_path,
+  error_text,
   parse_json_array_or_undefined,
   read_json_listing,
   parse_json_object_safe,
   gh_failure,
   has_stderr_field,
-  git_gh_exec,
-  process_identity,
-  lane_registry,
-  run_invocation,
-  run_carry,
-  run_watcher_guard
+  git_gh_exec
 };