@joshuafolkken/kit 1.1035.0 → 1.1094.0

package/dist/hooks/{chunk-EIFCAJRB.js → chunk-UD24EAIL.js}

@@ -1,7 +1,7 @@
 import {
   lane_child_marker,
   run_issue_number
-} from "./chunk-HOYJU5RM.js";
+} from "./chunk-E54KGFEQ.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_blocks,
@@ -13,7 +13,7 @@ import {
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-GLBDBJOK.js";
+} from "./chunk-NKOG3XAV.js";
 import {
   ENV_FILE_NAME,
   LANE_SEAT_KEY,
@@ -32,7 +32,6 @@ function is_josh_command(segment, names) {
   return names.has(named.slice(time_shell.JOSH_PREFIX.length));
 }
 var shell_segments = {
-  SEGMENT_SEPARATOR,
   is_josh_command,
   segments_of
 };
@@ -69,7 +68,7 @@ function bash_commands_of(line) {
 function prior_bash_commands(tail) {
   return tail.split("\n").flatMap((line) => bash_commands_of(line));
 }
-var tail_commands = { bash_commands_of, is_bash_use, prior_bash_commands };
+var tail_commands = { is_bash_use, prior_bash_commands };
 
 // scripts/rules/filing-cap.ts
 var FILING_CAP = 10;
@@ -123,8 +122,6 @@ var filing_cap = {
   FILING_CAP,
   FILING_CAP_REASON,
   ROW,
-  current_turn,
-  decide,
   is_prompt_line,
   prior_filing_count,
   turn_filing_count
@@ -153,7 +150,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) {
@@ -166,25 +163,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() ?? "";
 }
@@ -202,19 +194,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;
@@ -229,7 +235,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;
@@ -242,23 +248,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
@@ -433,7 +472,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";
@@ -559,19 +598,20 @@ function hold_path(git_directory) {
   return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
 }
 async function worktree_directory() {
-  const directories = await git_command.git_directories();
-  return directories[0];
+  const directories2 = await git_command.git_directories();
+  return directories2[0];
 }
 async function is_linked_worktree() {
-  const directories = await git_command.git_directories();
-  return directories[0] !== void 0 && directories[0] !== directories[1];
+  const directories2 = await git_command.git_directories();
+  return directories2[0] !== void 0 && directories2[0] !== directories2[1];
 }
 var run_hold_schema = z.object({
   issue: z.string(),
   taken_at: z.string(),
   pid: z.number(),
   is_fullrun: z.boolean().optional(),
-  is_halfrun_stop: z.boolean().optional()
+  is_halfrun_stop: z.boolean().optional(),
+  prrun_stop_head: z.string().optional()
 });
 function parse_hold(raw) {
   try {
@@ -606,8 +646,12 @@ function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
 function create_hold(target, issue, now = /* @__PURE__ */ new Date(), is_fullrun) {
   return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun));
 }
+var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
+function create_stop_hold(target, issue, mark, now = /* @__PURE__ */ new Date()) {
+  return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark });
+}
 function create_halfrun_stop_hold(target, issue, now = /* @__PURE__ */ new Date()) {
-  return stamp_file.create_stamp(target, { ...build_hold(issue, now), is_halfrun_stop: true });
+  return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now);
 }
 async function is_tree_dirty(directory) {
   try {
@@ -663,8 +707,9 @@ var run_hold = {
   UNNUMBERED_ISSUE,
   classify,
   create_halfrun_stop_hold,
+  create_stop_hold,
+  HALFRUN_STOP_FIELDS,
   create_hold,
-  describe_holder,
   foreign_release_message,
   forced_release_message,
   held_message,
@@ -673,7 +718,6 @@ var run_hold = {
   is_own_hold,
   is_tree_dirty,
   own_release_command,
-  parse_hold,
   race_message,
   read_hold,
   release_hold,
@@ -685,9 +729,6 @@ var run_hold = {
   write_hold
 };
 
-// scripts/run/run-cut.ts
-import { execFileSync } from "node:child_process";
-
 // scripts/josh/agent-session-environment.ts
 var SESSION_ID_KEY = "CLAUDE_CODE_SESSION_ID";
 var PARENT_SESSION_KEYS = [
@@ -732,13 +773,13 @@ function is_declared(value) {
   return value !== void 0 && value !== NO_HOST;
 }
 function loopback_proxy_keys(source, is_removed = is_loopback_proxy) {
-  const declared = PROXY_KEYS.filter((key) => is_declared(source[key]));
-  const matched = declared.filter((key) => is_removed(source[key]));
+  const declared = PROXY_KEYS.filter((key2) => is_declared(source[key2]));
+  const matched = declared.filter((key2) => is_removed(source[key2]));
   const is_certificate_included = matched.length > 0 && matched.length === declared.length;
   return is_certificate_included ? [...matched, PROXY_CERTIFICATE_KEY] : matched;
 }
 function to_removed(keys) {
-  return Object.fromEntries(keys.map((key) => [key, void 0]));
+  return Object.fromEntries(keys.map((key2) => [key2, void 0]));
 }
 function removed_environment(source = process.env) {
   return to_removed([...PARENT_SESSION_KEYS, ...loopback_proxy_keys(source)]);
@@ -840,55 +881,55 @@ function trimmed(value) {
   const result = value?.trim();
   return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
 }
-function override_value(role, field, environment) {
-  const key = ENV_KEYS[role][field];
-  const value = trimmed(environment[key]);
-  if (value !== void 0) return { key, value };
-  if (role !== WORKER) return { key, value: void 0 };
+function override_value(role, field, environment2) {
+  const key2 = ENV_KEYS[role][field];
+  const value = trimmed(environment2[key2]);
+  if (value !== void 0) return { key: key2, value };
+  if (role !== WORKER) return { key: key2, value: void 0 };
   const legacy = LEGACY_WORKER_KEYS[field];
-  const legacy_value = trimmed(environment[legacy]);
-  return legacy_value === void 0 ? { key, value: void 0 } : { key: legacy, value: legacy_value };
+  const legacy_value = trimmed(environment2[legacy]);
+  return legacy_value === void 0 ? { key: key2, value: void 0 } : { key: legacy, value: legacy_value };
 }
-function model_override(role, environment, provider) {
-  const key = ENV_KEYS[role].model;
-  return provider === OPENAI_PROVIDER ? { key, value: void 0 } : override_value(role, "model", environment);
+function model_override(role, environment2, provider) {
+  const key2 = ENV_KEYS[role].model;
+  return provider === OPENAI_PROVIDER ? { key: key2, 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` };
+function rejection(key2, value, expected) {
+  return { kind: "rejected", note: `${key2}=${value} ${expected}, so the agent was not started` };
 }
 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((key2) => trimmed(environment2[key2]) !== 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) {
@@ -902,19 +943,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 = {
@@ -934,17 +975,11 @@ function parse(value) {
 }
 var agent_role_profile = {
   DEFAULT_PROFILES,
-  EFFORT_SCHEMA,
-  ENV_KEYS,
   HANDED_PROVIDER_KEY,
   IMPLEMENTATION_PHASE,
-  LEGACY_WORKER_KEYS,
   MAX_VALUE_LENGTH,
   OPENAI_PROFILES,
-  PHASE_EFFORT,
-  PHASE_SCHEMA,
   PRE_GATE_PHASE,
-  PROVIDER_SCHEMA,
   PROFILE_SCHEMA,
   REVIEWER,
   SCHEDULER,
@@ -954,7 +989,6 @@ var agent_role_profile = {
   has_completion_callback,
   is_safe_value,
   parse,
-  phase_effort,
   resolve,
   resolve_provider,
   with_phase_effort
@@ -1061,7 +1095,6 @@ function decide2(input) {
 }
 var backlog_budget = {
   ANSWERS,
-  ANSWER_STOP_REASONS,
   BLOCKED_REASON,
   DEFAULT_IDLE_MINUTES,
   DEFAULT_IDLE_MS,
@@ -1076,7 +1109,6 @@ var backlog_budget = {
   UNREADABLE_REASON,
   WATCH_VERDICT,
   WHOLE_RUN_BUDGET_HOURS,
-  WHOLE_RUN_BUDGET_MINUTES,
   WHOLE_RUN_BUDGET_MS,
   WHOLE_RUN_REASON,
   decide: decide2,
@@ -1162,7 +1194,6 @@ var cost_pricing = {
   CACHE_WRITE_5M_MULTIPLIER,
   CACHE_WRITE_1H_MULTIPLIER,
   CACHE_READ_MULTIPLIER,
-  MODEL_PRICES,
   resolve_price,
   estimate_cost,
   estimate_composition,
@@ -1201,6 +1232,9 @@ var context_cut_payback = {
 var CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context();
 var RECENT_REQUEST_WINDOW = 10;
 
+// scripts/git/git-common-directory.ts
+import { execFileSync } from "node:child_process";
+
 // scripts/git/git-location-environment.ts
 var GIT_LOCATION_VARIABLES = [
   "GIT_ALTERNATE_OBJECT_DIRECTORIES",
@@ -1230,6 +1264,197 @@ function clear_git_location_variables() {
 }
 var git_location_environment = { clear_git_location_variables, location_free_environment };
 
+// scripts/git/git-common-directory.ts
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS = 5e3;
+var answers = /* @__PURE__ */ new Map();
+function probe_environment(cwd) {
+  if (cwd === void 0) return process.env;
+  return { ...process.env, ...git_location_environment.location_free_environment() };
+}
+function cache_key(cwd) {
+  if (cwd !== void 0) return `explicit\0${cwd}`;
+  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
+  return ["inherited", process.cwd(), ...locations].join("\0");
+}
+function read_directories(cwd) {
+  try {
+    const output = execFileSync(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      {
+        cwd,
+        env: probe_environment(cwd),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: PROBE_TIMEOUT_MS
+      }
+    );
+    return output.split("\n").filter((line) => line !== "");
+  } catch {
+    return [];
+  }
+}
+function directories(cwd) {
+  const key2 = cache_key(cwd);
+  const known = answers.get(key2);
+  if (known !== void 0) return known;
+  const read2 = read_directories(cwd);
+  if (read2.length > 0) answers.set(key2, read2);
+  return read2;
+}
+function own(cwd) {
+  return directories(cwd)[OWN_GIT_DIRECTORY];
+}
+function repository(cwd) {
+  return directories(cwd)[COMMON_GIT_DIRECTORY];
+}
+function select_linked(found) {
+  const own_directory = found[OWN_GIT_DIRECTORY];
+  const common = found[COMMON_GIT_DIRECTORY];
+  return own_directory !== void 0 && common !== void 0 && own_directory !== common ? common : void 0;
+}
+function resolve2(cwd) {
+  return select_linked(directories(cwd));
+}
+var git_common_directory = { directories, own, repository, resolve: resolve2, select_linked };
+
+// scripts/run/run-ship-stage.ts
+import { z as z3 } from "zod";
+var STAGE = {
+  PREFLIGHT: "preflight",
+  REVIEW: "review",
+  GATE: "gate",
+  COMMIT: "commit",
+  ROUND_TWO: "round-2",
+  FOLLOWUP: "followup",
+  REPORT: "report"
+};
+var PHASE = {
+  START: "start",
+  DONE: "done",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var RECORD_PREFIX = "josh-ship-stages-";
+var RECORD_SEPARATOR = "-";
+var SKIP_COMMIT_FLAG = "--skip-commit";
+var SKIP_PUSH_FLAG = "--skip-push";
+var record_schema = z3.object({ done: z3.array(z3.string()) });
+function record_path(repository2, issue) {
+  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue}${RECORD_SEPARATOR}`, repository2);
+}
+function parse_done(raw) {
+  try {
+    return new Set(record_schema.parse(JSON.parse(raw)).done);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function read_done(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? /* @__PURE__ */ new Set() : parse_done(raw);
+}
+function mark_done(target, stage) {
+  const done = /* @__PURE__ */ new Set([...read_done(target), stage]);
+  stamp_file.replace_stamp(target, { done: [...done] });
+}
+function clear(target) {
+  stamp_file.remove_stamp(target);
+}
+function is_shipped(state) {
+  return state.is_committed && state.is_pushed;
+}
+var DONE_BY = {
+  // The preflight (joshuafolkken/kit#2946) asks what the commit stage would refuse on, so a commit is
+  // its output as it is the gate's; a resumed commit stage still asks `git -y`'s own preflight.
+  [STAGE.PREFLIGHT]: (_done, state) => state.is_merged || state.is_committed,
+  // The `--review` round (joshuafolkken/kit#2427) precedes the commit, so a commit is its output as it
+  // is the gate's. A record alone is not honored: before a commit the tree may have been edited since
+  // the recorded round, and only a commit pins the tree that round read.
+  [STAGE.REVIEW]: (_done, state) => state.is_merged || state.is_committed,
+  [STAGE.GATE]: (_done, state) => state.is_merged || state.is_committed,
+  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
+  // The round-2 pass (joshuafolkken/kit#2489) reads the pushed fix delta, so its record is honored only
+  // while that push still stands — new work pushed on top reruns it.
+  [STAGE.ROUND_TWO]: (done, state) => state.is_merged || done.has(STAGE.ROUND_TWO) && is_shipped(state),
+  // A recorded followup still needs the shipped state: a record left by a merged ship whose report
+  // failed must not pass over the followup of new, not-yet-pushed work on the same issue.
+  [STAGE.FOLLOWUP]: (done, state) => state.is_merged || done.has(STAGE.FOLLOWUP) && is_shipped(state),
+  [STAGE.REPORT]: (done) => done.has(STAGE.REPORT)
+};
+function is_done(stage, done, state, has_body = false) {
+  if (has_body && stage === STAGE.COMMIT && !state.is_merged) return false;
+  return DONE_BY[stage](done, state);
+}
+function commit_flags(state) {
+  if (!state.is_committed) return [];
+  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
+}
+function event_text(issue, stage, phase) {
+  return `#${issue} ${stage} ${phase}`;
+}
+var run_ship_stage = {
+  PHASE,
+  STAGE,
+  clear,
+  commit_flags,
+  event_text,
+  is_done,
+  mark_done,
+  read_done,
+  record_path
+};
+
+// scripts/run/run-ship-next.ts
+var { STAGE: STAGE2 } = run_ship_stage;
+var COMMAND = {
+  LOG: "pnpm josh ship --log",
+  DETACH: "pnpm josh ship --detach",
+  DETACH_REVIEW: "pnpm josh ship --detach --review"
+};
+var ESCAPED_QUOTE = String.raw`'\''`;
+var BARE_WORD = /^[\w%+,./:=@-]+$/u;
+function quoted(title) {
+  return `'${title.split("'").join(ESCAPED_QUOTE)}'`;
+}
+function shell_word(token) {
+  return BARE_WORD.test(token) ? token : quoted(token);
+}
+function resume_of(args) {
+  const cites = args.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    title: args.title,
+    flags: [...args.notify, ...args.body, ...cites],
+    is_review: args.is_review
+  };
+}
+function ship_command(command, resume) {
+  const words = [...resume.flags, resume.title].map((token) => shell_word(token));
+  return [command, ...words].join(" ");
+}
+function detach_again(resume) {
+  return `leave the fix uncommitted and run \`${ship_command(COMMAND.DETACH, resume)}\`.`;
+}
+function detach_as_started(resume) {
+  const command = resume.is_review ? COMMAND.DETACH_REVIEW : COMMAND.DETACH;
+  return `leave the fix uncommitted and run \`${ship_command(command, resume)}\`.`;
+}
+var AFTER_FIX = {
+  [STAGE2.PREFLIGHT]: detach_as_started,
+  [STAGE2.REVIEW]: detach_as_started,
+  [STAGE2.GATE]: detach_as_started,
+  [STAGE2.COMMIT]: detach_as_started,
+  [STAGE2.ROUND_TWO]: detach_again,
+  [STAGE2.FOLLOWUP]: detach_again,
+  [STAGE2.REPORT]: detach_again
+};
+function next_step(issue, stage, resume) {
+  return `Read the stopped report with \`${COMMAND.LOG} ${issue}\`, fix the ${stage} failure, then ${AFTER_FIX[stage](resume)}`;
+}
+var run_ship_next = { COMMAND, next_step, quoted, resume_of };
+
 // scripts/lane/lane-child-invocation.ts
 var CHILD_INVOCATION = "fullrun";
 var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
@@ -1250,12 +1475,12 @@ function outage_resume_invocation(issue) {
   const preamble = `Resuming the lane child for issue #${issue} after an API disconnection \u2014 your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`;
   return `${preamble} ${child_invocation(issue)}`;
 }
-function ship_stop_invocation(issue) {
-  const preamble = `Resuming the lane child for issue #${issue} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md. Do not re-plan or re-implement what is already on the branch.`;
-  return `${preamble} ${child_invocation(issue)}`;
+function ship_stop_invocation(issue, stop) {
+  const opening = `Resuming the lane child for issue #${issue} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`;
+  const next = stop === void 0 ? `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.` : run_ship_next.next_step(issue, stop.stage, stop);
+  return `${opening} ${next} Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`;
 }
 var lane_child_invocation = {
-  CHILD_INVOCATION,
   child_invocation,
   outage_resume_invocation,
   process_pattern,
@@ -1264,16 +1489,16 @@ var lane_child_invocation = {
 };
 
 // scripts/run/run-cut.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // scripts/run/run-cut-handoff.ts
 import { readFileSync } from "node:fs";
-import { z as z3 } from "zod";
-var handoff_schema = z3.object({
-  instruction: z3.string(),
-  completed: z3.array(z3.string()),
-  remaining: z3.array(z3.string()),
-  untouched: z3.array(z3.string())
+import { z as z4 } from "zod";
+var handoff_schema = z4.object({
+  instruction: z4.string(),
+  completed: z4.array(z4.string()),
+  remaining: z4.array(z4.string()),
+  untouched: z4.array(z4.string())
 });
 var COMPLETED_LABEL = "Completed";
 var REMAINING_LABEL = "Remaining";
@@ -1312,10 +1537,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) {
@@ -1342,22 +1567,20 @@ var { PRE_GATE_PHASE: PRE_GATE_PHASE2, IMPLEMENTATION_PHASE: IMPLEMENTATION_PHAS
 var IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD;
 var CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS;
 var CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
-var GIT_READ_TIMEOUT_MS = 5e3;
-var WORKTREE_DIRECTORY_INDEX = 0;
 var END_COMMAND = "pnpm josh run:cut --end";
 var READ_COMMAND = "pnpm josh run:cut --json";
 var MAX_HANDOFF_BYTES = 8192;
 var NONE_READ = { kind: "none" };
 var UNREADABLE_READ2 = { kind: "unreadable" };
-var run_cut_schema = z4.object({
-  invocation: z4.string(),
-  issue: z4.string(),
-  branch: z4.string(),
-  phase: z4.string(),
-  cut_at: z4.string(),
-  is_handed_off: z4.boolean().optional(),
+var run_cut_schema = z5.object({
+  invocation: z5.string(),
+  issue: z5.string(),
+  branch: z5.string(),
+  phase: z5.string(),
+  cut_at: z5.string(),
+  is_handed_off: z5.boolean().optional(),
   handoff: run_cut_handoff.handoff_schema.optional(),
-  is_merge_relaunched: z4.boolean().optional()
+  is_merge_relaunched: z5.boolean().optional()
 });
 function cut_path(git_directory) {
   return stamp_file.stamp_path(CUT_PREFIX, git_directory);
@@ -1388,36 +1611,8 @@ function classify2(raw, now) {
 function read_cut(target, now = /* @__PURE__ */ new Date()) {
   return classify2(stamp_file.read_stamp_text(target), now);
 }
-function git_directories_sync(cwd) {
-  try {
-    const output = execFileSync(
-      git_utilities.get_git_command_for_spawn(),
-      [...git_command.GIT_DIRECTORY_ARGUMENTS],
-      // git's own diagnostics are discarded: a checkout it cannot describe is already the
-      // `undefined` below, and a hook that let `fatal: not a git repository` through would print it
-      // in front of a tool call that is about to be allowed.
-      // A `PreToolUse` hook holds the tool call while it runs, so the read is bounded rather than
-      // left to whatever git does.
-      // `cwd` is set only by `lane_cut_sync`, which reads another lane's record from the parent.
-      // With a `cwd`, the git location variables are cleared so it is what git answers for: a hook
-      // exports `GIT_DIR`, which beats `cwd` and would name the hook's checkout instead
-      // (joshuafolkken/kit#2515). Without one the environment is kept, so this read resolves the same
-      // checkout as the asynchronous `git_directories` that writes the record.
-      {
-        cwd,
-        env: cwd === void 0 ? process.env : { ...process.env, ...git_location_environment.location_free_environment() },
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: GIT_READ_TIMEOUT_MS
-      }
-    );
-    return output.split("\n").filter((line) => line !== "");
-  } catch {
-    return [];
-  }
-}
 function worktree_git_directory_sync() {
-  return git_directories_sync()[WORKTREE_DIRECTORY_INDEX];
+  return git_common_directory.own();
 }
 function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
   if (directory === void 0) return void 0;
@@ -1425,7 +1620,7 @@ function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree
   return read2.kind === "carried" ? read2.cut : void 0;
 }
 function lane_cut_sync(lane_directory) {
-  const directory = git_directories_sync(lane_directory)[WORKTREE_DIRECTORY_INDEX];
+  const directory = git_common_directory.own(lane_directory);
   if (directory === void 0) return void 0;
   const cut = carried_cut_sync(/* @__PURE__ */ new Date(), directory);
   return cut === void 0 ? void 0 : { target: cut_path(directory), cut };
@@ -1616,7 +1811,7 @@ var run_tail = {
 
 // scripts/rules/lane-background.ts
 var LONG_RUNNING_COMMANDS = new Set(
-  ["gate", "git", "followup"].map((name) => `${time_shell.JOSH_PREFIX}${name}`)
+  ["gate", "git", "followup", "ship"].map((name) => `${time_shell.JOSH_PREFIX}${name}`)
 );
 var BACKGROUND_KEY2 = "run_in_background";
 function is_backgrounded2(input) {
@@ -1637,8 +1832,8 @@ function unfinished_ids(tail, launched_ids) {
   const lines = tail.split("\n").map((line) => time_transcript_line.parse_line(line));
   const finished = new Set(lines.map((line) => line?.finished_background ?? ""));
   const blocks = lines.flatMap((line) => line?.blocks ?? []);
-  const launched = blocks.flatMap((block) => launched_ids(block));
-  return launched.filter((id) => id !== "" && !finished.has(id));
+  const launched2 = blocks.flatMap((block) => launched_ids(block));
+  return launched2.filter((id) => id !== "" && !finished.has(id));
 }
 function pending_background_ids(tail) {
   return unfinished_ids(tail, (block) => [block.background_id, block.agent_id]);
@@ -1646,7 +1841,7 @@ function pending_background_ids(tail) {
 function pending_agent_ids(tail) {
   return unfinished_ids(tail, (block) => [block.agent_id]);
 }
-var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless `claude -p` process whose background Bash tasks are killed when the turn ends \u2014 so a backgrounded `josh gate` / `josh git` / `josh followup` never re-invokes you; it dies at `exit code 143` (joshuafolkken/kit#2704, measured on the #2606 child: implementation, review and live verification done, the run parked instead of merged). Hand the gate-to-merge region to the detached supervisor instead: `pnpm josh ship --detach --review "<title> #<N>"` (add `--cite <N>`), then end the turn on `launched` / `busy` \u2014 `.claude/skills/workflow-commands/chain-rule.md` step 0 is the single source. A single check you must read before continuing runs in the foreground within the tool timeout; the commit-push step does not \u2014 in a child it too belongs to the detached ship, in either spelling. This rule fires on every occurrence, not once per run.';
+var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless `claude -p` process whose background Bash tasks are killed when the turn ends \u2014 so a backgrounded `josh gate` / `josh git` / `josh followup` / `josh ship` never re-invokes you; it dies at `exit code 143` (joshuafolkken/kit#2704, measured on the #2606 child: implementation, review and live verification done, the run parked instead of merged). Hand the gate-to-merge region to the detached supervisor instead: `pnpm josh ship --detach --review "<title> #<N>"` (add `--cite <N>`) issued in the foreground \u2014 its preflight runs in this process before the supervisor exists, so a backgrounded `ship` dies with the turn (joshuafolkken/kit#3027) \u2014 then end the turn on `launched` / `busy`. `.claude/skills/workflow-commands/chain-rule.md` step 0 is the single source. A single check you must read before continuing runs in the foreground within the tool timeout; the commit-push step does not \u2014 in a child it too belongs to the detached ship, in either spelling. This rule fires on every occurrence, not once per run.';
 var LANE_BACKGROUND_STOP_REASON = "\u26D4 lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task it launched has not finished \u2014 ending this headless turn kills it, and nothing re-invokes you afterwards (joshuafolkken/kit#2704). Do not send a notification and do not stop: wait for the task in the foreground and act on its result, or re-issue the work through `pnpm josh ship --detach`, whose supervisor outlives the turn (`.claude/skills/workflow-commands/chain-rule.md` step 0). Do not repeat your previous reply.";
 var ROW2 = {
   id: "lane-background",
@@ -1663,1713 +1858,2427 @@ var lane_background = {
   pending_background_ids
 };
 
-// scripts/git/issue-labels.ts
-var EPIC_LABEL = "epic";
-var ENHANCEMENT_LABEL = "enhancement";
-var BREAKING_CHANGE_LABEL = "breaking-change";
-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 NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
-var ALREADY_DONE_LABEL = "already-done";
-var INTERRUPT_ROUTE_LABEL = "route:interrupt";
-var REVIEW_CAP_ROUTE_LABEL = "route:review-cap";
-var SPLIT_ROUTE_LABEL = "route:split";
-var TIER_A_ROUTE_LABEL = "route:tier-a";
-var FILING_ROUTE_LABELS = [
-  {
-    name: INTERRUPT_ROUTE_LABEL,
-    // Not `5319e7`, which is the `epic` label's purple: in a listing an interrupt would render as
-    // an epic, and the two are read at a glance rather than by name.
-    color: "1d76db",
-    // Keyed to the tests rather than to severity. "A serious defect" is the self-assessment
-    // `wip-cap.md` bans as a criterion, and this string is what a person reads in `gh label list`.
-    description: "Filed past the WIP cap \u2014 meets one of the three interrupt tests (wip-cap.md)"
-  },
-  {
-    name: REVIEW_CAP_ROUTE_LABEL,
-    color: "eab308",
-    description: "Filed by the review round cap's carry-forward (prompts/review.md \u2192 Review round cap)"
-  },
-  {
-    name: SPLIT_ROUTE_LABEL,
-    color: "0e8a16",
-    description: "A child issue created by a split (split-assessment.md)"
-  },
-  {
-    name: TIER_A_ROUTE_LABEL,
-    color: "d93f0b",
-    description: "Filed Tier A during implementation \u2014 an upstream defect or a prerequisite"
-  }
-];
-var DEPTH_0_LABEL = "depth:0";
-var DEPTH_1_LABEL = "depth:1";
-var DEPTH_2_LABEL = "depth:2";
-var DEPTH_LABELS = [
-  {
-    name: DEPTH_0_LABEL,
-    color: "0e8a16",
-    description: "Depth 0 \u2014 what a consumer of this package touches (SKILL.md \xA72i)"
-  },
-  {
-    name: DEPTH_1_LABEL,
-    color: "fbc02d",
-    description: "Depth 1 \u2014 the run orchestration that executes an Issue (SKILL.md \xA72i)"
-  },
-  {
-    name: DEPTH_2_LABEL,
-    color: "c5def5",
-    description: "Depth 2 \u2014 what measures a run (SKILL.md \xA72i)"
+// scripts/josh/process-identity.ts
+import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync as readFileSync2, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import path from "node:path";
+var PS_COMMAND = "/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_MS2 = 2e3;
+var LIVENESS_SIGNAL = 0;
+var LOWEST_REAL_PID = 1;
+var PROC_START_FIELD_INDEX = 19;
+var BEACON_SCHEME = "socket:";
+var BEACON_SUFFIX = ".sock";
+var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
+var BEACON_ID_LENGTH = 36;
+var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
+var WINDOWS_PLATFORM = "win32";
+var SOCKET_PROBE_SOURCE = "const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(0));socket.once('error',()=>process.exit(1));socket.setTimeout(1000,()=>process.exit(1));";
+var beacons = /* @__PURE__ */ new Map();
+var exit_cleanup = { is_registered: false };
+function is_live_pid(pid) {
+  if (pid < LOWEST_REAL_PID) return false;
+  try {
+    process.kill(pid, LIVENESS_SIGNAL);
+    return true;
+  } catch {
+    return false;
   }
-];
-var WORKFLOW_LABELS = [
-  {
-    name: EPIC_LABEL,
-    color: "5319e7",
-    description: "Tracks a batch of child issues from one split"
-  },
-  { name: IN_PROGRESS_LABEL, color: "0075ca", description: "Work is actively in progress" },
-  {
-    name: RUN_SOLO_LABEL,
-    color: "b60205",
-    description: "Runs alone in a backlogrun: nothing starts beside it"
-  },
-  {
-    name: RUN_LANE_LABEL,
-    color: "0e8a16",
-    description: "Judged safe to run beside others in a backlogrun"
-  },
-  ...FILING_ROUTE_LABELS,
-  ...DEPTH_LABELS
-];
-var BUGFIX_LABEL = "bugfix";
-var OTHER_CHANGE_LABEL = "other-change";
-var IGNORE_FOR_RELEASE_LABEL = "ignore-for-release";
-var RELEASE_CLASSIFICATION_NAMES = [
-  BREAKING_CHANGE_LABEL,
-  ENHANCEMENT_LABEL,
-  BUGFIX_LABEL,
-  OTHER_CHANGE_LABEL,
-  IGNORE_FOR_RELEASE_LABEL
-];
-var RELEASE_CLASSIFICATION_METADATA = {
-  [BREAKING_CHANGE_LABEL]: { color: "d93f0b", description: "Release: a breaking change (major)" },
-  [ENHANCEMENT_LABEL]: { color: "84b6eb", description: "Release: a new feature (minor)" },
-  [BUGFIX_LABEL]: { color: "d73a4a", description: "Release: a bug fix (patch)" },
-  [OTHER_CHANGE_LABEL]: { color: "c2e0c6", description: "Release: any other change (patch)" },
-  [IGNORE_FOR_RELEASE_LABEL]: { color: "cfd3d7", description: "Release: left out of the notes" }
-};
-var RELEASE_CLASSIFICATION_LABELS = RELEASE_CLASSIFICATION_NAMES.map((name) => ({ name, ...RELEASE_CLASSIFICATION_METADATA[name] }));
-var REPOSITORY_LABELS = [
-  ...WORKFLOW_LABELS,
-  ...RELEASE_CLASSIFICATION_LABELS
-];
-function has_any_label(labels, wanted) {
-  return (labels ?? []).some((label) => wanted.has(label.name.toLowerCase()));
-}
-function label_name_of(labels, wanted) {
-  const target = wanted.toLowerCase();
-  return labels.find((label) => label.toLowerCase() === target);
-}
-function has_label_name(labels, wanted) {
-  return label_name_of(labels, wanted) !== void 0;
 }
-
-// scripts/rules/lane-park.ts
-var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
-var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
-function is_confirmation_notify(command) {
-  return shell_segments.segments_of(command).some(
-    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
-  );
+function read_proc_start(pid) {
+  try {
+    const stat = readFileSync2(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
+    const start = fields[PROC_START_FIELD_INDEX];
+    return start === void 0 ? void 0 : `proc:${start}`;
+  } catch {
+    return void 0;
+  }
 }
-var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
-function mentions_confirmation_notify(text) {
-  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
+function read_ps_start(pid) {
+  try {
+    const printed = execFileSync2(
+      PS_COMMAND,
+      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
+      {
+        encoding: "utf8",
+        timeout: PROBE_TIMEOUT_MS2,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: PROBE_ENVIRONMENT
+      }
+    ).trim();
+    return printed.length > 0 ? printed : void 0;
+  } catch {
+    return void 0;
+  }
 }
-function is_unparked_stop(command, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
-  if (!is_confirmation_notify(command)) return false;
-  return is_lane_child;
+var START_PROBES = { read_proc_start, read_ps_start };
+function safe_probe(probe, pid) {
+  try {
+    return probe(pid);
+  } catch {
+    return void 0;
+  }
 }
-var APPLIES_NEEDS_DECISION = new RegExp(
-  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
-  "u"
-);
-function records_the_park(command) {
-  return APPLIES_NEEDS_DECISION.test(command);
+function read_start(pid, probes = START_PROBES) {
+  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
 }
-var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
-var lane_park = {
-  LANE_PARK_REASON,
-  is_confirmation_notify,
-  is_unparked_stop,
-  mentions_confirmation_notify,
-  records_the_park
-};
-
-// scripts/discovery/repo-discovery.ts
-import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
-import path from "node:path";
-
-// scripts/discovery/repo-origin.ts
-var GITHUB_HOST = "github.com";
-var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
-var GIT_SUFFIX = ".git";
-var PATH_SEPARATOR2 = "/";
-var USER_SEPARATOR = "@";
-var HOST_SEPARATOR = ":";
-var OWNER_INDEX = 0;
-var REPO_INDEX = 1;
-var REPO_PATH_SEGMENTS = 2;
-var NOT_FOUND = -1;
-var SECTION_PREFIX = "[";
-var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
-var URL_KEY = "url";
-function is_github_hostname(host) {
-  return host.toLowerCase() === GITHUB_HOST;
+function close_beacon(token) {
+  const server = beacons.get(token);
+  if (server === void 0) return;
+  beacons.delete(token);
+  server.close();
+  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
 }
-function is_github_ssh_host(host) {
-  const normalized = host.toLowerCase();
-  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
+function close_beacons() {
+  for (const token of beacons.keys()) close_beacon(token);
 }
-function strip_git_suffix(name) {
-  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
+function ensure_exit_cleanup() {
+  if (exit_cleanup.is_registered) return;
+  exit_cleanup.is_registered = true;
+  process.once("exit", close_beacons);
 }
-function to_identity(repository_path) {
-  const segments = repository_path.split(PATH_SEPARATOR2).filter((segment) => segment !== "");
-  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
-  const owner = segments[OWNER_INDEX] ?? "";
-  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
-  return repo === "" ? void 0 : { owner, repo };
+function ignore_beacon_error() {
 }
-function parse_scp_like(url) {
-  const user_end = url.indexOf(USER_SEPARATOR);
-  const authority = user_end === NOT_FOUND ? url : url.slice(user_end + 1);
-  const host_end = authority.indexOf(HOST_SEPARATOR);
-  if (host_end === NOT_FOUND) return void 0;
-  if (!is_github_ssh_host(authority.slice(0, host_end))) return void 0;
-  return to_identity(authority.slice(host_end + 1));
+function bind_beacon(target) {
+  return createServer().on("error", ignore_beacon_error).listen(target);
 }
-function parse_url_like(url) {
+function try_bind_beacon(bind, target) {
   try {
-    const parsed = new URL(url);
-    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
+    const server = bind(target);
+    return server.listening ? server : void 0;
   } catch {
     return void 0;
   }
 }
-function parse_origin_url(url) {
-  const trimmed2 = url.trim();
-  if (trimmed2 === "") return void 0;
-  return parse_url_like(trimmed2) ?? parse_scp_like(trimmed2);
+function open_beacon(bind = bind_beacon) {
+  const target = path.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
+  const token = `${BEACON_SCHEME}${target}`;
+  const server = try_bind_beacon(bind, target);
+  if (server === void 0) return void 0;
+  server.unref();
+  beacons.set(token, server);
+  ensure_exit_cleanup();
+  return token;
 }
-function is_section_header(line) {
-  return line.startsWith(SECTION_PREFIX);
+function resolve_own_start(probes = START_PROBES, platform2 = process.platform) {
+  const start = read_start(process.pid, probes);
+  if (start !== void 0 || platform2 === WINDOWS_PLATFORM) return start;
+  return open_beacon();
 }
-function origin_section_lines(lines) {
-  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
-  if (start === NOT_FOUND) return [];
-  const rest = lines.slice(start + 1);
-  const end = rest.findIndex((line) => is_section_header(line));
-  return end === NOT_FOUND ? rest : rest.slice(0, end);
+function is_valid_beacon_name(name) {
+  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
+  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
+  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
 }
-function entry_value(line, key) {
-  const separator = line.indexOf("=");
-  if (separator === NOT_FOUND) return void 0;
-  if (line.slice(0, separator).trim() !== key) return void 0;
-  return line.slice(separator + 1).trim();
+function beacon_target(token) {
+  if (!token.startsWith(BEACON_SCHEME)) return void 0;
+  const target = token.slice(BEACON_SCHEME.length);
+  if (path.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
+  return is_valid_beacon_name(path.basename(target)) ? target : void 0;
 }
-function parse_origin_from_config(content) {
-  const lines = content.split("\n").map((line) => line.trim());
-  return origin_section_lines(lines).map((line) => entry_value(line, URL_KEY)).find((url) => url !== void 0);
+function is_live_beacon(target) {
+  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
+    stdio: "ignore",
+    timeout: PROBE_TIMEOUT_MS2
+  }).status === 0;
 }
-function format_identity(identity) {
-  return `${identity.owner}${PATH_SEPARATOR2}${identity.repo}`.toLowerCase();
+function has_matching_start(pid, recorded_start, read2) {
+  const observed = read2(pid);
+  return observed === void 0 ? void 0 : observed === recorded_start;
 }
-var repo_origin = {
-  GITHUB_HOST,
-  is_github_hostname,
-  is_github_ssh_host,
-  parse_origin_from_config,
-  parse_origin_url,
-  format_identity
-};
-
-// scripts/discovery/repo-map-logic.ts
-var OVERRIDE_ENTRY_SEPARATOR = ",";
-var OVERRIDE_PAIR_SEPARATOR = "=";
-var OVERRIDE_PAIR_PARTS = 2;
-var KEY_INDEX = 0;
-var PATH_INDEX = 1;
-function is_same_owner(identity, current_owner2) {
-  return identity.owner.toLowerCase() === current_owner2.toLowerCase();
+function matches_recorded_start(pid, recorded_start, read2) {
+  const target = beacon_target(recorded_start);
+  return target === void 0 ? has_matching_start(pid, recorded_start, read2) : is_live_beacon(target);
 }
-function add_entry(target, origin_url, repository_path, current_owner2) {
-  if (origin_url === void 0) return;
-  const identity = repo_origin.parse_origin_url(origin_url);
-  if (identity === void 0 || !is_same_owner(identity, current_owner2)) return;
-  target.set(repo_origin.format_identity(identity), repository_path);
+var own_probe = /* @__PURE__ */ new Map();
+function own_start() {
+  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
+  return own_probe.get(process.pid);
 }
-function parse_override_entry(entry) {
-  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
-  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
-  const key = parts[KEY_INDEX] ?? "";
-  const repository_path = parts[PATH_INDEX] ?? "";
-  if (repository_path === "") return void 0;
-  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key}` };
+function own_fields() {
+  const start = own_start();
+  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
 }
-function parse_overrides(raw) {
-  if (raw === void 0) return [];
-  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
+function is_same_process(pid, recorded_start, read2 = read_start) {
+  if (pid === void 0 || !is_live_pid(pid)) return false;
+  if (recorded_start === void 0) return void 0;
+  return matches_recorded_start(pid, recorded_start, read2);
 }
-function build_repository_map(discovered, current_owner2, override_value2) {
-  const result = /* @__PURE__ */ new Map();
-  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner2);
-  for (const entry of parse_overrides(override_value2)) {
-    add_entry(result, entry.origin_url, entry.path, current_owner2);
-  }
-  return result;
+function is_own_process(pid, recorded_start) {
+  return pid === process.pid && recorded_start === own_start();
 }
-var repo_map_logic = {
-  is_same_owner,
-  parse_overrides,
-  build_repository_map
+var process_identity = {
+  close_beacon,
+  is_live_pid,
+  is_own_process,
+  is_same_process,
+  open_beacon,
+  own_fields,
+  own_start,
+  read_start,
+  resolve_own_start
 };
 
-// scripts/discovery/repo-discovery.ts
-var GIT_DIRECTORY = ".git";
-var GIT_CONFIG = "config";
-var GITDIR_PREFIX = "gitdir:";
-var COMMON_DIRECTORY_FILE = "commondir";
-var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
-function resolve_common_directory(git_directory) {
-  const pointer = path.join(git_directory, COMMON_DIRECTORY_FILE);
-  if (!existsSync(pointer)) return git_directory;
-  try {
-    return path.resolve(git_directory, readFileSync2(pointer, "utf8").trim());
-  } catch {
-    return git_directory;
-  }
+// scripts/run/run-carry.ts
+import { z as z6 } 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 follow_git_file(repository_path, git_file) {
-  const pointer = readFileSync2(git_file, "utf8").trim();
-  if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
-  return path.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
+function next_failures(carry, change) {
+  if (has_increment(change.merged)) return NO_INCREMENT;
+  return carry.failures + (change.failures ?? NO_INCREMENT);
 }
-function resolve_git_directory(repository_path) {
-  const candidate = path.join(repository_path, GIT_DIRECTORY);
-  if (!existsSync(candidate)) return void 0;
-  try {
-    if (statSync(candidate).isDirectory()) return candidate;
-    const linked = follow_git_file(repository_path, candidate);
-    return linked === void 0 ? void 0 : resolve_common_directory(linked);
-  } 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 read_origin_url(repository_path) {
-  const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0) return void 0;
-  try {
-    return repo_origin.parse_origin_from_config(
-      readFileSync2(path.join(git_directory, GIT_CONFIG), "utf8")
-    );
-  } catch {
-    return void 0;
-  }
+function folded_outage(carry) {
+  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
 }
-function sibling_directories(parent) {
-  try {
-    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
-  } catch {
-    return [];
-  }
+function counted_outage(carry, change, now) {
+  const outages = carry.outages + (change.outages ?? NO_INCREMENT);
+  return { outages, last_outage_at: now.toISOString() };
 }
-function scan_siblings(parent) {
-  return sibling_directories(parent).map((repository_path) => ({
-    path: repository_path,
-    origin_url: read_origin_url(repository_path)
-  }));
+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 resolve_current_owner(repository_path) {
-  const origin_url = read_origin_url(repository_path);
-  if (origin_url === void 0) return void 0;
-  return repo_origin.parse_origin_url(origin_url)?.owner;
+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 main_worktree(repository_path) {
-  const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0) return repository_path;
-  if (path.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
-  return path.dirname(git_directory);
+var run_carry_streak = { 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 discover_repositories(repository_path, environment = 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]
-  );
+function next_merged_issues(carry, issue) {
+  if (issue === void 0) return carry.merged_issues;
+  return [...carry.merged_issues ?? [], issue];
 }
-var repo_discovery = {
-  OVERRIDE_ENV_KEY,
-  main_worktree,
-  read_origin_url,
-  resolve_current_owner,
-  scan_siblings,
-  discover_repositories
-};
-
-// scripts/discovery/repo-party.ts
-var FIRST_PARTY = "first-party";
-var THIRD_PARTY = "third-party";
-var UNKNOWN = "unknown";
-function classify3(session_owner, target) {
-  if (session_owner === void 0 || target === void 0) return UNKNOWN;
-  return session_owner.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
+function is_duplicate_merge(carry, change) {
+  const issue = change.merged_issue;
+  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
 }
-function target_owner(owner_repo) {
-  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
+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 current_owner(repository_path = process.cwd()) {
-  return repo_discovery.resolve_current_owner(repository_path);
+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;
 }
-var repo_party = { FIRST_PARTY, THIRD_PARTY, UNKNOWN, classify: classify3, current_owner, target_owner };
+var run_carry_change = { apply_change };
 
-// scripts/lane/lane-registry.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path3 from "node:path";
+// scripts/backlog/backlog-budget-cli.ts
+import { fileURLToPath } from "node:url";
 
-// 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/git/changed-paths.ts
+function to_paths(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
 }
+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 changed_paths = { read_changed_paths, to_paths };
 
-// 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/josh/process-identity.ts
-import { execFileSync as execFileSync2, 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 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 LIVENESS_SIGNAL = 0;
-var LOWEST_REAL_PID = 1;
-var PROC_START_FIELD_INDEX = 19;
-var BEACON_SCHEME = "socket:";
-var BEACON_SUFFIX = ".sock";
-var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
-var BEACON_ID_LENGTH = 36;
-var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
-var WINDOWS_PLATFORM = "win32";
-var SOCKET_PROBE_SOURCE = "const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(0));socket.once('error',()=>process.exit(1));socket.setTimeout(1000,()=>process.exit(1));";
-var beacons = /* @__PURE__ */ new Map();
-var exit_cleanup = { is_registered: false };
-function is_live_pid(pid) {
-  if (pid < LOWEST_REAL_PID) return false;
-  try {
-    process.kill(pid, LIVENESS_SIGNAL);
-    return true;
-  } catch {
-    return false;
-  }
+// 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 read_proc_start(pid) {
-  try {
-    const stat = readFileSync3(`/proc/${String(pid)}/stat`, "utf8");
-    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
-    const start = fields[PROC_START_FIELD_INDEX];
-    return start === void 0 ? void 0 : `proc:${start}`;
-  } catch {
-    return void 0;
+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 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 print_decision(key2, answer, reason, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [key2]: answer, reason }));
+    return;
   }
+  console.info(answer);
+  console.error(reason);
 }
-function read_ps_start(pid) {
-  try {
-    const printed = execFileSync2(
-      PS_COMMAND,
-      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
-      {
-        encoding: "utf8",
-        timeout: PROBE_TIMEOUT_MS,
-        stdio: ["ignore", "pipe", "ignore"],
-        env: PROBE_ENVIRONMENT
-      }
-    ).trim();
-    return printed.length > 0 ? printed : void 0;
-  } catch {
-    return void 0;
+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 START_PROBES = { read_proc_start, read_ps_start };
-function safe_probe(probe, pid) {
+var path_decision = {
+  format_path_list,
+  has_unknown_flag,
+  JSON_FLAG,
+  parse_options,
+  print_decision,
+  run_path_decision
+};
+
+// 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 probe(pid);
+    return parseArgs(config);
   } catch {
     return void 0;
   }
 }
-function read_start(pid, probes = START_PROBES) {
-  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
-}
-function close_beacon(token) {
-  const server = beacons.get(token);
-  if (server === void 0) return;
-  beacons.delete(token);
-  server.close();
-  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
-}
-function close_beacons() {
-  for (const token of beacons.keys()) close_beacon(token);
-}
-function ensure_exit_cleanup() {
-  if (exit_cleanup.is_registered) return;
-  exit_cleanup.is_registered = true;
-  process.once("exit", close_beacons);
+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 ignore_beacon_error() {
+function text_of(value) {
+  return typeof value === "string" ? value : void 0;
 }
-function bind_beacon(target) {
-  return createServer().on("error", ignore_beacon_error).listen(target);
+function to_answer(raw) {
+  return backlog_budget.ANSWERS.find((answer) => answer === raw);
 }
-function try_bind_beacon(bind, target) {
-  try {
-    const server = bind(target);
-    return server.listening ? server : void 0;
-  } catch {
-    return void 0;
-  }
+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 open_beacon(bind = bind_beacon) {
-  const target = path2.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
-  const token = `${BEACON_SCHEME}${target}`;
-  const server = try_bind_beacon(bind, target);
-  if (server === void 0) return void 0;
-  server.unref();
-  beacons.set(token, server);
-  ensure_exit_cleanup();
-  return token;
+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 resolve_own_start(probes = START_PROBES, platform2 = process.platform) {
-  const start = read_start(process.pid, probes);
-  if (start !== void 0 || platform2 === WINDOWS_PLATFORM) return start;
-  return open_beacon();
+function is_readable(raw, parsed) {
+  return raw === void 0 || parsed !== void 0;
 }
-function is_valid_beacon_name(name) {
-  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
-  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
-  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
+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 beacon_target(token) {
-  if (!token.startsWith(BEACON_SCHEME)) return void 0;
-  const target = token.slice(BEACON_SCHEME.length);
-  if (path2.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
-  return is_valid_beacon_name(path2.basename(target)) ? target : void 0;
+function are_counts_readable(values, counts) {
+  return COUNT_NAMES.every((name) => is_readable(text_of(values[name]), counts[name]));
 }
-function is_live_beacon(target) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
-    stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS
-  }).status === 0;
+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 has_matching_start(pid, recorded_start, read2) {
-  const observed = read2(pid);
-  return observed === void 0 ? void 0 : observed === recorded_start;
+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 matches_recorded_start(pid, recorded_start, read2) {
-  const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read2) : is_live_beacon(target);
+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));
 }
-var own_probe = /* @__PURE__ */ new Map();
-function own_start() {
-  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
-  return own_probe.get(process.pid);
+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)
+  };
 }
-function own_fields() {
-  const start = own_start();
-  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
+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 is_same_process(pid, recorded_start, read2 = read_start) {
-  if (pid === void 0 || !is_live_pid(pid)) return false;
-  if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read2);
+function refuse() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE2;
 }
-function is_own_process(pid, recorded_start) {
-  return pid === process.pid && recorded_start === own_start();
+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;
 }
-var process_identity = {
-  close_beacon,
-  is_live_pid,
-  is_own_process,
-  is_same_process,
-  open_beacon,
-  own_fields,
-  own_start,
-  read_start,
-  resolve_own_start
+function main(argv) {
+  process.exitCode = run(argv);
+}
+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/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-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_FOUND = -1;
+function tokens_of(invocation) {
+  return invocation.split(TOKEN_SEPARATOR).filter((token) => token.length > EMPTY_LENGTH2);
 }
-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 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 resolve2(cwd) {
-  try {
-    return select_linked(read_directories(cwd));
-  } catch {
-    return 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 repository(cwd) {
-  try {
-    return read_directories(cwd)[COMMON_GIT_DIRECTORY];
-  } catch {
-    return void 0;
+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;
 }
-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 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 parse_owner(raw) {
-  if (raw === void 0) return void 0;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
+function take_leading_prefixed(args) {
+  const stop = args.findIndex((token) => !token.startsWith(ISSUE_PREFIX));
+  return args.slice(FIRST_TOKEN, stop === NOT_FOUND ? 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 read_owner(target) {
-  return parse_owner(stamp_file.read_stamp_text(target));
+function issue_token(issue) {
+  return `${ISSUE_PREFIX}${String(issue)}`;
 }
-function is_owner_gone(owner) {
-  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
+function joined(command, rendered) {
+  return [command, ...rendered].join(TOKEN_SEPARATOR);
 }
-function restore(aside, target) {
-  try {
-    linkSync(aside, target);
-  } catch {
-  }
+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 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 rebuild(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  return rebuilt_backlog(tokens);
 }
-function move_aside(target) {
-  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
+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
+};
+
+// 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 = z6.object({
+  invocation: z6.string(),
+  started_at: z6.string(),
+  merged: z6.number(),
+  merged_issues: z6.array(z6.number()).optional(),
+  filed: z6.number(),
+  cuts: z6.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: z6.number().default(0),
+  // Defaulted for the same backward-compatibility as `failures` (joshuafolkken/kit#2240).
+  outages: z6.number().default(0),
+  // Optional, so a record written before the outage fold existed still parses (joshuafolkken/kit#2317).
+  last_outage_at: z6.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: z6.number().optional(),
+  owner_start: z6.string().optional(),
+  is_handed_off: z6.boolean().optional(),
+  done: z6.array(z6.number()).optional(),
+  // Optional, so a record written before the retrospective existed still parses (joshuafolkken/kit#2328).
+  retrospective: z6.boolean().optional()
+});
+function carry_path(git_directory) {
+  return stamp_file.stamp_path(CARRY_PREFIX, git_directory);
+}
+async function repository_directory() {
+  const directories2 = await git_command.git_directories();
+  return directories2[REPOSITORY_DIRECTORY_INDEX];
+}
+function parse_carry(raw) {
   try {
-    renameSync(target, aside);
-    return aside;
+    const parsed = run_carry_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
   } catch {
     return void 0;
   }
 }
-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_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 claim(target) {
-  clear_stale(target);
-  return stamp_file.create_stamp(target, process_identity.own_fields());
+function classify3(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 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 read_carry(target, now = /* @__PURE__ */ new Date()) {
+  return classify3(stamp_file.read_stamp_text(target), now);
 }
-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;
+function owner_of(pid, read2 = process_identity.read_start) {
+  return { pid, start: read2(pid) };
 }
-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);
-  }
+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
+  };
 }
-var repository_lock = { clear_stale, lock_path, with_lock };
-
-// 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 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 worktree_list() {
-  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
+function replace_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+  stamp_file.remove_stamp(target);
+  return begin_carry(target, invocation, owner, now);
 }
-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 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;
 }
-async function worktree_add_detached(directory, commit2) {
-  return await locked([WORKTREE, "add", "--detach", directory, commit2]);
+function is_owner_live(carry) {
+  return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false;
 }
-async function worktree_remove(directory) {
-  return await locked([WORKTREE, "remove", "--force", directory]);
+function is_owned_by(carry, owner) {
+  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
 }
-async function worktree_prune() {
-  return await locked([WORKTREE, "prune"]);
+function is_foreign_live_owner(carry, owner) {
+  return is_owner_live(carry) && !is_owned_by(carry, owner);
 }
-async function ls_remote_branch(branch_name) {
-  return await git_spawn.read(ls_remote_branch_arguments(branch_name));
+function is_handed_off_to(carry, invocation) {
+  return carry.is_handed_off === true && carry.invocation === invocation;
 }
-async function branch_delete(branch_name) {
-  return await git_spawn.read(["branch", "-D", branch_name]);
+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 git_worktree = {
-  branch_delete,
-  ls_remote_branch,
-  worktree_add,
-  worktree_add_detached,
-  worktree_list,
-  worktree_prune,
-  worktree_remove
-};
-
-// 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 is_count_refused(carry, owner) {
+  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
 }
-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_at_cut_cap(carry) {
+  return carry.cuts >= MAX_CUTS;
 }
-function is_seed_line(line) {
-  return is_key_line(line, PORT_SEED_KEY);
+function end_carry(target) {
+  stamp_file.remove_stamp(target);
 }
-function is_seat_line(line) {
-  return is_key_line(line, LANE_SEAT_KEY);
+function retrospective_done_of(read2) {
+  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
+  return read2.carry.retrospective === true;
 }
-function is_output_line(line) {
-  return is_key_line(line, LANE_OUTPUT_KEY);
+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 split_lines(content) {
-  const trimmed2 = content.trimEnd();
-  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
+function done_note(carry) {
+  const done = carry.done ?? [];
+  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
 }
-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 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 unquote(raw) {
-  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : 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 assignment_value(line) {
-  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
+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 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 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 read_root_seed(content) {
-  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
+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.`;
 }
-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 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 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 lost_message() {
+  return `Another process established a run record here first, so nothing was established. Read it with \`${READ_COMMAND2}\`.`;
+}
+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_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 unknown_message3() {
+  return "This repository\u2019s git directory could not be read, so no run record was established.";
+}
+var run_carry = {
+  CARRY_MAX_AGE_HOURS,
+  CARRY_MAX_AGE_MS,
+  END_COMMAND: 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: classify3,
+  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/run/run-ship-detach.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
+import { z as z8 } from "zod";
+
+// scripts/run/detached-launch.ts
+import { spawn } from "node:child_process";
+import { closeSync, constants, openSync, writeSync } from "node:fs";
+
+// scripts/agent/agent-launch-environment.ts
+import { existsSync, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from "node:fs";
+import path3 from "node:path";
+
+// scripts/gh/gh-cli-token.ts
+import { execaSync } from "execa";
+var GH_CLI_TIMEOUT_MS = 5e3;
+function get() {
+  try {
+    const { stdout } = execaSync("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
+    const token = stdout.trim();
+    return token.length > 0 ? token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var gh_cli_token = { get };
+
+// scripts/agent/codex-home-source.ts
+import os from "node:os";
+import path2 from "node:path";
+function default_home() {
+  return path2.join(os.homedir(), ".codex");
+}
+var codex_home_source = { default_home };
+
+// scripts/agent/agent-launch-environment.ts
+var OPENAI_PROVIDER2 = "openai";
+var REVIEWER_HOME = ["node_modules", ".cache", "josh", "openai", "reviewer-home"];
+var HOME_FILES = ["auth.json", "config.toml"];
+var PRIVATE_DIRECTORY_MODE = 448;
+function openai_environment() {
+  const token = gh_cli_token.get();
+  return token === void 0 ? { TMPDIR: PLATFORM_TEMP_ROOT } : { GH_TOKEN: token, TMPDIR: PLATFORM_TEMP_ROOT };
+}
+function remove_old_home_link(source, target) {
+  const current = lstatSync(target, { throwIfNoEntry: false });
+  if (current === void 0) return false;
+  if (!current.isSymbolicLink()) throw new Error(`Reviewer home file is not a link: ${target}`);
+  if (existsSync(source) && readlinkSync(target) === source) return true;
+  unlinkSync(target);
+  return false;
+}
+function link_home_file(source_home, target_home, name) {
+  const source = path3.join(source_home, name);
+  const target = path3.join(target_home, name);
+  if (!remove_old_home_link(source, target) && existsSync(source)) symlinkSync(source, target);
+}
+function reviewer_home(cwd, environment2) {
+  const source = environment2["CODEX_HOME"] ?? process.env["CODEX_HOME"] ?? codex_home_source.default_home();
+  const target = path3.resolve(cwd, ...REVIEWER_HOME);
+  mkdirSync(target, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  for (const name of HOME_FILES) link_home_file(source, target, name);
+  return target;
+}
+function build(cwd, profile, environment2 = {}) {
+  if (profile?.provider !== OPENAI_PROVIDER2) return environment2;
+  const base = { ...openai_environment(), ...environment2 };
+  return profile.role === agent_role_profile.REVIEWER ? { ...base, CODEX_HOME: reviewer_home(cwd, environment2) } : base;
+}
+var agent_launch_environment = { build };
+
+// scripts/run/detached-launch.ts
+var NO_PID_NOTE = "the process started without a pid";
+var UNSAFE_NOTE = "the wake command or its arguments contain characters that are not safe to execute";
+var { is_safe_value: is_safe_value2 } = agent_role_profile;
+function is_safe_argv(argv) {
+  return is_safe_value2(argv.command) && argv.args.every((value) => is_safe_value2(value));
+}
+function note_of(error) {
+  return error instanceof Error ? error.message : JSON.stringify(error);
+}
+function launched(pid) {
+  return { kind: "launched", pid };
+}
+var LOG_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW;
+var LOG_MODE = 384;
+function profile_suffix(profile) {
+  return profile === void 0 ? "" : ` \xB7 ${agent_role_profile.describe(profile)}`;
+}
+function log_header(argv, profile) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `
+=== ${stamp} \xB7 started by process ${String(process.pid)} \xB7 ${argv.command}${profile_suffix(profile)} ===
+`;
+}
+function opened_log(log_path2, on_error) {
+  const descriptor = openSync(log_path2, LOG_FLAGS, LOG_MODE);
+  if (!stamp_file.is_own_regular_file(log_path2)) {
+    closeSync(descriptor);
+    on_error(`${log_path2} is not this account's own file, so nothing is kept there`);
+    return void 0;
+  }
+  return descriptor;
+}
+function stamped(descriptor, argv, profile, on_error) {
+  if (descriptor === void 0) return;
+  try {
+    writeSync(descriptor, log_header(argv, profile));
+  } catch (error) {
+    on_error(`the session log could not be written: ${note_of(error)}`);
+  }
+}
+function open_log(log_path2, on_error) {
+  if (log_path2 === void 0) return void 0;
+  try {
+    return opened_log(log_path2, on_error);
+  } catch (error) {
+    on_error(`the session log at ${log_path2} could not be opened: ${note_of(error)}`);
+    return void 0;
+  }
+}
+function ensure_log(log_path2, on_error) {
+  const descriptor = open_log(log_path2, on_error);
+  if (descriptor !== void 0) closeSync(descriptor);
+}
+function spawn_options(cwd, log, environment2 = {}, is_detached = true) {
   return {
-    development: ports.resolve_development_port(environment),
-    preview: ports.resolve_preview_port(environment)
+    cwd,
+    detached: is_detached,
+    stdio: log === void 0 ? "ignore" : ["ignore", log, log],
+    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment2 }
   };
 }
-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 notify_spawn(pid, on_spawn, on_error) {
+  if (pid === void 0) return;
+  try {
+    on_spawn(pid);
+  } catch (error) {
+    on_error(`the child state could not be recorded: ${note_of(error)}`);
+  }
 }
-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)
+async function attached_spawn(request, log, on_error, on_spawn) {
+  return await new Promise((resolve3) => {
+    const environment2 = agent_launch_environment.build(request.cwd, request.profile, request.env);
+    const child = spawn(
+      request.argv.command,
+      [...request.argv.args],
+      spawn_options(request.cwd, log, environment2, false)
+    );
+    child.once("error", (error) => {
+      on_error(note_of(error));
+      resolve3({ kind: "failed", note: note_of(error) });
+    });
+    child.once("exit", (exit_code) => {
+      resolve3({ kind: "completed", pid: child.pid ?? 0, exit_code });
+    });
+    notify_spawn(child.pid, on_spawn, on_error);
   });
 }
-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 ignore_spawn(_pid) {
 }
-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 spawned(request, log, on_error) {
+  const { command, args } = request.argv;
+  const environment2 = agent_launch_environment.build(request.cwd, request.profile, request.env);
+  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment2));
+  child.on("error", (error) => {
+    on_error(note_of(error));
+  });
+  child.unref();
+  return child.pid === void 0 ? { kind: "failed", note: NO_PID_NOTE } : launched(child.pid);
 }
-function lane_file_content(root_content, seat) {
-  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
+function launch(request, on_error) {
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return spawned(request, log, on_error);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
 }
-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);
+async function launch_attached(request, on_error, on_spawn = ignore_spawn) {
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return await attached_spawn(request, log, on_error, on_spawn);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
 }
-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 detached_launch = {
+  UNSAFE_NOTE,
+  ensure_log,
+  is_safe_argv,
+  is_safe_value: is_safe_value2,
+  launch,
+  launch_attached,
+  log_header,
+  note_of
 };
 
-// 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-event-stream.ts
+import { z as z7 } from "zod";
+var EVENT_PREFIX = "josh-run-events-";
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 500;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR = "\n";
+var EVENT_KIND = {
+  PLAN: "plan",
+  CHILD_LAUNCH: "child-launch",
+  MERGE: "merge",
+  PARK: "park",
+  SPLIT: "split",
+  OUTAGE: "outage",
+  CUT: "cut",
+  // The backlog emptied while nothing of the run's own was in flight — the drain
+  // (joshuafolkken/kit#2335). It marks the position at which the end-of-run retrospective is owed,
+  // *before* the idle watch opens, so `run:step` fires the retrospective at the drain rather than after
+  // the watch runs its course. It is not itself a stop: the run watches on once the retrospective has
+  // run, and the real `STOP` follows when the watch expires.
+  DRAIN: "drain",
+  STOP: "stop",
+  PR_OPENED: "pr-opened",
+  REVIEW_ROUND: "review-round",
+  // The end-of-run retrospective's result, recorded when the run marks the retrospective done
+  // (joshuafolkken/kit#2342). A retrospective that files zero improvements and one that never ran look
+  // the same from outside — no new Issue either way — so the result is put on the stream the report is
+  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
+  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
+  // what it found are one action rather than two the run could do only one of.
+  RETROSPECTIVE: "retrospective",
+  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
+  // while (joshuafolkken/kit#2359). Emitted once per stall episode by the stop-time detector, it is
+  // both the dedup marker — `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes
+  // (joshuafolkken/kit#2464) — and the line a
+  // terminal reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
+  // stalled is pointed straight at dispatching the work rather than left waiting.
+  STALL: "stall",
+  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
+  // is watching (joshuafolkken/kit#2375). Emitted once per strand episode by the stop-time detector,
+  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
+  // than once, and a terminal reader following the stream sees the line. The strand is the step before
+  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
+  STRANDED: "stranded",
+  // One `josh ship` stage starting, succeeding or failing (joshuafolkken/kit#2426). It is a trace of the
+  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
+  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
+  // — so it is one of the `TRACE_KINDS` the last-event read skips.
+  SHIP_STAGE: "ship-stage",
+  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints
+  // (joshuafolkken/kit#2437). Printed only to the watcher's own output, a headless successor's heartbeat
+  // was buried in its log after a cut; on the stream it reaches the attached session's relay. It says
+  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
+  HEARTBEAT: "heartbeat",
+  // The post-implementation region handed to a detached `josh ship --detach` supervisor
+  // (joshuafolkken/kit#2428). Unlike a stage trace it is a position: the agent has ended and the
+  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
+  SHIP_LAUNCH: "ship-launch",
+  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
+  // (joshuafolkken/kit#2428). The position that hands control back: `run:step` prints the command that
+  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
+  SHIP_STOP: "ship-stop"
+};
+var EVENT_KINDS = Object.values(EVENT_KIND);
+var TRACE_KINDS = /* @__PURE__ */ new Set([EVENT_KIND.SHIP_STAGE, EVENT_KIND.HEARTBEAT]);
+var event_schema = z7.object({
+  pos: z7.number(),
+  at: z7.string(),
+  kind: z7.string(),
+  text: z7.string()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
 }
-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 target_of(repository2) {
+  return stamp_file.stamp_path(EVENT_PREFIX, repository2, EVENT_SUFFIX);
 }
-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 is_present(event) {
+  return event !== void 0;
 }
-function read_environment(directory) {
-  return file_reader.read_if_readable(path3.join(directory, ENV_FILE_NAME));
+function parse_line(line) {
+  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
 }
-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 read_events(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
 }
-function is_gone(directory) {
-  return !existsSync2(directory);
+function last_position(events) {
+  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
 }
-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);
+function serialize(events) {
+  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
+}
+function append(target, kind, text, at) {
+  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
+  const existing = read_events(target);
+  const position = last_position(existing) + POSITION_INCREMENT;
+  const bounded = [...existing, { pos: position, at, kind, text }].slice(-EVENT_CAP);
+  stamp_file.write_text_stamp(target, serialize(bounded));
+  return { appended: true, position };
+}
+function read_from(target, position) {
+  const events = read_events(target);
   return {
-    issue,
-    branch: branch2,
-    directory,
-    seat: held.seat,
-    development_port: held.development_port,
-    preview_port: held.preview_port,
-    output,
-    profile,
-    is_stranded
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
   };
 }
-function is_lane_directory(root, issue, directory) {
-  return directory === lane_paths.lane_directory(root, issue);
+function read_last(target) {
+  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
+}
+function has_since(events, kind, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT).some((event) => event.kind === kind);
+}
+var FIELD_SEPARATOR = " \xB7 ";
+function format_event(event) {
+  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
+}
+var run_event_stream = {
+  EVENT_CAP,
+  EVENT_KIND,
+  EVENT_KINDS,
+  TRACE_KINDS,
+  append,
+  format_event,
+  has_since,
+  read_events,
+  read_from,
+  read_last,
+  target_of
+};
+
+// scripts/run/run-event-scope.ts
+var SINCE_SCOPE = "since";
+var UNKNOWN_SCOPE = "unknown";
+var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
+function moment_of(at) {
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
 }
-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 is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
 }
-function is_lane(lane) {
-  return lane !== void 0;
+function scoped_events(events, scope) {
+  if (scope.kind === UNKNOWN_SCOPE) return void 0;
+  const floor = moment_of(scope.started_at);
+  if (floor === void 0) return void 0;
+  return events.filter((event) => is_within(event, floor));
 }
-async function worktree_blocks() {
-  const listing = await git_worktree.worktree_list();
-  return listing.split(BLOCK_SEPARATOR);
+function scope_of(read2) {
+  if (read2.kind === "carried" || read2.kind === "expired") {
+    return { kind: SINCE_SCOPE, started_at: read2.carry.started_at };
+  }
+  return UNKNOWN_EVENT_SCOPE;
 }
-async function main_repository_root() {
-  return repo_discovery.main_worktree(await git_command.repository_root());
+function last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
 }
-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));
+var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+  run_event_stream.EVENT_KIND.SHIP_STOP
+]);
+var KIND = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.PARK,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`#${issue} `);
+}
+function is_own_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue);
+}
+function names_issue(event, issue) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1] === issue;
+}
+function is_lane_position(event, issue) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue);
+}
+function since_own_launch(events, issue) {
+  const launch3 = events.findLastIndex(
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue)
+  );
+  return events.slice(launch3 + 1);
+}
+function is_foreign_event(event, issue, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue);
+  return is_foreign_ship_event(event, issue);
+}
+function last_issue_event(events, scope, issue, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue) : events;
+  const own2 = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own2, scope);
+  return own2.findLast((event) => is_own_ship_event(event, issue));
+}
+var run_event_scope = {
+  UNKNOWN_EVENT_SCOPE,
+  last_issue_event,
+  last_scoped_event,
+  scope_of,
+  scoped_events
+};
+
+// scripts/run/run-event-stream-emit.ts
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
 }
-function used_seats(lanes) {
-  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
+async function stream_target() {
+  const repository2 = await run_carry.repository_directory();
+  return repository2 === void 0 ? void 0 : run_event_stream.target_of(repository2);
 }
-function unreadable_lanes(lanes) {
-  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
+async function emit(kind, text) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return;
+    run_event_stream.append(target, kind, text, now_iso());
+  } catch {
+  }
 }
-function find_lane(lanes, issue) {
-  return lanes.find((lane) => lane.issue === issue);
+async function emit_once(kind, text) {
+  try {
+    const target = await stream_target();
+    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
+    return run_event_stream.append(target, kind, text, now_iso()).appended;
+  } catch {
+    return false;
+  }
 }
-async function find_open_lane(issue) {
-  return find_lane(await list_lanes(), issue);
+function invocation_events(repository2, target) {
+  const events = run_event_stream.read_events(target);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository2)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
 }
-var lane_registry = {
-  find_lane,
-  find_open_lane,
-  list_lanes,
-  main_repository_root,
-  parse_block,
-  read_environment,
-  unreadable_lanes,
-  used_seats
+async function emit_once_since(kind, text, reset_kind) {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return false;
+    const target = run_event_stream.target_of(repository2);
+    if (run_event_stream.has_since(invocation_events(repository2, target), kind, reset_kind)) {
+      return false;
+    }
+    return run_event_stream.append(target, kind, text, now_iso()).appended;
+  } catch {
+    return false;
+  }
+}
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
+}
+async function current_events() {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return [];
+    const read2 = run_carry.read_carry(run_carry.carry_path(repository2));
+    const scope = run_event_scope.scope_of(read2);
+    const events = run_event_stream.read_events(run_event_stream.target_of(repository2));
+    return run_event_scope.scoped_events(events, scope) ?? [];
+  } catch {
+    return [];
+  }
+}
+var run_event_stream_emit = {
+  current_events,
+  emit,
+  emit_heartbeat,
+  emit_once,
+  emit_once_since,
+  stream_target
 };
 
-// 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 !== "");
+// scripts/run/run-ship-detach.ts
+var LOG_PREFIX = "josh-ship-log-";
+var PID_PREFIX = "josh-ship-pid-";
+var BODY_PREFIX = "josh-ship-notify-";
+var KEY_SEPARATOR = "-";
+var LOG_SUFFIX = ".log";
+var BODY_SUFFIX = ".txt";
+var PNPM = "pnpm";
+var INLINE_NOTIFY = "--notify-message";
+var FILE_NOTIFY = "--notify-message-file";
+var NOTIFY_VALUE_INDEX = 1;
+var SUPERVISED_KEY = "JOSH_SHIP_SUPERVISED";
+var LAUNCH_ID_KEY = "JOSH_SHIP_LAUNCH_ID";
+var SUPERVISED_VALUE = "1";
+var LAUNCHED = "launched";
+var BUSY = "busy";
+var FAILED = "failed";
+var RESULT_PREFIX = "josh-ship-result-";
+var RECORD_POLL_MS = 25;
+var RECORD_WAIT_ATTEMPTS = 200;
+var CLAIM_WINDOW_MS = 12e4;
+var ship_record_schema = z8.object({
+  pid: z8.number().int().positive().optional(),
+  process_start: z8.string().optional(),
+  launched_at: z8.number().optional(),
+  launcher_pid: z8.number().int().positive().optional(),
+  launcher_start: z8.string().optional(),
+  launch_id: z8.string(),
+  result: z8.enum(["success", "failed"]).optional()
+});
+var LAUNCH_MARK = " \xB7 started by process ";
+var HEADER_START = "\n";
+function key(prefix, request) {
+  return stamp_file.stamp_path(`${prefix}${request.number}${KEY_SEPARATOR}`, request.repository);
 }
-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 log_path(repository2, number) {
+  return stamp_file.stamp_path(`${LOG_PREFIX}${number}${KEY_SEPARATOR}`, repository2, LOG_SUFFIX);
 }
-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 result_path(repository2, number) {
+  return stamp_file.stamp_path(`${RESULT_PREFIX}${number}${KEY_SEPARATOR}`, repository2);
 }
-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 read_record(repository2, number) {
+  try {
+    const raw = stamp_file.read_stamp_text(result_path(repository2, number));
+    if (raw === void 0) return void 0;
+    const value = JSON.parse(raw);
+    const parsed = ship_record_schema.safeParse(value);
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
 }
-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 record_launch(request, pid, launch_id) {
+  stamp_file.write_text_stamp(key(PID_PREFIX, request), String(pid));
+  const process_start = process_identity.read_start(pid);
+  stamp_file.replace_stamp(result_path(request.repository, request.number), {
+    pid,
+    launch_id,
+    launched_at: Date.now(),
+    ...process_start !== void 0 && { process_start }
+  });
 }
-function print_decision(key, answer, reason, is_json) {
-  if (is_json) {
-    console.info(JSON.stringify({ [key]: answer, reason }));
-    return;
+function supervisor_environment(launch_id) {
+  return {
+    ...agent_role_profile.handoff_environment(),
+    [SUPERVISED_KEY]: SUPERVISED_VALUE,
+    [LAUNCH_ID_KEY]: launch_id
+  };
+}
+function is_within_claim_window(record) {
+  return record.launched_at !== void 0 && Date.now() - record.launched_at < CLAIM_WINDOW_MS;
+}
+function has_live_identity(pid, record) {
+  if (record.process_start === void 0) {
+    return is_within_claim_window(record) && process_identity.is_live_pid(pid);
   }
-  console.info(answer);
-  console.error(reason);
+  return process_identity.is_same_process(pid, record.process_start) !== false;
 }
-async function run_path_decision(argv, command) {
-  const options = parse_options(argv);
-  if (options === void 0) {
-    console.error(command.usage);
-    return FAILURE_EXIT_CODE;
+function result_of(record) {
+  if (record.pid === void 0) {
+    const is_launcher = process_identity.is_same_process(record.launcher_pid, record.launcher_start);
+    return is_launcher === false ? "abnormal" : "running";
   }
-  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;
+  if (has_live_identity(record.pid, record)) return "running";
+  return record.result ?? "abnormal";
+}
+function read_result(repository2, number) {
+  const record = read_record(repository2, number);
+  return record === void 0 ? void 0 : { launch_id: record.launch_id, result: result_of(record) };
+}
+function current_record(repository2, number) {
+  const record = read_record(repository2, number);
+  return record?.launch_id === process.env[LAUNCH_ID_KEY] ? record : void 0;
+}
+function is_pending(record) {
+  return record !== void 0 && record.pid === void 0;
+}
+async function ready_record(repository2, number) {
+  let record = current_record(repository2, number);
+  for (let attempt = 0; attempt < RECORD_WAIT_ATTEMPTS; attempt += 1) {
+    if (!is_pending(record)) return record;
+    await sleep(RECORD_POLL_MS);
+    record = current_record(repository2, number);
+  }
+  return void 0;
+}
+async function update_record(repository2, number, fields) {
+  const record = await ready_record(repository2, number);
+  if (record === void 0) return;
+  stamp_file.replace_stamp(result_path(repository2, number), { ...record, ...fields });
+}
+async function mark_result(repository2, number, code) {
+  await update_record(repository2, number, { result: code === 0 ? "success" : "failed" });
+}
+async function claim_identity(repository2, number) {
+  const own2 = process_identity.own_fields();
+  if (own2.process_start === void 0) return;
+  await update_record(repository2, number, own2);
+}
+function failed_launch(request, note) {
+  stamp_file.remove_stamp(result_path(request.repository, request.number));
+  return { verdict: FAILED, note };
+}
+function notify_arguments(request) {
+  const [flag, value] = [request.notify[0], request.notify[NOTIFY_VALUE_INDEX]];
+  if (flag !== INLINE_NOTIFY || value === void 0) return request.notify;
+  const body_path = stamp_file.stamp_path(
+    `${BODY_PREFIX}${request.number}${KEY_SEPARATOR}`,
+    request.repository,
+    BODY_SUFFIX
+  );
+  stamp_file.write_text_stamp(body_path, value);
+  return [FILE_NOTIFY, body_path];
 }
-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
+function supervisor_argv(request) {
+  const review = request.is_review ? ["--review"] : [];
+  const cites = request.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    command: PNPM,
+    args: [
+      "josh",
+      "ship",
+      ...review,
+      ...notify_arguments(request),
+      ...request.body,
+      ...cites,
+      request.title
+    ]
+  };
+}
+function prepare_launch(request) {
+  const launch_id = randomUUID2();
+  const launcher = process_identity.own_fields();
+  stamp_file.replace_stamp(result_path(request.repository, request.number), {
+    launch_id,
+    launcher_pid: launcher.pid,
+    ...launcher.process_start !== void 0 && { launcher_start: launcher.process_start }
+  });
+  return launch_id;
+}
+function launch2(request) {
+  const notes = [];
+  const log = log_path(request.repository, request.number);
+  const launch_id = prepare_launch(request);
+  const result = detached_launch.launch(
+    {
+      argv: supervisor_argv(request),
+      cwd: request.cwd,
+      log_path: log,
+      // The provider travels as a mark because the launch strips the session keys that name it, and
+      // `ship --review` resolves its reviewer from it (joshuafolkken/kit#2456).
+      env: supervisor_environment(launch_id)
+    },
+    (note) => {
+      notes.push(note);
+    }
+  );
+  if (result.kind === "failed") return failed_launch(request, result.note);
+  record_launch(request, result.pid, launch_id);
+  return {
+    verdict: LAUNCHED,
+    note: [`supervisor ${String(result.pid)} \u2014 log: ${log}`, ...notes].join("\n")
+  };
+}
+async function detach(request) {
+  if (read_result(request.repository, request.number)?.result === "running") {
+    return { verdict: BUSY, note: `a ship supervisor for #${request.number} is already running` };
+  }
+  const result = launch2(request);
+  if (result.verdict === LAUNCHED) {
+    await run_event_stream_emit.emit(
+      run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+      `#${request.number} ship supervisor launched`
+    );
+  }
+  return result;
+}
+function last_launch(text) {
+  const mark = text.lastIndexOf(LAUNCH_MARK);
+  if (mark === -1) return text;
+  return text.slice(text.lastIndexOf(HEADER_START, mark) + HEADER_START.length);
+}
+function read_log(repository2, number) {
+  const text = stamp_file.read_stamp_text(log_path(repository2, number));
+  return text === void 0 ? void 0 : last_launch(text);
+}
+function is_supervised(source = process.env) {
+  return source[SUPERVISED_KEY] === SUPERVISED_VALUE;
+}
+var run_ship_detach = {
+  BUSY,
+  FAILED,
+  LAUNCHED,
+  LAUNCH_ID_KEY,
+  claim_identity,
+  mark_result,
+  read_result,
+  SUPERVISED_KEY,
+  detach,
+  is_supervised,
+  last_launch,
+  log_path,
+  read_log,
+  supervisor_argv
 };
 
-// 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}`;
+// scripts/lane/lane-handoff.ts
+function is_ship_running(issue, directory) {
+  const repository2 = git_common_directory.repository(directory);
+  return repository2 !== void 0 && run_ship_detach.read_result(repository2, issue)?.result === "running";
 }
-function parse_or_undefined(config) {
-  try {
-    return parseArgs(config);
-  } catch {
-    return void 0;
-  }
+function is_handed_off(directory, source = process.env) {
+  const issue = lane_child_marker.marked_issue(source);
+  if (issue === void 0 || !lane_child_marker.is_child_of(directory, source)) return false;
+  return is_ship_running(issue, directory);
 }
-var cli_flags = { refuse_unknown_flags, parse_or_undefined };
+var lane_handoff = { is_handed_off, is_ship_running };
 
-// 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" }
+// scripts/issue/issue-labels.ts
+var EPIC_LABEL = "epic";
+var ENHANCEMENT_LABEL = "enhancement";
+var BREAKING_CHANGE_LABEL = "breaking-change";
+var IN_PROGRESS_LABEL = "in-progress";
+var PLANNED_LABEL = "run:planned";
+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";
+var REVIEW_CAP_ROUTE_LABEL = "route:review-cap";
+var SPLIT_ROUTE_LABEL = "route:split";
+var TIER_A_ROUTE_LABEL = "route:tier-a";
+var FILING_ROUTE_LABELS = [
+  {
+    name: INTERRUPT_ROUTE_LABEL,
+    // Not `5319e7`, which is the `epic` label's purple: in a listing an interrupt would render as
+    // an epic, and the two are read at a glance rather than by name.
+    color: "1d76db",
+    // Keyed to the tests rather than to severity. "A serious defect" is the self-assessment
+    // `wip-cap.md` bans as a criterion, and this string is what a person reads in `gh label list`.
+    description: "Filed past the WIP cap \u2014 meets one of the three interrupt tests (wip-cap.md)"
+  },
+  {
+    name: REVIEW_CAP_ROUTE_LABEL,
+    color: "eab308",
+    description: "Filed by the review round cap's carry-forward (prompts/review.md \u2192 Review round cap)"
+  },
+  {
+    name: SPLIT_ROUTE_LABEL,
+    color: "0e8a16",
+    description: "A child issue created by a split (split-assessment.md)"
+  },
+  {
+    name: TIER_A_ROUTE_LABEL,
+    color: "d93f0b",
+    description: "Filed Tier A during implementation \u2014 an upstream defect or a prerequisite"
+  }
+];
+var DEPTH_0_LABEL = "depth:0";
+var DEPTH_1_LABEL = "depth:1";
+var DEPTH_2_LABEL = "depth:2";
+var DEPTH_LABELS = [
+  {
+    name: DEPTH_0_LABEL,
+    color: "0e8a16",
+    description: "Depth 0 \u2014 what a consumer of this package touches (SKILL.md \xA72i)"
+  },
+  {
+    name: DEPTH_1_LABEL,
+    color: "fbc02d",
+    description: "Depth 1 \u2014 the run orchestration that executes an Issue (SKILL.md \xA72i)"
+  },
+  {
+    name: DEPTH_2_LABEL,
+    color: "c5def5",
+    description: "Depth 2 \u2014 what measures a run (SKILL.md \xA72i)"
+  }
+];
+var WORKFLOW_LABELS = [
+  {
+    name: EPIC_LABEL,
+    color: "5319e7",
+    description: "Tracks a batch of child issues from one split"
+  },
+  { name: IN_PROGRESS_LABEL, color: "0075ca", description: "Work is actively in progress" },
+  { name: PLANNED_LABEL, color: "c2e0c6", description: "kickoff posted the plan" },
+  {
+    name: RUN_SOLO_LABEL,
+    color: "b60205",
+    description: "Runs alone in a backlogrun: nothing starts beside it"
+  },
+  {
+    name: RUN_LANE_LABEL,
+    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
+];
+var BUGFIX_LABEL = "bugfix";
+var OTHER_CHANGE_LABEL = "other-change";
+var IGNORE_FOR_RELEASE_LABEL = "ignore-for-release";
+var RELEASE_CLASSIFICATION_NAMES = [
+  BREAKING_CHANGE_LABEL,
+  ENHANCEMENT_LABEL,
+  BUGFIX_LABEL,
+  OTHER_CHANGE_LABEL,
+  IGNORE_FOR_RELEASE_LABEL
+];
+var RELEASE_CLASSIFICATION_METADATA = {
+  [BREAKING_CHANGE_LABEL]: { color: "d93f0b", description: "Release: a breaking change (major)" },
+  [ENHANCEMENT_LABEL]: { color: "84b6eb", description: "Release: a new feature (minor)" },
+  [BUGFIX_LABEL]: { color: "d73a4a", description: "Release: a bug fix (patch)" },
+  [OTHER_CHANGE_LABEL]: { color: "c2e0c6", description: "Release: any other change (patch)" },
+  [IGNORE_FOR_RELEASE_LABEL]: { color: "cfd3d7", description: "Release: left out of the notes" }
 };
-function read_arguments(argv) {
-  return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS, strict: true })?.values;
-}
-function text_of(value) {
-  return typeof value === "string" ? value : void 0;
+var RELEASE_CLASSIFICATION_LABELS = RELEASE_CLASSIFICATION_NAMES.map((name) => ({ name, ...RELEASE_CLASSIFICATION_METADATA[name] }));
+var REPOSITORY_LABELS = [
+  ...WORKFLOW_LABELS,
+  ...RELEASE_CLASSIFICATION_LABELS
+];
+function has_any_label(labels, wanted) {
+  return (labels ?? []).some((label2) => wanted.has(label2.name.toLowerCase()));
 }
-function to_answer(raw) {
-  return backlog_budget.ANSWERS.find((answer) => answer === raw);
+function label_name_of(labels, wanted) {
+  const target = wanted.toLowerCase();
+  return labels.find((label2) => label2.toLowerCase() === target);
 }
-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 has_label_name(labels, wanted) {
+  return label_name_of(labels, wanted) !== void 0;
 }
-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;
+
+// scripts/rules/lane-park.ts
+var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
+var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
+function is_confirmation_notify(command) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
+  );
 }
-function is_readable(raw, parsed) {
-  return raw === void 0 || parsed !== void 0;
+var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
+function mentions_confirmation_notify(text) {
+  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
 }
-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 is_parking_child(directory = process.cwd()) {
+  return lane_child_marker.is_child_of(directory) && !lane_handoff.is_handed_off(directory);
 }
-function are_counts_readable(values, counts) {
-  return COUNT_NAMES.every((name) => is_readable(text_of(values[name]), counts[name]));
+function is_unparked_stop(command, is_child = is_parking_child) {
+  if (!is_confirmation_notify(command)) return false;
+  return is_child();
 }
-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;
+var APPLIES_NEEDS_DECISION = new RegExp(
+  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
+  "u"
+);
+function records_the_park(command) {
+  return APPLIES_NEEDS_DECISION.test(command);
 }
-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;
+var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
+var lane_park = {
+  LANE_PARK_REASON,
+  is_confirmation_notify,
+  is_parking_child,
+  is_unparked_stop,
+  mentions_confirmation_notify,
+  records_the_park
+};
+
+// scripts/discovery/repo-discovery.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import path4 from "node:path";
+
+// scripts/discovery/repo-origin.ts
+var GITHUB_HOST = "github.com";
+var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
+var GIT_SUFFIX = ".git";
+var PATH_SEPARATOR2 = "/";
+var USER_SEPARATOR = "@";
+var HOST_SEPARATOR = ":";
+var OWNER_INDEX = 0;
+var REPO_INDEX = 1;
+var REPO_PATH_SEGMENTS = 2;
+var NOT_FOUND2 = -1;
+var SECTION_PREFIX = "[";
+var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
+var URL_KEY = "url";
+function is_github_hostname(host) {
+  return host.toLowerCase() === GITHUB_HOST;
 }
-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 is_github_ssh_host(host) {
+  const normalized = host.toLowerCase();
+  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
 }
-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)
-  };
+function strip_git_suffix(name) {
+  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : 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 });
+function to_identity(repository_path) {
+  const segments = repository_path.split(PATH_SEPARATOR2).filter((segment) => segment !== "");
+  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
+  const owner = segments[OWNER_INDEX] ?? "";
+  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
+  return repo === "" ? void 0 : { owner, repo };
 }
-function refuse() {
-  console.error(USAGE);
-  return FAILURE_EXIT_CODE2;
+function parse_scp_like(url) {
+  const user_end = url.indexOf(USER_SEPARATOR);
+  const authority = user_end === NOT_FOUND2 ? url : url.slice(user_end + 1);
+  const host_end = authority.indexOf(HOST_SEPARATOR);
+  if (host_end === NOT_FOUND2) return void 0;
+  if (!is_github_ssh_host(authority.slice(0, host_end))) return void 0;
+  return to_identity(authority.slice(host_end + 1));
 }
-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 parse_url_like(url) {
+  try {
+    const parsed = new URL(url);
+    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
+  } 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 parse_origin_url(url) {
+  const trimmed2 = url.trim();
+  if (trimmed2 === "") return void 0;
+  return parse_url_like(trimmed2) ?? parse_scp_like(trimmed2);
 }
-var backlog_budget_cli = {
-  JSON_KEY,
-  OPTIONS,
-  SUCCESS_EXIT_CODE,
-  USAGE,
-  build_input,
-  main,
-  read_arguments,
-  run,
-  to_answer,
-  to_count,
-  to_time_ms
+function is_section_header(line) {
+  return line.startsWith(SECTION_PREFIX);
+}
+function origin_section_lines(lines) {
+  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
+  if (start === NOT_FOUND2) return [];
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => is_section_header(line));
+  return end === NOT_FOUND2 ? rest : rest.slice(0, end);
+}
+function entry_value(line, key2) {
+  const separator = line.indexOf("=");
+  if (separator === NOT_FOUND2) return void 0;
+  if (line.slice(0, separator).trim() !== key2) return void 0;
+  return line.slice(separator + 1).trim();
+}
+function parse_origin_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return origin_section_lines(lines).map((line) => entry_value(line, URL_KEY)).find((url) => url !== void 0);
+}
+function format_identity(identity) {
+  return `${identity.owner}${PATH_SEPARATOR2}${identity.repo}`.toLowerCase();
+}
+var repo_origin = {
+  GITHUB_HOST,
+  is_github_hostname,
+  is_github_ssh_host,
+  parse_origin_from_config,
+  parse_origin_url,
+  format_identity
 };
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
 
-// 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);
+// scripts/discovery/repo-map-logic.ts
+var OVERRIDE_ENTRY_SEPARATOR = ",";
+var OVERRIDE_PAIR_SEPARATOR = "=";
+var OVERRIDE_PAIR_PARTS = 2;
+var KEY_INDEX = 0;
+var PATH_INDEX = 1;
+function is_same_owner(identity, current_owner2) {
+  return identity.owner.toLowerCase() === current_owner2.toLowerCase();
 }
-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 add_entry(target, origin_url, repository_path, current_owner2) {
+  if (origin_url === void 0) return;
+  const identity = repo_origin.parse_origin_url(origin_url);
+  if (identity === void 0 || !is_same_owner(identity, current_owner2)) return;
+  target.set(repo_origin.format_identity(identity), repository_path);
 }
-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 parse_override_entry(entry) {
+  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
+  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
+  const key2 = parts[KEY_INDEX] ?? "";
+  const repository_path = parts[PATH_INDEX] ?? "";
+  if (repository_path === "") return void 0;
+  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key2}` };
 }
-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_overrides(raw) {
+  if (raw === void 0) return [];
+  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
+}
+function build_repository_map(discovered, current_owner2, override_value2) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner2);
+  for (const entry of parse_overrides(override_value2)) {
+    add_entry(result, entry.origin_url, entry.path, current_owner2);
   }
-  return rendered;
+  return result;
 }
-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;
+var repo_map_logic = {
+  is_same_owner,
+  build_repository_map
+};
+
+// scripts/discovery/repo-discovery.ts
+var GIT_DIRECTORY = ".git";
+var GIT_CONFIG = "config";
+var GITDIR_PREFIX = "gitdir:";
+var COMMON_DIRECTORY_FILE = "commondir";
+var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
+function resolve_common_directory(git_directory) {
+  const pointer = path4.join(git_directory, COMMON_DIRECTORY_FILE);
+  if (!existsSync2(pointer)) return git_directory;
+  try {
+    return path4.resolve(git_directory, readFileSync3(pointer, "utf8").trim());
+  } catch {
+    return git_directory;
+  }
 }
-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 follow_git_file(repository_path, git_file) {
+  const pointer = readFileSync3(git_file, "utf8").trim();
+  if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
+  return path4.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
 }
-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 resolve_git_directory(repository_path) {
+  const candidate = path4.join(repository_path, GIT_DIRECTORY);
+  if (!existsSync2(candidate)) return void 0;
+  try {
+    if (statSync(candidate).isDirectory()) return candidate;
+    const linked = follow_git_file(repository_path, candidate);
+    return linked === void 0 ? void 0 : resolve_common_directory(linked);
+  } catch {
+    return void 0;
   }
-  return issues;
 }
-function issue_token(issue) {
-  return `${ISSUE_PREFIX}${String(issue)}`;
+function read_origin_url(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0) return void 0;
+  try {
+    return repo_origin.parse_origin_from_config(
+      readFileSync3(path4.join(git_directory, GIT_CONFIG), "utf8")
+    );
+  } catch {
+    return void 0;
+  }
 }
-function joined(command, rendered) {
-  return [command, ...rendered].join(TOKEN_SEPARATOR);
+function sibling_directories(parent) {
+  try {
+    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path4.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
 }
-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 scan_siblings(parent) {
+  return sibling_directories(parent).map((repository_path) => ({
+    path: repository_path,
+    origin_url: read_origin_url(repository_path)
+  }));
 }
-function rebuild(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
-  return rebuilt_backlog(tokens);
+function resolve_current_owner(repository_path) {
+  const origin_url = read_origin_url(repository_path);
+  if (origin_url === void 0) return void 0;
+  return repo_origin.parse_origin_url(origin_url)?.owner;
 }
-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 main_worktree(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0) return repository_path;
+  if (path4.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
+  return path4.dirname(git_directory);
 }
-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);
+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(path4.dirname(main2)),
+    current_owner2,
+    environment2[OVERRIDE_ENV_KEY]
+  );
 }
-var run_invocation = {
-  has_only,
-  issue_numbers,
-  rebuild
+var repo_discovery = {
+  OVERRIDE_ENV_KEY,
+  main_worktree,
+  read_origin_url,
+  resolve_current_owner,
+  scan_siblings,
+  discover_repositories
 };
 
-// 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;
+// scripts/discovery/repo-party.ts
+var FIRST_PARTY = "first-party";
+var THIRD_PARTY = "third-party";
+var UNKNOWN = "unknown";
+function classify4(session_owner, target) {
+  if (session_owner === void 0 || target === void 0) return UNKNOWN;
+  return session_owner.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
 }
-function next_failures(carry, change) {
-  if (has_increment(change.merged)) return NO_INCREMENT;
-  return carry.failures + (change.failures ?? NO_INCREMENT);
+function target_owner(owner_repo) {
+  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
 }
-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 current_owner(repository_path = process.cwd()) {
+  return repo_discovery.resolve_current_owner(repository_path);
 }
-function folded_outage(carry) {
-  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
+var repo_party = { FIRST_PARTY, THIRD_PARTY, UNKNOWN, classify: classify4, current_owner, target_owner };
+
+// scripts/lane/lane-reap.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+var PGREP_COMMAND = "pgrep";
+var MATCH_FULL_COMMAND_LINE = "-f";
+var CHILDREN_OF_FLAG = "-P";
+var PS_COMMAND2 = "/bin/ps";
+var PARENT_FORMAT = ["-o", "ppid=", "-p"];
+var TERMINATE_SIGNAL = "SIGTERM";
+var PROBE_TIMEOUT_MS3 = 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);
+}
+function run_probe(command, args) {
+  try {
+    return execFileSync3(command, [...args], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return "";
+  }
 }
-function counted_outage(carry, change, now) {
-  const outages = carry.outages + (change.outages ?? NO_INCREMENT);
-  return { outages, last_outage_at: now.toISOString() };
+function parent_of(pid) {
+  return parse_pids(run_probe(PS_COMMAND2, [...PARENT_FORMAT, String(pid)]))[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);
+function terminate(pid) {
+  try {
+    process.kill(pid, TERMINATE_SIGNAL);
+    return true;
+  } catch {
+    return false;
   }
-  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 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
-  };
 }
-var run_carry_streak = { OUTAGE_FOLD_WINDOW_MS, next_state };
+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 own2 = own_ancestry(probes);
+  const pattern = lane_child_invocation.process_pattern(issue);
+  const roots = probes.matching(pattern).filter((pid) => !own2.has(pid));
+  const doomed = tree_of(roots, probes).filter((pid) => !own2.has(pid));
+  return doomed.filter((pid) => probes.terminate(pid));
+}
+var lane_reap = {
+  own_ancestry,
+  parse_pids,
+  reap_child
+};
 
-// 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 next_merged_issues(carry, issue) {
-  if (issue === void 0) return carry.merged_issues;
-  return [...carry.merged_issues ?? [], issue];
-}
-function is_duplicate_merge(carry, change) {
-  const issue = change.merged_issue;
-  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
-}
-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 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;
+// scripts/lane/lane-registry.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path5 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}`];
 }
-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);
+// scripts/git/repository-lock.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
+import { setTimeout as sleep2 } from "node:timers/promises";
+
+// scripts/josh/process-owner.ts
+import { z as z9 } from "zod";
+var process_owner_schema = z9.object({ pid: z9.number(), process_start: z9.string().optional() });
+
+// scripts/git/repository-lock.ts
+var POLL_INTERVAL_MS = 200;
+function lock_path(prefix, cwd) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
 }
-async function repository_directory() {
-  const directories = await git_command.git_directories();
-  return directories[REPOSITORY_DIRECTORY_INDEX];
+function parse_owner(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
 }
-function parse_carry(raw) {
+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 {
-    const parsed = run_carry_schema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : void 0;
+    linkSync(aside, target);
+  } catch {
+  }
+}
+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 move_aside(target) {
+  const aside = `${target}.${String(process.pid)}.${randomUUID3()}`;
+  try {
+    renameSync(target, aside);
+    return aside;
   } catch {
     return void 0;
   }
 }
-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 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 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 claim(target) {
+  clear_stale(target);
+  return stamp_file.create_stamp(target, process_identity.own_fields());
 }
-function read_carry(target, now = /* @__PURE__ */ new Date()) {
-  return classify4(stamp_file.read_stamp_text(target), now);
+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 owner_of(pid, read2 = process_identity.read_start) {
-  return { pid, start: read2(pid) };
+async function acquire(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    await sleep2(POLL_INTERVAL_MS);
+  }
+  return true;
 }
-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 with_lock(work, target, max_wait_ms) {
+  if (!await acquire(target, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target);
+  }
 }
-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;
+var repository_lock = { clear_stale, lock_path, with_lock };
+
+// 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 replace_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
-  stamp_file.remove_stamp(target);
-  return begin_carry(target, invocation, owner, now);
+async function worktree_list() {
+  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
 }
-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;
+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_owner_live(carry) {
-  return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false;
+async function worktree_add_detached(directory, commit2) {
+  return await locked([WORKTREE, "add", "--detach", directory, commit2]);
 }
-function is_owned_by(carry, owner) {
-  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
+async function worktree_remove(directory) {
+  return await locked([WORKTREE, "remove", "--force", directory]);
 }
-function is_foreign_live_owner(carry, owner) {
-  return is_owner_live(carry) && !is_owned_by(carry, owner);
+async function worktree_prune() {
+  return await locked([WORKTREE, "prune"]);
 }
-function is_handed_off_to(carry, invocation) {
-  return carry.is_handed_off === true && carry.invocation === invocation;
+async function ls_remote_branch(branch_name) {
+  return await git_spawn.read(ls_remote_branch_arguments(branch_name));
 }
-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";
+async function branch_delete(branch_name) {
+  return await git_spawn.read(["branch", "-D", branch_name]);
 }
-function is_count_refused(carry, owner) {
-  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
+var git_worktree = {
+  branch_delete,
+  ls_remote_branch,
+  worktree_add,
+  worktree_add_detached,
+  worktree_list,
+  worktree_prune,
+  worktree_remove
+};
+
+// 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 is_at_cut_cap(carry) {
-  return carry.cuts >= MAX_CUTS;
+function is_key_line(line, key2) {
+  const body = strip_export(line);
+  if (!body.startsWith(key2)) return false;
+  return body.slice(key2.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
 }
-function end_carry(target) {
-  stamp_file.remove_stamp(target);
+function is_seat_line(line) {
+  return is_key_line(line, LANE_SEAT_KEY);
 }
-function retrospective_done_of(read2) {
-  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
-  return read2.carry.retrospective === true;
+function is_output_line(line) {
+  return is_key_line(line, LANE_OUTPUT_KEY);
 }
-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 split_lines(content) {
+  const trimmed2 = content.trimEnd();
+  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
 }
-function done_note(carry) {
-  const done = carry.done ?? [];
-  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
+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 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 unquote(raw) {
+  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : 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 assignment_value(line) {
+  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
 }
-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 read_assignment(content, key2) {
+  const line = split_lines(content).findLast((entry) => is_key_line(entry, key2));
+  return line === void 0 ? void 0 : assignment_value(line);
 }
-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 read_root_seed(content) {
+  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
 }
-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.`;
+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 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 {
+    development: ports.resolve_development_port(environment2),
+    preview: ports.resolve_preview_port(environment2)
+  };
+}
+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 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 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 lost_message() {
-  return `Another process established a run record here first, so nothing was established. Read it with \`${READ_COMMAND2}\`.`;
+function replace_assignment(lines, keep, assignment, key2) {
+  return lines.flatMap((entry, index) => {
+    if (index === keep) return [assignment];
+    return is_key_line(entry, key2) ? [] : [entry];
+  });
 }
-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 upsert_assignment(content, key2, value) {
+  const assignment = `${key2}${ASSIGNMENT_SEPARATOR}${value}`;
+  const lines = split_lines(content);
+  const last = lines.findLastIndex((entry) => is_key_line(entry, key2));
+  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key2);
+  return `${body.join("\n")}
+`;
 }
-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 lane_file_content(root_content, seat) {
+  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
 }
-function unknown_message3() {
-  return "This repository\u2019s git directory could not be read, so no run record was established.";
+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 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_environment = {
+  is_seat_line,
+  lane_file_content,
+  read_lane_output,
+  read_lane_profile,
+  read_lane_ports,
+  read_lane_seat,
+  read_root_seed,
+  with_lane_output
 };
 
-// scripts/run/run-progress-clock.ts
-import { execaSync } from "execa";
-import { z as z6 } from "zod";
-var PROGRESS_PREFIX = "josh-run-progress-";
-var LIFE_PREFIX = "josh-run-progress-life-";
-var LOG_SUFFIX = ".log";
-var LOG_KEEP = 12;
-var MS_PER_MINUTE2 = 6e4;
-var LOG_STALE_MINUTES = 90;
-var LOG_STALE_MS = LOG_STALE_MINUTES * MS_PER_MINUTE2;
-var BLOCK_SEPARATOR2 = "\n\n";
-var GIT_TIMEOUT_MS = 5e3;
-var GIT_DIRECTORY_ARGUMENTS2 = ["rev-parse", "--absolute-git-dir"];
-var report_stamp_schema = z6.object({ reported_at: z6.string(), line: z6.string().optional() });
-function parse_stamp(raw) {
-  const parsed = report_stamp_schema.safeParse(JSON.parse(raw));
-  if (!parsed.success) return void 0;
-  const reported_at = Date.parse(parsed.data.reported_at);
-  return Number.isNaN(reported_at) ? void 0 : reported_at;
-}
-function read_last_line(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return void 0;
-  try {
-    return report_stamp_schema.safeParse(JSON.parse(raw)).data?.line;
-  } catch {
-    return void 0;
-  }
+// 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 read_last_report(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return void 0;
-  try {
-    return parse_stamp(raw);
-  } catch {
-    return void 0;
-  }
+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 log_path_of(target) {
-  return `${target}${LOG_SUFFIX}`;
+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 is_log_stale(target, now_ms) {
-  const previous_ms = read_last_report(target);
-  return previous_ms === void 0 || now_ms - previous_ms > LOG_STALE_MS;
+function read_environment(directory) {
+  return file_reader.read_if_readable(path5.join(directory, ENV_FILE_NAME));
 }
-function recent_blocks(log_target, is_fresh) {
-  if (is_fresh) return [];
-  const raw = stamp_file.read_stamp_text(log_target);
-  if (raw === void 0) return [];
-  return raw.split(BLOCK_SEPARATOR2).map((block) => block.trimEnd()).filter((block) => block.length > 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 append_line(log_target, reported_at, line, is_fresh) {
-  const block = `${reported_at}
-${line}`;
-  const blocks = [...recent_blocks(log_target, is_fresh), block].slice(-LOG_KEEP);
-  stamp_file.write_text_stamp(log_target, `${blocks.join(BLOCK_SEPARATOR2)}
-`);
+function is_gone(directory) {
+  return !existsSync3(directory);
 }
-function mark(target, now_ms, line) {
-  const reported_at = new Date(now_ms).toISOString();
-  const kept = line ?? read_last_line(target);
-  if (line !== void 0) {
-    append_line(log_path_of(target), reported_at, line, is_log_stale(target, now_ms));
-  }
-  stamp_file.write_stamp(target, kept === void 0 ? { reported_at } : { reported_at, line: kept });
+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 stamp_target_of(git_directory) {
-  return stamp_file.stamp_path(PROGRESS_PREFIX, git_directory);
+function is_lane_directory(root, issue, directory) {
+  return directory === lane_paths.lane_directory(root, issue);
 }
-function life_target_of(git_directory) {
-  return stamp_file.stamp_path(LIFE_PREFIX, git_directory);
+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));
 }
-var life_schema = z6.object({ alive: z6.literal(true), pinged_at: z6.string().optional() });
-function begin_life(target) {
-  stamp_file.write_stamp(target, { alive: true, pinged_at: (/* @__PURE__ */ new Date()).toISOString() });
+function is_lane(lane) {
+  return lane !== void 0;
 }
-function ping_life(target) {
-  begin_life(target);
+async function worktree_blocks() {
+  const listing = await git_worktree.worktree_list();
+  return listing.split(BLOCK_SEPARATOR);
 }
-function parse_pinged_at(raw) {
-  const parsed = life_schema.safeParse(JSON.parse(raw));
-  if (!parsed.success || parsed.data.pinged_at === void 0) return void 0;
-  const pinged_ms = Date.parse(parsed.data.pinged_at);
-  return Number.isNaN(pinged_ms) ? void 0 : pinged_ms;
+async function main_repository_root() {
+  return repo_discovery.main_worktree(await git_command.repository_root());
 }
-function is_life_fresh(target, threshold_ms) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return false;
-  try {
-    const pinged_ms = parse_pinged_at(raw);
-    return pinged_ms !== void 0 && Date.now() - pinged_ms < threshold_ms;
-  } catch {
-    return false;
-  }
+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));
+}
+async function has_lanes_in_flight() {
+  const lanes = await list_lanes();
+  return lanes.some((lane) => !lane.is_stranded);
 }
-function is_life_ended(target) {
-  return stamp_file.read_stamp_text(target) === void 0;
+function used_seats(lanes) {
+  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
 }
-function end_life(target) {
-  stamp_file.remove_stamp(target);
+function unreadable_lanes(lanes) {
+  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
 }
-function git_directory_sync() {
-  const git_binary = git_utilities.get_git_command_for_spawn();
-  const result = execaSync(git_binary, GIT_DIRECTORY_ARGUMENTS2, {
-    reject: false,
-    timeout: GIT_TIMEOUT_MS
-  });
-  if (result.exitCode !== 0) return void 0;
-  const output = result.stdout.trim();
-  return output === "" ? void 0 : output;
-}
-function stamp_target_sync() {
-  const directory = git_directory_sync();
-  return directory === void 0 ? void 0 : stamp_target_of(directory);
-}
-function read_last_report_sync() {
-  const target = stamp_target_sync();
-  return target === void 0 ? void 0 : read_last_report(target);
-}
-var run_progress_clock = {
-  LIFE_PREFIX,
-  LOG_KEEP,
-  LOG_STALE_MS,
-  PROGRESS_PREFIX,
-  append_line,
-  begin_life,
-  end_life,
-  is_life_ended,
-  is_life_fresh,
-  life_target_of,
-  log_path_of,
-  mark,
-  parse_stamp,
-  ping_life,
-  read_last_line,
-  read_last_report,
-  read_last_report_sync,
-  stamp_target_of,
-  stamp_target_sync
+function find_lane(lanes, issue) {
+  return lanes.find((lane) => lane.issue === issue);
+}
+async function find_open_lane(issue) {
+  return find_lane(await list_lanes(), issue);
+}
+var lane_registry = {
+  find_lane,
+  find_open_lane,
+  has_lanes_in_flight,
+  list_lanes,
+  main_repository_root,
+  parse_block,
+  read_environment,
+  unreadable_lanes,
+  used_seats
 };
 
-// scripts/run/run-watcher-guard.ts
-var WATCHER_TICK_MS = 3e4;
-var TICK_MULTIPLIER = 3;
-var MS_PER_SECOND2 = 1e3;
-var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
-var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND2;
-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() {
-  const all_lanes = await lane_registry.list_lanes();
-  return all_lanes.some((lane) => !lane.is_stranded);
-}
-async function check(life_target) {
-  if (!await has_lanes_in_flight()) return OK_RESULT;
-  if (run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) return OK_RESULT;
-  return { kind: "stale", note: STALE_NOTE };
-}
-var run_watcher_guard = {
-  STALE_NOTE,
-  STALE_THRESHOLD_MS,
-  check,
-  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 lane_registry.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/git/git-gh-api-path.ts
+// 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 = {
+  citation_line,
+  citer,
+  issue_url,
+  missing_line,
+  no_repo_line,
+  parse_target,
+  unreadable_line
+};
+
+// scripts/gh/git-gh-api-path.ts
 var FULL_PAGE_QUERY = "?per_page=100";
 function repo_api_path(repo) {
   return `repos/${repo ?? "{owner}/{repo}"}`;
@@ -3431,6 +4340,36 @@ var git_gh_api_path = {
   commit_status_api_path
 };
 
+// scripts/lib/timeouts.ts
+var FETCH_TIMEOUT_MS = 1e4;
+var COMMAND_TIMEOUT_MS = 3e4;
+
+// scripts/lib/error-message.ts
+function message_of(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var error_text = { message_of };
+
+// scripts/gh/git-gh-exec.ts
+import { execa as execa5, execaSync as execaSync2 } from "execa";
+
+// scripts/gh/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"], { timeout: COMMAND_TIMEOUT_MS });
+  } 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/parse-json-array.ts
 var MALFORMED_JSON = /* @__PURE__ */ Symbol("malformed-json");
 function parse_json_loose(raw_json) {
@@ -3454,52 +4393,18 @@ function read_json_listing(raw_json, element_schema) {
     return { kind: "unexpected_shape" };
   }
 }
-function parse_json_array_safe(raw_json, element_schema) {
-  const value = parse_json_loose(raw_json);
-  if (value === MALFORMED_JSON) return [];
-  return element_schema.array().parse(value);
-}
 function parse_json_object_safe(raw_json, schema) {
   const value = parse_json_loose(raw_json);
   if (value === MALFORMED_JSON) return void 0;
   return schema.parse(value);
 }
 var parse_json = {
-  parse_json_array_safe,
-  parse_json_array_or_undefined,
-  parse_json_object_safe,
-  read_json_listing
+  parse_json_object_safe
 };
 
-// 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 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({});
+// scripts/gh/git-gh-failure.ts
+import { z as z10 } from "zod";
+var error_document_schema = z10.object({ status: z10.union([z10.string(), z10.number()]).optional() }).catch({});
 var GH_FAILURE_FIELD = "gh_failure";
 function has_gh_failure(error) {
   return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
@@ -3526,7 +4431,7 @@ function failure_of(error) {
 }
 var gh_failure = { attach, classify_stdout, failure_of, parse_response_status };
 
-// scripts/git/git-gh-exec.ts
+// scripts/gh/git-gh-exec.ts
 var BODY_FROM_STDIN = "-";
 var GH_REQUEST_TIMEOUT_MS = 6e4;
 function to_timeout_option(timeout_ms) {
@@ -3568,7 +4473,7 @@ 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_, options);
+    const { stdout } = await execa5("gh", arguments_, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -3578,7 +4483,7 @@ async function exec_gh_command_with_stdin(input) {
   await check_gh_installed();
   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);
@@ -3592,20 +4497,20 @@ function parse_status_line(output) {
 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) {
+async function exec_gh_api_status(path6, 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", path6], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
   }
 }
-function exec_gh_api_status_sync(path4, timeout_ms) {
+function exec_gh_api_status_sync(path6, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
-    const { stdout } = execaSync2("gh", ["api", "--include", "--silent", path4], options);
+    const { stdout } = execaSync2("gh", ["api", "--include", "--silent", path6], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
@@ -3677,7 +4582,9 @@ var git_gh_exec = {
 export {
   shell_segments,
   bash_triggers,
-  run_progress_clock,
+  issue_cite,
+  git_command,
+  git_common_directory,
   tail_commands,
   filing_cap,
   CONTEXT_CUT_THRESHOLD,
@@ -3685,8 +4592,6 @@ export {
   agent_session_environment,
   agent_role_profile,
   backlog_budget,
-  git_command,
-  lane_child_invocation,
   run_hold,
   run_cut,
   run_tail,
@@ -3703,21 +4608,26 @@ export {
   RELEASE_CLASSIFICATION_NAMES,
   has_any_label,
   has_label_name,
+  process_identity,
+  run_event_stream,
+  run_invocation,
+  run_carry,
+  run_event_stream_emit,
+  lane_handoff,
   lane_park,
   repo_origin,
   repo_party,
+  process_owner_schema,
+  lane_registry,
+  run_headless,
   FULL_PAGE_QUERY,
   git_gh_api_path,
   error_text,
+  FETCH_TIMEOUT_MS,
   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
 };