@joshuafolkken/kit 1.1050.0 → 1.1094.0

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

@@ -1,7 +1,7 @@
 import {
   lane_child_marker,
   run_issue_number
-} from "./chunk-WQ4OSBSS.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-7VPDUBRN.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
@@ -601,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 {
@@ -648,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 {
@@ -705,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,
@@ -715,7 +718,6 @@ var run_hold = {
   is_own_hold,
   is_tree_dirty,
   own_release_command,
-  parse_hold,
   race_message,
   read_hold,
   release_hold,
@@ -727,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 = [
@@ -774,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)]);
@@ -883,27 +882,27 @@ function trimmed(value) {
   return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
 }
 function override_value(role, field, environment2) {
-  const key = ENV_KEYS[role][field];
-  const value = trimmed(environment2[key]);
-  if (value !== void 0) return { key, value };
-  if (role !== WORKER) return { key, value: void 0 };
+  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(environment2[legacy]);
-  return legacy_value === void 0 ? { key, value: void 0 } : { key: legacy, value: legacy_value };
+  return legacy_value === void 0 ? { key: key2, value: void 0 } : { key: legacy, value: legacy_value };
 }
 function model_override(role, environment2, provider) {
-  const key = ENV_KEYS[role].model;
-  return provider === OPENAI_PROVIDER ? { key, value: void 0 } : override_value(role, "model", environment2);
+  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(environment2, keys) {
-  return keys.some((key) => trimmed(environment2[key]) !== void 0);
+  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";
@@ -976,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,
@@ -996,7 +989,6 @@ var agent_role_profile = {
   has_completion_callback,
   is_safe_value,
   parse,
-  phase_effort,
   resolve,
   resolve_provider,
   with_phase_effort
@@ -1103,7 +1095,6 @@ function decide2(input) {
 }
 var backlog_budget = {
   ANSWERS,
-  ANSWER_STOP_REASONS,
   BLOCKED_REASON,
   DEFAULT_IDLE_MINUTES,
   DEFAULT_IDLE_MS,
@@ -1118,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,
@@ -1204,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,
@@ -1243,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",
@@ -1272,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";
@@ -1292,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,
@@ -1306,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";
@@ -1384,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);
@@ -1430,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;
@@ -1467,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 };
@@ -1658,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) {
@@ -1679,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]);
@@ -1688,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",
@@ -1705,1234 +1858,1960 @@ 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 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"
+// 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 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)"
+}
+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 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"
-  },
-  {
-    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" }
-};
-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 label_name_of(labels, wanted) {
-  const target = wanted.toLowerCase();
-  return labels.find((label2) => label2.toLowerCase() === target);
+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 has_label_name(labels, wanted) {
-  return label_name_of(labels, wanted) !== void 0;
+var START_PROBES = { read_proc_start, read_ps_start };
+function safe_probe(probe, pid) {
+  try {
+    return probe(pid);
+  } catch {
+    return 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)
-  );
-}
-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 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 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 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 scan_siblings(parent) {
-  return sibling_directories(parent).map((repository_path) => ({
-    path: repository_path,
-    origin_url: read_origin_url(repository_path)
-  }));
-}
-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, environment2 = process.env) {
-  const main2 = main_worktree(repository_path);
-  const current_owner2 = resolve_current_owner(main2);
-  if (current_owner2 === void 0) return /* @__PURE__ */ new Map();
-  return repo_map_logic.build_repository_map(
-    scan_siblings(path.dirname(main2)),
-    current_owner2,
-    environment2[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-reap.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-var PGREP_COMMAND = "pgrep";
-var MATCH_FULL_COMMAND_LINE = "-f";
-var CHILDREN_OF_FLAG = "-P";
-var PS_COMMAND = "/bin/ps";
-var PARENT_FORMAT = ["-o", "ppid=", "-p"];
-var TERMINATE_SIGNAL = "SIGTERM";
-var PROBE_TIMEOUT_MS = 2e3;
-var LOWEST_CHILD_PID = 2;
-function parse_pids(printed) {
-  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
-}
-function run_probe(command, args) {
-  try {
-    return execFileSync2(command, [...args], {
-      encoding: "utf8",
-      timeout: PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-  } catch {
-    return "";
-  }
+// 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 !== "");
 }
-function parent_of(pid) {
-  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
+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 terminate(pid) {
-  try {
-    process.kill(pid, TERMINATE_SIGNAL);
-    return true;
-  } catch {
-    return false;
-  }
+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));
 }
-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 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 own_ancestry(probes = SYSTEM_PROBES) {
-  return ancestry_of(process.pid, probes);
+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 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();
+function print_decision(key2, answer, reason, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [key2]: answer, reason }));
+    return;
   }
-  return tree;
+  console.info(answer);
+  console.error(reason);
 }
-function reap_child(issue, probes = SYSTEM_PROBES) {
-  const own = own_ancestry(probes);
-  const pattern = lane_child_invocation.process_pattern(issue);
-  const roots = probes.matching(pattern).filter((pid) => !own.has(pid));
-  const doomed = tree_of(roots, probes).filter((pid) => !own.has(pid));
-  return doomed.filter((pid) => probes.terminate(pid));
+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 lane_reap = {
-  own_ancestry,
-  parse_pids,
-  reap_child
+var path_decision = {
+  format_path_list,
+  has_unknown_flag,
+  JSON_FLAG,
+  parse_options,
+  print_decision,
+  run_path_decision
 };
 
-// scripts/josh/process-identity.ts
-import { execFileSync as execFileSync3, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { readFileSync as readFileSync3, rmSync } from "node:fs";
-import { createServer } from "node:net";
-import path2 from "node:path";
-var PS_COMMAND2 = "/bin/ps";
-var FORMAT_FLAG = "-o";
-var START_TIME_FORMAT = "lstart=";
-var PID_FLAG = "-p";
-var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
-var PROBE_TIMEOUT_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;
-  }
-}
-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;
-  }
+// 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 read_ps_start(pid) {
+function parse_or_undefined(config) {
   try {
-    const printed = execFileSync3(
-      PS_COMMAND2,
-      [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;
+    return parseArgs(config);
   } catch {
     return void 0;
   }
 }
-var START_PROBES = { read_proc_start, read_ps_start };
-function safe_probe(probe, pid) {
-  try {
-    return probe(pid);
-  } 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);
+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 ensure_exit_cleanup() {
-  if (exit_cleanup.is_registered) return;
-  exit_cleanup.is_registered = true;
-  process.once("exit", close_beacons);
+function text_of(value) {
+  return typeof value === "string" ? value : void 0;
 }
-function ignore_beacon_error() {
+function to_answer(raw) {
+  return backlog_budget.ANSWERS.find((answer) => answer === raw);
 }
-function bind_beacon(target) {
-  return createServer().on("error", ignore_beacon_error).listen(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 try_bind_beacon(bind, target) {
-  try {
-    const server = bind(target);
-    return server.listening ? server : void 0;
-  } catch {
-    return 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;
 }
-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;
+function is_readable(raw, parsed) {
+  return raw === void 0 || 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();
+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_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 are_counts_readable(values, counts) {
+  return COUNT_NAMES.every((name) => is_readable(text_of(values[name]), counts[name]));
 }
-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;
+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 is_live_beacon(target) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
-    stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS2
-  }).status === 0;
+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 has_matching_start(pid, recorded_start, read2) {
-  const observed = read2(pid);
-  return observed === void 0 ? void 0 : observed === recorded_start;
+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 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 input_of(values, base) {
+  const counts = counts_of(values);
+  return {
+    ...base,
+    active_at_ms: to_time_ms(text_of(values.active)) ?? base.started_at_ms,
+    merged: counts.merged ?? 0,
+    running: counts.running ?? 0,
+    max_issues: counts.max,
+    idle_budget_ms: to_idle_ms(counts.idle)
+  };
 }
-var 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 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 own_fields() {
-  const start = own_start();
-  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
+function refuse() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE2;
 }
-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 run(argv, now_ms = Date.now()) {
+  const values = read_arguments(argv);
+  if (values === void 0) return refuse();
+  const input = build_input(values, now_ms);
+  if (input === void 0) return refuse();
+  const { verdict, reason } = backlog_budget.decide(input);
+  if (values.json === true) {
+    console.info(
+      JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: backlog_budget.is_finish(input) })
+    );
+    return SUCCESS_EXIT_CODE;
+  }
+  path_decision.print_decision(JSON_KEY, verdict, reason, false);
+  return SUCCESS_EXIT_CODE;
 }
-function is_own_process(pid, recorded_start) {
-  return pid === process.pid && recorded_start === own_start();
+function main(argv) {
+  process.exitCode = run(argv);
 }
-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
+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/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/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 next_failures(carry, change) {
-  if (has_increment(change.merged)) return NO_INCREMENT;
-  return carry.failures + (change.failures ?? NO_INCREMENT);
+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 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_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 folded_outage(carry) {
-  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
+function flag_tokens(tokens, start) {
+  const rendered = [];
+  let index = start;
+  while (index < tokens.length) {
+    const read2 = read_flag(tokens, index);
+    if (read2 === void 0) return void 0;
+    rendered.push(read2.part);
+    index += read2.advance;
+  }
+  return rendered;
 }
-function counted_outage(carry, change, now) {
-  const outages = carry.outages + (change.outages ?? NO_INCREMENT);
-  return { outages, last_outage_at: now.toISOString() };
+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 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 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 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 };
-
-// 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;
-}
-var run_carry_change = { apply_change };
-
-// scripts/backlog/backlog-budget-cli.ts
-import { fileURLToPath } from "node:url";
-
-// scripts/git/changed-paths.ts
-function to_paths(raw) {
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+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;
 }
-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 issue_token(issue) {
+  return `${ISSUE_PREFIX}${String(issue)}`;
 }
-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 joined(command, rendered) {
+  return [command, ...rendered].join(TOKEN_SEPARATOR);
 }
-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 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 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 rebuild(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  return rebuilt_backlog(tokens);
 }
-function print_decision(key, answer, reason, is_json) {
-  if (is_json) {
-    console.info(JSON.stringify({ [key]: answer, reason }));
-    return;
-  }
-  console.info(answer);
-  console.error(reason);
+function 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;
 }
-async function run_path_decision(argv, command) {
-  const options = parse_options(argv);
-  if (options === void 0) {
-    console.error(command.usage);
-    return FAILURE_EXIT_CODE;
-  }
-  const paths = await changed_paths.read_changed_paths(options.is_staged);
-  const answer = command.decide(paths);
-  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
-  return 0;
+function 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 path_decision = {
-  format_path_list,
-  has_unknown_flag,
-  JSON_FLAG,
-  KNOWN_FLAGS,
-  MAX_LISTED_PATHS,
-  parse_options,
-  print_decision,
-  run_path_decision,
-  STAGED_FLAG
+var run_invocation = {
+  has_only,
+  issue_numbers,
+  rebuild
 };
 
-// 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/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);
 }
-function parse_or_undefined(config) {
+async function repository_directory() {
+  const directories2 = await git_command.git_directories();
+  return directories2[REPOSITORY_DIRECTORY_INDEX];
+}
+function parse_carry(raw) {
   try {
-    return parseArgs(config);
+    const parsed = run_carry_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
   } catch {
     return void 0;
   }
 }
-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 text_of(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function to_answer(raw) {
-  return backlog_budget.ANSWERS.find((answer) => answer === raw);
+function is_expired2(carry, now) {
+  const started = Date.parse(carry.started_at);
+  if (Number.isNaN(started)) return true;
+  return now.getTime() - started > CARRY_MAX_AGE_MS;
 }
-function to_time_ms(raw) {
-  if (raw === void 0) return void 0;
-  const parsed = Date.parse(raw);
-  return Number.isNaN(parsed) ? void 0 : parsed;
+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 };
 }
-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 read_carry(target, now = /* @__PURE__ */ new Date()) {
+  return classify3(stamp_file.read_stamp_text(target), now);
 }
-function is_readable(raw, parsed) {
-  return raw === void 0 || parsed !== void 0;
+function owner_of(pid, read2 = process_identity.read_start) {
+  return { pid, start: read2(pid) };
 }
-var COUNT_NAMES = ["idle", "max", "merged", "running"];
-function counts_of(values) {
+function fresh_carry(invocation, owner, now) {
   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))
+    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
   };
 }
-function are_counts_readable(values, counts) {
-  return COUNT_NAMES.every((name) => is_readable(text_of(values[name]), counts[name]));
+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 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 replace_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+  stamp_file.remove_stamp(target);
+  return begin_carry(target, invocation, owner, now);
 }
-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 adopt_carry(target, carry, owner = NO_OWNER) {
+  const next = {
+    ...carry,
+    owner_pid: owner.pid,
+    owner_start: owner.start,
+    is_handed_off: false
+  };
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, next) ? next : void 0;
 }
-function 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_owner_live(carry) {
+  return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false;
 }
-function input_of(values, base) {
-  const counts = counts_of(values);
+function is_owned_by(carry, owner) {
+  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
+}
+function is_foreign_live_owner(carry, owner) {
+  return is_owner_live(carry) && !is_owned_by(carry, owner);
+}
+function is_handed_off_to(carry, invocation) {
+  return carry.is_handed_off === true && carry.invocation === invocation;
+}
+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";
+}
+function is_count_refused(carry, owner) {
+  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
+}
+function is_at_cut_cap(carry) {
+  return carry.cuts >= MAX_CUTS;
+}
+function end_carry(target) {
+  stamp_file.remove_stamp(target);
+}
+function retrospective_done_of(read2) {
+  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
+  return read2.carry.retrospective === true;
+}
+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 done_note(carry) {
+  const done = carry.done ?? [];
+  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
+}
+function describe_carry(carry) {
+  return `${carry.invocation} started ${carry.started_at}; ${String(carry.merged)} merged, ${String(carry.filed)} filed, ${String(carry.failures)} failed in a row, ${String(carry.outages)} outage(s) in a row, ${String(carry.cuts)} cut(s) crossed${done_note(carry)}`;
+}
+function expired_message(carry) {
+  return `The ${String(CARRY_MAX_AGE_HOURS)}-hour whole-run bound is spent: ${describe_carry(carry)}. Clear it with \`${END_COMMAND2}\`.`;
+}
+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 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 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 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 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 {
-    ...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)
+    cwd,
+    detached: is_detached,
+    stdio: log === void 0 ? "ignore" : ["ignore", log, log],
+    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment2 }
   };
 }
-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 refuse() {
-  console.error(USAGE);
-  return FAILURE_EXIT_CODE2;
+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 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) })
+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)
     );
-    return SUCCESS_EXIT_CODE;
+    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 ignore_spawn(_pid) {
+}
+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 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);
   }
-  path_decision.print_decision(JSON_KEY, verdict, reason, false);
-  return SUCCESS_EXIT_CODE;
 }
-function main(argv) {
-  process.exitCode = run(argv);
+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 backlog_budget_cli = {
-  JSON_KEY,
-  OPTIONS,
-  SUCCESS_EXIT_CODE,
-  USAGE,
-  build_input,
-  main,
-  read_arguments,
-  run,
-  to_answer,
-  to_count,
-  to_time_ms
+var detached_launch = {
+  UNSAFE_NOTE,
+  ensure_log,
+  is_safe_argv,
+  is_safe_value: is_safe_value2,
+  launch,
+  launch_attached,
+  log_header,
+  note_of
 };
-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/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 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 target_of(repository2) {
+  return stamp_file.stamp_path(EVENT_PREFIX, repository2, EVENT_SUFFIX);
 }
-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 is_present(event) {
+  return event !== 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;
+function parse_line(line) {
+  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+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 last_position(events) {
+  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
+}
+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 {
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
+  };
+}
+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 is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
+}
+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));
+}
+function scope_of(read2) {
+  if (read2.kind === "carried" || read2.kind === "expired") {
+    return { kind: SINCE_SCOPE, started_at: read2.carry.started_at };
   }
-  return rendered;
+  return UNKNOWN_EVENT_SCOPE;
 }
-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 last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
 }
-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);
+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 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);
+async function stream_target() {
+  const repository2 = await run_carry.repository_directory();
+  return repository2 === void 0 ? void 0 : run_event_stream.target_of(repository2);
+}
+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 {
   }
-  return issues;
 }
-function issue_token(issue) {
-  return `${ISSUE_PREFIX}${String(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;
+  }
 }
-function joined(command, rendered) {
-  return [command, ...rendered].join(TOKEN_SEPARATOR);
+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;
 }
-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]);
+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;
+  }
 }
-function rebuild(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
-  return rebuilt_backlog(tokens);
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
 }
-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;
+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/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);
+}
+function log_path(repository2, number) {
+  return stamp_file.stamp_path(`${LOG_PREFIX}${number}${KEY_SEPARATOR}`, repository2, LOG_SUFFIX);
+}
+function result_path(repository2, number) {
+  return stamp_file.stamp_path(`${RESULT_PREFIX}${number}${KEY_SEPARATOR}`, repository2);
+}
+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 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 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);
+  }
+  return process_identity.is_same_process(pid, record.process_start) !== false;
+}
+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";
+  }
+  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];
+}
+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/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 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 lane_handoff = { is_handed_off, is_ship_running };
+
+// 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" }
+};
+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 label_name_of(labels, wanted) {
+  const target = wanted.toLowerCase();
+  return labels.find((label2) => label2.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)
+  );
+}
+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 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 is_parking_child(directory = process.cwd()) {
+  return lane_child_marker.is_child_of(directory) && !lane_handoff.is_handed_off(directory);
 }
-var run_invocation = {
-  has_only,
-  issue_numbers,
-  rebuild
+function is_unparked_stop(command, is_child = is_parking_child) {
+  if (!is_confirmation_notify(command)) return false;
+  return is_child();
+}
+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);
+}
+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/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/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;
 }
-async function repository_directory() {
-  const directories = await git_command.git_directories();
-  return directories[REPOSITORY_DIRECTORY_INDEX];
+function is_github_ssh_host(host) {
+  const normalized = host.toLowerCase();
+  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
 }
-function parse_carry(raw) {
+function strip_git_suffix(name) {
+  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
+}
+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 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 parse_url_like(url) {
   try {
-    const parsed = run_carry_schema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : void 0;
+    const parsed = new URL(url);
+    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
   } 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 parse_origin_url(url) {
+  const trimmed2 = url.trim();
+  if (trimmed2 === "") return void 0;
+  return parse_url_like(trimmed2) ?? parse_scp_like(trimmed2);
 }
-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 is_section_header(line) {
+  return line.startsWith(SECTION_PREFIX);
 }
-function read_carry(target, now = /* @__PURE__ */ new Date()) {
-  return classify4(stamp_file.read_stamp_text(target), now);
+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 owner_of(pid, read2 = process_identity.read_start) {
-  return { pid, start: read2(pid) };
+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 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
-  };
+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 begin_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
-  const carry = fresh_carry(invocation, owner, now);
-  return stamp_file.create_stamp(target, carry) ? carry : void 0;
+function format_identity(identity) {
+  return `${identity.owner}${PATH_SEPARATOR2}${identity.repo}`.toLowerCase();
 }
-function replace_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
-  stamp_file.remove_stamp(target);
-  return begin_carry(target, invocation, owner, now);
+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 adopt_carry(target, carry, owner = NO_OWNER) {
-  const next = {
-    ...carry,
-    owner_pid: owner.pid,
-    owner_start: owner.start,
-    is_handed_off: false
-  };
-  stamp_file.remove_stamp(target);
-  return stamp_file.create_stamp(target, next) ? next : void 0;
+function 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 is_owner_live(carry) {
-  return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false;
+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 is_owned_by(carry, owner) {
-  return carry.owner_pid === owner.pid && carry.owner_start === owner.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_foreign_live_owner(carry, owner) {
-  return is_owner_live(carry) && !is_owned_by(carry, owner);
+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_handed_off_to(carry, invocation) {
-  return carry.is_handed_off === true && carry.invocation === invocation;
+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 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";
+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 is_count_refused(carry, owner) {
-  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
+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;
+  }
 }
-function is_at_cut_cap(carry) {
-  return carry.cuts >= MAX_CUTS;
+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 end_carry(target) {
-  stamp_file.remove_stamp(target);
+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 scan_siblings(parent) {
+  return sibling_directories(parent).map((repository_path) => ({
+    path: repository_path,
+    origin_url: read_origin_url(repository_path)
+  }));
+}
+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 retrospective_done_of(read2) {
-  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
-  return read2.carry.retrospective === true;
+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 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 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]
+  );
 }
-function done_note(carry) {
-  const done = carry.done ?? [];
-  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
+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 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 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 target_owner(owner_repo) {
+  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
 }
-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 current_owner(repository_path = process.cwd()) {
+  return repo_discovery.resolve_current_owner(repository_path);
 }
-function mismatch_message(carry, invocation) {
-  return `A different invocation is carried here \u2014 ${describe_carry(carry)}. This one is \`${invocation}\`. End the standing record with \`${END_COMMAND2}\` once you know its run is over, then begin again.`;
+var 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 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 run_probe(command, args) {
+  try {
+    return execFileSync3(command, [...args], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return "";
+  }
 }
-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 parent_of(pid) {
+  return parse_pids(run_probe(PS_COMMAND2, [...PARENT_FORMAT, String(pid)]))[0];
 }
-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.`;
+function terminate(pid) {
+  try {
+    process.kill(pid, TERMINATE_SIGNAL);
+    return true;
+  } catch {
+    return false;
   }
-  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 lost_message() {
-  return `Another process established a run record here first, so nothing was established. Read it with \`${READ_COMMAND2}\`.`;
+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 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 own_ancestry(probes = SYSTEM_PROBES) {
+  return ancestry_of(process.pid, probes);
 }
-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 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 unknown_message3() {
-  return "This repository\u2019s git directory could not be read, so no run record was established.";
+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 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_reap = {
+  own_ancestry,
+  parse_pids,
+  reap_child
 };
 
 // scripts/lane/lane-registry.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path3 from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import path5 from "node:path";
 
 // scripts/git/git-ls-remote.ts
 var LS_REMOTE_COMMAND = "ls-remote";
@@ -2944,58 +3823,23 @@ function ls_remote_branch_arguments(branch_name) {
 }
 
 // scripts/git/repository-lock.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
-import { setTimeout as sleep } from "node:timers/promises";
+import { setTimeout as sleep2 } from "node:timers/promises";
 
-// scripts/git/git-common-directory.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-var OWN_GIT_DIRECTORY = 0;
-var COMMON_GIT_DIRECTORY = 1;
-var PROBE_TIMEOUT_MS3 = 2e3;
-function read_directories(cwd) {
-  const git = git_utilities.get_git_command_for_spawn();
-  const output = execFileSync4(git, [...git_command.GIT_DIRECTORY_ARGUMENTS], {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
-    timeout: PROBE_TIMEOUT_MS3
-  });
-  return output.trim().split("\n");
-}
-function 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 resolve2(cwd) {
-  try {
-    return select_linked(read_directories(cwd));
-  } catch {
-    return void 0;
-  }
-}
-function repository(cwd) {
-  try {
-    return read_directories(cwd)[COMMON_GIT_DIRECTORY];
-  } catch {
-    return void 0;
-  }
-}
-var git_common_directory = { repository, resolve: resolve2, select_linked };
+// 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 = process.cwd()) {
-  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd);
+function lock_path(prefix, cwd) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
 }
 function parse_owner(raw) {
   if (raw === void 0) return void 0;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
 }
 function read_owner(target) {
   return parse_owner(stamp_file.read_stamp_text(target));
@@ -3015,7 +3859,7 @@ function stale_record(target, is_gone2) {
   return owner !== void 0 && is_gone2(owner) ? raw : void 0;
 }
 function move_aside(target) {
-  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
+  const aside = `${target}.${String(process.pid)}.${randomUUID3()}`;
   try {
     renameSync(target, aside);
     return aside;
@@ -3045,7 +3889,7 @@ 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);
+    await sleep2(POLL_INTERVAL_MS);
   }
   return true;
 }
@@ -3125,13 +3969,10 @@ function strip_export(line) {
   const trimmed2 = line.trimStart();
   return trimmed2.startsWith(EXPORT_PREFIX) ? trimmed2.slice(EXPORT_PREFIX.length).trimStart() : trimmed2;
 }
-function is_key_line(line, key) {
+function is_key_line(line, key2) {
   const body = strip_export(line);
-  if (!body.startsWith(key)) return false;
-  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
-}
-function is_seed_line(line) {
-  return is_key_line(line, PORT_SEED_KEY);
+  if (!body.startsWith(key2)) return false;
+  return body.slice(key2.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
 }
 function is_seat_line(line) {
   return is_key_line(line, LANE_SEAT_KEY);
@@ -3154,8 +3995,8 @@ function unquote(raw) {
 function assignment_value(line) {
   return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
 }
-function read_assignment(content, key) {
-  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
+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 read_root_seed(content) {
@@ -3188,17 +4029,17 @@ function read_lane_profile(content) {
     effort: read_assignment(content, LANE_EFFORT_KEY)
   });
 }
-function replace_assignment(lines, keep, assignment, key) {
+function replace_assignment(lines, keep, assignment, key2) {
   return lines.flatMap((entry, index) => {
     if (index === keep) return [assignment];
-    return is_key_line(entry, key) ? [] : [entry];
+    return is_key_line(entry, key2) ? [] : [entry];
   });
 }
-function upsert_assignment(content, key, value) {
-  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
+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, key));
-  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
+  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")}
 `;
 }
@@ -3214,12 +4055,7 @@ function with_lane_output(content, output, profile) {
   return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
 }
 var lane_environment = {
-  LANE_OUTPUT_KEY,
-  LANE_PROVIDER_KEY,
-  LANE_ROLE_KEY,
-  is_output_line,
   is_seat_line,
-  is_seed_line,
   lane_file_content,
   read_lane_output,
   read_lane_profile,
@@ -3253,7 +4089,7 @@ function held_seat(content) {
   return seat_from_content(content) ?? EMPTY_SEAT;
 }
 function read_environment(directory) {
-  return file_reader.read_if_readable(path3.join(directory, ENV_FILE_NAME));
+  return file_reader.read_if_readable(path5.join(directory, ENV_FILE_NAME));
 }
 function branch_issue(branch2) {
   if (!branch2?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
@@ -3261,7 +4097,7 @@ function branch_issue(branch2) {
   return ISSUE_PATTERN.test(issue) ? issue : void 0;
 }
 function is_gone(directory) {
-  return !existsSync2(directory);
+  return !existsSync3(directory);
 }
 function build_lane(issue, branch2, directory, is_stranded) {
   const content = is_stranded ? void 0 : read_environment(directory);
@@ -3308,6 +4144,10 @@ async function list_lanes() {
   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 used_seats(lanes) {
   return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
 }
@@ -3323,6 +4163,7 @@ async function find_open_lane(issue) {
 var lane_registry = {
   find_lane,
   find_open_lane,
+  has_lanes_in_flight,
   list_lanes,
   main_repository_root,
   parse_block,
@@ -3331,171 +4172,6 @@ var lane_registry = {
   used_seats
 };
 
-// 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;
-  }
-}
-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 log_path_of(target) {
-  return `${target}${LOG_SUFFIX}`;
-}
-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 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 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 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 stamp_target_of(git_directory) {
-  return stamp_file.stamp_path(PROGRESS_PREFIX, git_directory);
-}
-function life_target_of(git_directory) {
-  return stamp_file.stamp_path(LIFE_PREFIX, git_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 ping_life(target) {
-  begin_life(target);
-}
-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;
-}
-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;
-  }
-}
-function is_life_ended(target) {
-  return stamp_file.read_stamp_text(target) === void 0;
-}
-function end_life(target) {
-  stamp_file.remove_stamp(target);
-}
-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
-};
-
-// scripts/run/run-watcher-guard.ts
-var WATCHER_TICK_MS = 3e4;
-var TICK_MULTIPLIER = 3;
-var MS_PER_SECOND3 = 1e3;
-var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
-var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND3;
-var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding`;
-var OK_RESULT = { kind: "ok" };
-async function has_lanes_in_flight() {
-  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";
@@ -3514,7 +4190,7 @@ async function read_carry_here() {
 }
 async function must_keep_waiting(source = process.env) {
   const is_candidate2 = is_headless(source) && lane_child_marker.marked_issue(source) === void 0;
-  if (!is_candidate2 || !await run_watcher_guard.has_lanes_in_flight()) return false;
+  if (!is_candidate2 || !await lane_registry.has_lanes_in_flight()) return false;
   return is_driving(await read_carry_here());
 }
 async function current_carry() {
@@ -3593,18 +4269,16 @@ function no_repo_line(target) {
   return `\u2716 ${label(target)}: could not read this repository \u2014 check gh auth and the origin remote`;
 }
 var issue_cite = {
-  SUMMARY_SEPARATOR,
   citation_line,
   citer,
   issue_url,
-  label,
   missing_line,
   no_repo_line,
   parse_target,
   unreadable_line
 };
 
-// scripts/git/git-gh-api-path.ts
+// scripts/gh/git-gh-api-path.ts
 var FULL_PAGE_QUERY = "?per_page=100";
 function repo_api_path(repo) {
   return `repos/${repo ?? "{owner}/{repo}"}`;
@@ -3666,22 +4340,26 @@ 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/git/git-gh-exec.ts
+// scripts/gh/git-gh-exec.ts
 import { execa as execa5, execaSync as execaSync2 } from "execa";
 
-// scripts/git/git-gh-check.ts
+// 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"]);
+    await execa4("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
   } catch {
     delete gh_check.promise;
     throw new Error(GH_NOT_INSTALLED_MSG);
@@ -3692,9 +4370,6 @@ async function check_gh_installed() {
   await gh_check.promise;
 }
 
-// scripts/git/git-gh-failure.ts
-import { z as z7 } from "zod";
-
 // scripts/git/parse-json-array.ts
 var MALFORMED_JSON = /* @__PURE__ */ Symbol("malformed-json");
 function parse_json_loose(raw_json) {
@@ -3718,25 +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/git/git-gh-failure.ts
-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);
@@ -3763,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) {
@@ -3829,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 execa5("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);
@@ -3915,7 +4583,8 @@ export {
   shell_segments,
   bash_triggers,
   issue_cite,
-  run_progress_clock,
+  git_command,
+  git_common_directory,
   tail_commands,
   filing_cap,
   CONTEXT_CUT_THRESHOLD,
@@ -3923,7 +4592,6 @@ export {
   agent_session_environment,
   agent_role_profile,
   backlog_budget,
-  git_command,
   run_hold,
   run_cut,
   run_tail,
@@ -3940,18 +4608,22 @@ export {
   RELEASE_CLASSIFICATION_NAMES,
   has_any_label,
   has_label_name,
-  lane_park,
-  repo_origin,
-  repo_party,
   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_watcher_guard,
   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,