@joshuafolkken/kit 1.1178.0 → 1.1240.0

package/dist/hooks/{chunk-GDS5N2KB.js → chunk-KHX4U3BG.js}

@@ -1,11 +1,13 @@
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
 import {
   lane_child_marker,
   run_issue_number
-} from "./chunk-32GQTL4F.js";
+} from "./chunk-ZQGD4GBY.js";
 import {
   CHECK_STATUS_FAIL,
   CHECK_STATUS_PENDING,
-  PLATFORM_TEMP_ROOT,
   PrConflictError,
   blocking_issue_schema,
   cost_blocks,
@@ -21,19 +23,27 @@ import {
   json_value,
   lane_paths,
   parse_pr_state_snapshot,
+  process_identity,
+  process_owner_schema,
   read_string,
   rest_comment_schema,
-  stamp_file,
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-S6X6WYKR.js";
+} from "./chunk-WK2XSHSI.js";
 import {
   ENV_FILE_NAME,
   LANE_SEAT_KEY,
   PORT_SEED_KEY,
   ports
 } from "./chunk-RKUAD3I6.js";
+import {
+  COMMAND_TIMEOUT_MS,
+  GIT_TIMEOUT_MS,
+  PLATFORM_TEMP_ROOT,
+  PROBE_TIMEOUT_MS,
+  stamp_file
+} from "./chunk-ELCN5LCH.js";
 
 // scripts/lib/bounded-pool.ts
 function pool_width(limit, total) {
@@ -157,8 +167,8 @@ function current_turn(tail) {
 function turn_filing_count(tail) {
   return prior_filing_count(current_turn(tail));
 }
-function decide(_call, run3) {
-  return prior_filing_count(time_density_hook.read_tail(run3.transcript)) >= CAP_REACHED;
+function decide(_call, run4) {
+  return prior_filing_count(time_density_hook.read_tail(run4.transcript)) >= CAP_REACHED;
 }
 var FILING_CAP_REASON = `\u26D4 filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling \u2014 on reaching it, stop and report rather than filing more. Automatic filing is capped so a run cannot manufacture Issues faster than they can be closed (\`.claude/skills/workflow-commands/SKILL.md\` \u2192 \`prerequisite.md\`, \`observation-filing.md\`). A further Issue that genuinely must exist is a person's call, not this run's. **This rule fires on every filing past the cap, not once per run**, so reissuing the same filing will be refused again.`;
 var ROW = {
@@ -183,17 +193,13 @@ var PORCELAIN_FLAG = "--porcelain";
 var UNTRACKED_FILES_FLAG = "--untracked-files=all";
 var GIT_BINARY_KEY = "JOSH_GIT_BINARY";
 function get_git_command() {
-  if (platform() === "win32") {
-    return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
-  }
+  if (platform() === "win32") return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
   return GIT_COMMAND_UNIX;
 }
 function get_git_command_for_spawn() {
   const binary = process.env[GIT_BINARY_KEY];
   if (binary !== void 0 && binary !== "") return binary;
-  if (platform() === "win32") {
-    return String.raw`C:\Program Files\Git\cmd\git.exe`;
-  }
+  if (platform() === "win32") return String.raw`C:\Program Files\Git\cmd\git.exe`;
   return GIT_COMMAND_UNIX;
 }
 var git_utilities = {
@@ -201,6 +207,9 @@ var git_utilities = {
   get_git_command_for_spawn
 };
 
+// scripts/git/git-spawn.ts
+import { execa as execa3 } from "execa";
+
 // scripts/git/git-execa-error.ts
 function get_exit_code(error) {
   if (typeof error !== "object" || error === null) return void 0;
@@ -300,7 +309,6 @@ var git_push_transport = {
 };
 
 // scripts/git/git-spawn.ts
-import { execa as execa3 } from "execa";
 async function read(arguments_) {
   const git_cmd = git_utilities.get_git_command_for_spawn();
   const { stdout } = await execa3(git_cmd, arguments_);
@@ -352,73 +360,7 @@ var git_spawn = {
   with_output_remote
 };
 
-// scripts/lib/spawn-exit.ts
-function read_spawn_stdout(result) {
-  return result.stdout ?? "";
-}
-function read_spawn_stderr(result) {
-  return result.stderr ?? "";
-}
-
-// scripts/git/git-spawn-sync.ts
-import { execaSync } from "execa";
-var GIT_TIMEOUT_MS = 1e4;
-var SUCCESS_EXIT_CODE = 0;
-var C_LOCALE = { LC_ALL: "C", LANGUAGE: "C" };
-function run(args, options = {}) {
-  const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
-    ...options,
-    extendEnv: true,
-    reject: false,
-    timeout: options.timeout ?? GIT_TIMEOUT_MS
-  });
-  return {
-    exit_code: result.exitCode,
-    stdout: read_spawn_stdout(result),
-    stderr: read_spawn_stderr(result)
-  };
-}
-function read2(args, options = {}) {
-  const result = run(args, options);
-  return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
-}
-function origin_url(cwd) {
-  return read2(["config", "--get", "remote.origin.url"], { cwd });
-}
-function toplevel(timeout = GIT_TIMEOUT_MS) {
-  return run(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
-}
-var git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run, read: read2, origin_url, toplevel };
-
-// scripts/git/git-command.ts
-async function branch() {
-  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
-}
-async function status(directory) {
-  const location = directory === void 0 ? [] : ["-C", directory];
-  return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
-}
-async function repository_root() {
-  const result = git_spawn_sync.toplevel();
-  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
-  return result.stdout.trim();
-}
-async function head_commit() {
-  return await git_spawn.read(["rev-parse", "HEAD"]);
-}
-var GIT_DIRECTORY_ARGUMENTS = [
-  "rev-parse",
-  "--absolute-git-dir",
-  "--path-format=absolute",
-  "--git-common-dir"
-];
-async function git_directories() {
-  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
-  return output.split("\n").filter((line) => line !== "");
-}
-async function diff_cached(file_path) {
-  return await git_spawn.read(["diff", "--cached", file_path]);
-}
+// scripts/git/git-diff-reads.ts
 var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
 var NAME_ONLY_FLAG = "--name-only";
 var DEFAULT_BRANCH_FALLBACK = "main";
@@ -507,6 +449,164 @@ async function untracked_names() {
     WHOLE_TREE_PATHSPEC
   ]);
 }
+var git_diff_reads = {
+  change_base,
+  change_base_commit,
+  default_branch_reference,
+  diff_cached_names,
+  diff_main,
+  diff_main_names,
+  diff_main_numstat,
+  get_default_branch,
+  untracked_names
+};
+
+// scripts/git/git-pre-push-hook.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+var REMOTE = "origin";
+var HOOK_NAME = "pre-push";
+var PROBE_HOOK_NAME = "kit-hook-run-probe";
+var ALLOW_UNKNOWN_HOOK_NAME_FLAG = "--allow-unknown-hook-name";
+var HOOK_RUN = "run";
+var STDIN_FILE = "refs";
+var TEMPORARY_PREFIX = "kit-pre-push-";
+var ZERO_DIGIT = "0";
+async function read_remote_oid(branch2) {
+  try {
+    return await git_spawn.read([
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `refs/remotes/${REMOTE}/${branch2}`
+    ]);
+  } catch {
+    return void 0;
+  }
+}
+async function read_push_references() {
+  const [branch2, local_oid] = await Promise.all([
+    git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]),
+    git_spawn.read(["rev-parse", "HEAD"])
+  ]);
+  return { branch: branch2, local_oid, remote_oid: await read_remote_oid(branch2) };
+}
+function to_stdin_line(references) {
+  const reference2 = `refs/heads/${references.branch}`;
+  const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
+  return `${reference2} ${references.local_oid} ${reference2} ${remote_oid}
+`;
+}
+function to_hook_run_arguments(stdin_path, hook_name) {
+  return [HOOK_RUN, "--ignore-missing", `--to-stdin=${stdin_path}`, hook_name];
+}
+async function can_probe(probe_arguments) {
+  try {
+    await git_spawn.read(["hook", ...probe_arguments]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function can_run_hooks(stdin_path) {
+  const [, ...options] = to_hook_run_arguments(stdin_path, PROBE_HOOK_NAME);
+  if (await can_probe([HOOK_RUN, ALLOW_UNKNOWN_HOOK_NAME_FLAG, ...options])) return true;
+  return await can_probe([HOOK_RUN, ...options]);
+}
+async function run_with_stdin(stdin_line) {
+  const directory = await mkdtemp(path.join(tmpdir(), TEMPORARY_PREFIX));
+  const stdin_path = path.join(directory, STDIN_FILE);
+  try {
+    await writeFile(stdin_path, stdin_line);
+    if (!await can_run_hooks(stdin_path)) return false;
+    const url = await git_spawn.read(["remote", "get-url", REMOTE]);
+    await git_spawn.with_output("hook", [
+      ...to_hook_run_arguments(stdin_path, HOOK_NAME),
+      "--",
+      REMOTE,
+      url
+    ]);
+    return true;
+  } finally {
+    await rm(directory, { force: true, recursive: true });
+  }
+}
+async function run() {
+  const references = await read_push_references();
+  if (references.local_oid === references.remote_oid) return true;
+  return await run_with_stdin(to_stdin_line(references));
+}
+var git_pre_push_hook = {
+  run
+};
+
+// scripts/lib/spawn-exit.ts
+function read_spawn_stdout(result) {
+  return result.stdout ?? "";
+}
+function read_spawn_stderr(result) {
+  return result.stderr ?? "";
+}
+
+// scripts/git/git-spawn-sync.ts
+import { execaSync } from "execa";
+var SUCCESS_EXIT_CODE = 0;
+var C_LOCALE = { LC_ALL: "C", LANGUAGE: "C" };
+function run2(args, options = {}) {
+  const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
+    ...options,
+    extendEnv: true,
+    reject: false,
+    timeout: options.timeout ?? GIT_TIMEOUT_MS
+  });
+  return {
+    exit_code: result.exitCode,
+    stdout: read_spawn_stdout(result),
+    stderr: read_spawn_stderr(result)
+  };
+}
+function read2(args, options = {}) {
+  const result = run2(args, options);
+  return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
+}
+function origin_url(cwd) {
+  return read2(["config", "--get", "remote.origin.url"], { cwd });
+}
+function toplevel(timeout = GIT_TIMEOUT_MS) {
+  return run2(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
+}
+var git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run: run2, read: read2, origin_url, toplevel };
+
+// scripts/git/git-command.ts
+async function branch() {
+  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+async function status(directory) {
+  const location = directory === void 0 ? [] : ["-C", directory];
+  return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
+}
+async function repository_root() {
+  const result = git_spawn_sync.toplevel();
+  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
+  return result.stdout.trim();
+}
+async function head_commit() {
+  return await git_spawn.read(["rev-parse", "HEAD"]);
+}
+var GIT_DIRECTORY_ARGUMENTS = [
+  "rev-parse",
+  "--absolute-git-dir",
+  "--path-format=absolute",
+  "--git-common-dir"
+];
+async function git_directories() {
+  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
+  return output.split("\n").filter((line) => line !== "");
+}
+async function diff_cached(file_path) {
+  return await git_spawn.read(["diff", "--cached", file_path]);
+}
 async function fetch_branch(branch_name) {
   const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
   return await git_spawn.read(["fetch", "origin", refspec]);
@@ -548,16 +648,18 @@ function is_upstream_not_set_error(error) {
   const { cause } = error;
   return cause !== void 0 && is_exit_code_128(cause);
 }
-async function push_with_upstream(branch_name) {
-  await git_push_transport.push(["--set-upstream", "origin", branch_name]);
+var NO_VERIFY_FLAG = "--no-verify";
+async function push_with_upstream(branch_name, verify_flags) {
+  await git_push_transport.push([...verify_flags, "--set-upstream", "origin", branch_name]);
 }
 async function push2() {
+  const verify_flags = await git_pre_push_hook.run() ? [NO_VERIFY_FLAG] : [];
   try {
-    await git_push_transport.push([]);
+    await git_push_transport.push([...verify_flags]);
   } catch (error) {
     if (is_upstream_not_set_error(error)) {
       const current_branch = await branch();
-      await push_with_upstream(current_branch);
+      await push_with_upstream(current_branch, verify_flags);
       return;
     }
     throw error;
@@ -642,15 +744,9 @@ var git_command = {
   head_commit,
   git_directories,
   diff_cached,
-  diff_cached_names,
-  diff_main,
-  change_base,
-  change_base_commit,
-  diff_main_names,
-  diff_main_numstat,
-  untracked_names,
-  get_default_branch,
-  default_branch_reference,
+  // The default branch, the change base and every reading against it are `git-diff-reads.ts`'s
+  // (joshuafolkken/kit#3264), re-exported here so no call site, mock or spy moved with them.
+  ...git_diff_reads,
   fetch_branch,
   merge_fast_forward,
   fast_forward_local,
@@ -674,19 +770,7 @@ var git_command = {
   is_upstream_not_set_error
 };
 
-// scripts/lib/error-message.ts
-function message_of(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-var DEBUG_ENV_KEY = "JOSH_DEBUG";
-function trace_swallowed(where, error) {
-  if ((process.env[DEBUG_ENV_KEY] ?? "").trim() === "") return;
-  process.stderr.write(`josh debug: ${where}: ${message_of(error)}
-`);
-}
-var error_text = { message_of, trace_swallowed };
-
-// scripts/run/run-hold.ts
+// scripts/run/hold/run-hold.ts
 import { z } from "zod";
 var HOLD_PREFIX = "josh-run-hold-";
 var UNNUMBERED_ISSUE = "new";
@@ -986,18 +1070,18 @@ function trimmed(value) {
   const result = value?.trim();
   return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
 }
-function override_value(role, field, environment2) {
+function override_value(role, field, environment3) {
   const key2 = ENV_KEYS[role][field];
-  const value = trimmed(environment2[key2]);
+  const value = trimmed(environment3[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]);
+  const legacy_value = trimmed(environment3[legacy]);
   return legacy_value === void 0 ? { key: key2, value: void 0 } : { key: legacy, value: legacy_value };
 }
-function model_override(role, environment2, provider) {
+function model_override(role, environment3, provider) {
   const key2 = ENV_KEYS[role].model;
-  return provider === OPENAI_PROVIDER ? { key: key2, value: void 0 } : override_value(role, "model", environment2);
+  return provider === OPENAI_PROVIDER ? { key: key2, value: void 0 } : override_value(role, "model", environment3);
 }
 function rejection(key2, value, expected) {
   return { kind: "rejected", note: `${key2}=${value} ${expected}, so the agent was not started` };
@@ -1006,35 +1090,35 @@ function resolved_effort(override, fallback) {
   const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback);
   return parsed.success ? { kind: "effort", effort: parsed.data } : rejection(override.key, override.value ?? "", "is not an allowed effort");
 }
-function has_session(environment2, keys) {
-  return keys.some((key2) => trimmed(environment2[key2]) !== void 0);
+function has_session(environment3, keys) {
+  return keys.some((key2) => trimmed(environment3[key2]) !== void 0);
 }
 function session_rejection(is_conflicting) {
   const note = is_conflicting ? "both Codex and Claude Code sessions were detected" : "no Codex or Claude Code session was detected";
   return { kind: "rejected", note };
 }
 var HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
-function handed_provider(environment2) {
-  const value = trimmed(environment2[HANDED_PROVIDER_KEY]);
+function handed_provider(environment3) {
+  const value = trimmed(environment3[HANDED_PROVIDER_KEY]);
   if (value === void 0) return session_rejection(false);
   const parsed = PROVIDER_SCHEMA.safeParse(value);
   return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value, "is not an allowed provider");
 }
-function detected_provider(environment2) {
-  const has_codex = has_session(environment2, [CODEX_SESSION_KEY]);
-  const has_claude = has_session(environment2, agent_session_environment.PARENT_SESSION_KEYS);
+function detected_provider(environment3) {
+  const has_codex = has_session(environment3, [CODEX_SESSION_KEY]);
+  const has_claude = has_session(environment3, agent_session_environment.PARENT_SESSION_KEYS);
   if (has_codex === has_claude) return has_codex ? session_rejection(true) : void 0;
   return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
 }
-function resolve_provider(environment2 = process.env) {
-  return detected_provider(environment2) ?? handed_provider(environment2);
+function resolve_provider(environment3 = process.env) {
+  return detected_provider(environment3) ?? handed_provider(environment3);
 }
-function has_completion_callback(environment2 = process.env) {
-  const selected = resolve_provider(environment2);
+function has_completion_callback(environment3 = process.env) {
+  const selected = resolve_provider(environment3);
   return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
 }
-function handoff_environment(environment2 = process.env) {
-  const selected = resolve_provider(environment2);
+function handoff_environment(environment3 = process.env) {
+  const selected = resolve_provider(environment3);
   return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
 }
 function validate(profile, model_key) {
@@ -1048,19 +1132,19 @@ function phase_effort(role, phase, fallback) {
   if (!parsed.success) return fallback;
   return PHASE_EFFORT[role]?.[parsed.data] ?? fallback;
 }
-function overridden_effort(profile, phase, environment2) {
-  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment2).value);
+function overridden_effort(profile, phase, environment3) {
+  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment3).value);
   return parsed.success ? parsed.data : phase_effort(profile.role, phase, profile.effort);
 }
-function with_phase_effort(profile, phase, environment2 = process.env) {
-  return { ...profile, effort: overridden_effort(profile, phase, environment2) };
+function with_phase_effort(profile, phase, environment3 = process.env) {
+  return { ...profile, effort: overridden_effort(profile, phase, environment3) };
 }
-function resolve(role, environment2 = process.env, phase) {
-  const selected = resolve_provider(environment2);
+function resolve(role, environment3 = process.env, phase) {
+  const selected = resolve_provider(environment3);
   if (selected.kind === "rejected") return selected;
   const defaults = PROVIDER_PROFILES[selected.provider][role];
-  const model = model_override(role, environment2, selected.provider);
-  const effort = override_value(role, "effort", environment2);
+  const model = model_override(role, environment3, selected.provider);
+  const effort = override_value(role, "effort", environment3);
   const resolved = resolved_effort(effort, phase_effort(role, phase, defaults.effort));
   if (resolved.kind === "rejected") return resolved;
   const profile = {
@@ -1371,7 +1455,7 @@ var git_location_environment = { clear_git_location_variables, location_free_env
 // scripts/git/git-common-directory.ts
 var OWN_GIT_DIRECTORY = 0;
 var COMMON_GIT_DIRECTORY = 1;
-var PROBE_TIMEOUT_MS = 5e3;
+var PROBE_TIMEOUT_MS2 = 5e3;
 var answers = /* @__PURE__ */ new Map();
 function probe_environment(cwd) {
   if (cwd === void 0) return process.env;
@@ -1392,7 +1476,7 @@ function read_directories(cwd) {
         env: probe_environment(cwd),
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
-        timeout: PROBE_TIMEOUT_MS
+        timeout: PROBE_TIMEOUT_MS2
       }
     );
     return output.split("\n").filter((line) => line !== "");
@@ -1424,7 +1508,7 @@ function resolve2(cwd) {
 }
 var git_common_directory = { directories, own, repository, resolve: resolve2, select_linked };
 
-// scripts/run/run-ship-stage.ts
+// scripts/run/ship/run-ship-stage.ts
 import { z as z3 } from "zod";
 var STAGE = {
   PREFLIGHT: "preflight",
@@ -1520,7 +1604,7 @@ var run_ship_stage = {
   stop_reason: stop_reason2
 };
 
-// scripts/run/run-ship-next.ts
+// scripts/run/ship/run-ship-next.ts
 var { STAGE: STAGE2 } = run_ship_stage;
 var COMMAND = {
   LOG: "pnpm josh ship --log",
@@ -1607,10 +1691,10 @@ var lane_child_invocation = {
   ship_stop_invocation
 };
 
-// scripts/run/run-cut.ts
+// scripts/run/cut/run-cut.ts
 import { z as z5 } from "zod";
 
-// scripts/run/run-cut-handoff.ts
+// scripts/run/cut/run-cut-handoff.ts
 import { readFileSync } from "node:fs";
 import { z as z4 } from "zod";
 var handoff_schema = z4.object({
@@ -1689,7 +1773,7 @@ var run_cut_handoff = {
   read_handoff_file
 };
 
-// scripts/run/run-cut.ts
+// scripts/run/cut/run-cut.ts
 var CUT_PREFIX = "josh-run-cut-";
 var { PRE_GATE_PHASE: PRE_GATE_PHASE2, IMPLEMENTATION_PHASE: IMPLEMENTATION_PHASE2 } = agent_role_profile;
 var IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD;
@@ -1888,7 +1972,7 @@ var run_cut = {
   worktree_git_directory_sync
 };
 
-// scripts/rules/run-tail.ts
+// scripts/rules/run-tail-rule.ts
 var SEGMENT_PREFIX = String.raw`(?:\(\s*)?(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:npx\s+|pnpm\s+(?:exec\s+|run\s+)?)?`;
 var WORD_END = String.raw`(?=\s|$|\))`;
 var PUSH_STEP_SEGMENT = new RegExp(String.raw`^${SEGMENT_PREFIX}josh\s+(?:git|g)${WORD_END}`, "u");
@@ -1928,7 +2012,7 @@ function decide3() {
   return true;
 }
 var RUN_TAIL_REASON = '\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set. In `fullrun #1501` this call was given a 900-second timeout, the harness detached it at its own 600-second cap, and nothing read the output for a further 6m28s \u2014 45m03s of wall clock on about 17 minutes of work (joshuafolkken/kit#1510). **Never give a foreground call a timeout above the harness cap**: the cap decides, not the number. A backgrounded call re-invokes you when it exits, so the completion notification is what resumes the run. **When it arrives, the turn that reads it goes straight through any branch-2 filing and `pnpm josh epic:bundle` to `pnpm josh followup` \u2014 the turn never ends at the push.** CI went green 6m06s before the merge started in that run, and it started only because the person asked; joshuafolkken/kit#1333 had already settled that the merge is issued in the turn the review closes. While the push runs, do the work that writes nothing \u2014 drafting the completion body to a file, deciding the branch-2 disposition. `pnpm josh followup` itself stays in the **foreground** \u2014 nearly every step after it reads its result. But a tail does follow the merge, measured at 3.0 min and 5.9% of a run (joshuafolkken/kit#1462), so empty it beforehand: the steps that read the merge result stay after `followup`, and the rest are composed in the turn that issues it, bar the one exception background-commands.md names. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every foreground push, not once per run**, so reissuing the same call in the foreground will be refused again.';
-var run_tail = {
+var run_tail_rule = {
   RUN_TAIL_REASON,
   decide: decide3,
   is_backgrounded_push_step,
@@ -1965,7 +2049,7 @@ function is_backgrounded_ship(call) {
   return command !== void 0 && ships_alone(command);
 }
 function is_candidate(call) {
-  if (run_tail.is_push_step_call(call)) return true;
+  if (run_tail_rule.is_push_step_call(call)) return true;
   const command = backgrounded_bash_command(call);
   if (command === void 0 || is_backgrounded_ship(call)) return false;
   return long_commands_of(command).length > 0;
@@ -1984,347 +2068,44 @@ function unfinished_ids(tail, launched_ids) {
   const finished = new Set(lines.map((line) => line?.finished_background ?? ""));
   const blocks = lines.flatMap((line) => line?.blocks ?? []);
   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]);
-}
-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` / `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; a backgrounded `ship` issued alone is moved to the foreground for you, joshuafolkken/kit#3154) \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",
-  is_trigger: (call) => is_background_long_run(call),
-  reason: LANE_BACKGROUND_REASON,
-  decide: () => true
-};
-var lane_background = {
-  FOREGROUND_NOTE,
-  LANE_BACKGROUND_REASON,
-  LANE_BACKGROUND_STOP_REASON,
-  ROW: ROW2,
-  foreground_input,
-  is_background_long_run,
-  pending_agent_ids,
-  pending_background_ids
-};
-
-// 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;
-  }
-}
-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;
-  }
-}
-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;
-  }
-}
-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);
-}
-function ensure_exit_cleanup() {
-  if (exit_cleanup.is_registered) return;
-  exit_cleanup.is_registered = true;
-  process.once("exit", close_beacons);
-}
-function ignore_beacon_error() {
-}
-function bind_beacon(target) {
-  return createServer().on("error", ignore_beacon_error).listen(target);
-}
-function try_bind_beacon(bind, target) {
-  try {
-    const server = bind(target);
-    return server.listening ? server : void 0;
-  } catch {
-    return void 0;
-  }
-}
-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 resolve_own_start(probes = START_PROBES, platform2 = process.platform) {
-  const start = read_start(process.pid, probes);
-  if (start !== void 0 || platform2 === WINDOWS_PLATFORM) return start;
-  return open_beacon();
-}
-function is_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 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 is_live_beacon(target) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
-    stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS2
-  }).status === 0;
-}
-function has_matching_start(pid, recorded_start, read3) {
-  const observed = read3(pid);
-  return observed === void 0 ? void 0 : observed === recorded_start;
-}
-function matches_recorded_start(pid, recorded_start, read3) {
-  const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read3) : is_live_beacon(target);
-}
-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 own_fields() {
-  const start = own_start();
-  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
-}
-function is_same_process(pid, recorded_start, read3 = 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, read3);
-}
-function is_own_process(pid, recorded_start) {
-  return pid === process.pid && recorded_start === own_start();
-}
-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/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 next_failures(carry, change) {
-  if (has_increment(change.merged)) return NO_INCREMENT;
-  return carry.failures + (change.failures ?? NO_INCREMENT);
-}
-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 folded_outage(carry) {
-  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
-}
-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 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 = { 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/run/run-carry-conversation.ts
-import { existsSync, statSync } from "node:fs";
-import path2 from "node:path";
-
-// scripts/cost-runtime/own-session.ts
-var NOT_FOUND = -1;
-function session_id_of(environment2) {
-  const value = environment2[agent_session_environment.SESSION_ID_KEY];
-  return value === void 0 || value === "" ? void 0 : value;
-}
-function select_own_session(files, environment2) {
-  const session_id = session_id_of(environment2);
-  if (session_id === void 0) {
-    return { kind: "own", index: cost_transcript.latest_own_index(files) };
-  }
-  const index = files.findIndex((file) => file.session_id === session_id);
-  return index === NOT_FOUND ? { kind: "absent", session_id } : { kind: "own", index };
-}
-var own_session = {
-  session_id_of,
-  select_own_session
-};
-
-// scripts/run/run-carry-conversation.ts
-var CONVERSATION_QUIET_MS = 6e5;
-function own_transcript(environment2 = process.env, directories2 = cost_transcript.transcript_directories(process.cwd())) {
-  const session_id = own_session.session_id_of(environment2);
-  if (session_id === void 0) return void 0;
-  const name = `${session_id}${cost_transcript.TRANSCRIPT_EXTENSION}`;
-  return directories2.map((directory) => path2.join(directory, name)).find((file) => existsSync(file));
-}
-function modified_ms(transcript) {
-  try {
-    return statSync(transcript).mtimeMs;
-  } catch {
-    return void 0;
-  }
-}
-function is_recent(modified, now) {
-  return modified !== void 0 && now.getTime() - modified <= CONVERSATION_QUIET_MS;
-}
-function is_conversation_live(carry, now = /* @__PURE__ */ new Date(), read_modified = modified_ms) {
-  if (carry.is_handed_off === true || carry.owner_transcript === void 0) return false;
-  return is_recent(read_modified(carry.owner_transcript), now);
+  return launched2.filter((id) => id !== "" && !finished.has(id));
 }
-function is_same_conversation(carry, owner) {
-  return owner.transcript !== void 0 && owner.transcript === carry.owner_transcript;
+function pending_background_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.background_id, block.agent_id]);
 }
-function reclaim_owner(carry, owner) {
-  if (carry.is_handed_off === true || !is_same_conversation(carry, owner)) return carry;
-  if (owner.pid === carry.owner_pid) return carry;
-  return { ...carry, owner_pid: owner.pid, owner_start: owner.start };
+function pending_agent_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.agent_id]);
 }
-var run_carry_conversation = {
-  CONVERSATION_QUIET_MS,
-  own_transcript,
-  is_conversation_live,
-  is_same_conversation,
-  reclaim_owner
+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; a backgrounded `ship` issued alone is moved to the foreground for you, joshuafolkken/kit#3154) \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",
+  is_trigger: (call) => is_background_long_run(call),
+  reason: LANE_BACKGROUND_REASON,
+  decide: () => true
+};
+var lane_background = {
+  FOREGROUND_NOTE,
+  LANE_BACKGROUND_REASON,
+  LANE_BACKGROUND_STOP_REASON,
+  ROW: ROW2,
+  foreground_input,
+  is_background_long_run,
+  pending_agent_ids,
+  pending_background_ids
 };
 
+// scripts/agent/agent-headless.ts
+var KEY = "JOSH_AGENT_HEADLESS";
+var VALUE = "1";
+function environment() {
+  return { [KEY]: VALUE };
+}
+function is_headless(source = process.env) {
+  return source[KEY] === VALUE;
+}
+var agent_headless = { KEY, environment, is_headless };
+
 // scripts/backlog/backlog-budget-cli.ts
 import { fileURLToPath } from "node:url";
 
@@ -2411,7 +2192,50 @@ function arguments_of(argv, options) {
 function string_of(value) {
   return typeof value === "string" ? value : void 0;
 }
-var cli_flags = { refuse_unknown_flags, parse_or_undefined, values_of, arguments_of, string_of };
+var LONG_FLAG_PREFIX = "--";
+var SHORT_FLAG_PREFIX = "-";
+function option_name(flag) {
+  return flag.slice(LONG_FLAG_PREFIX.length);
+}
+function is_unusable_value(value) {
+  if (typeof value === "boolean" || value.length === 0) return true;
+  return value !== SHORT_FLAG_PREFIX && value.startsWith(SHORT_FLAG_PREFIX);
+}
+function given_values(argv, flag) {
+  const name = option_name(flag);
+  const given = parse_or_undefined({
+    args: [...argv],
+    options: { [name]: { type: "string", multiple: true } },
+    strict: false,
+    allowPositionals: true
+  })?.values[name];
+  return Array.isArray(given) ? given : [];
+}
+function is_value_unusable(argv, flag) {
+  return given_values(argv, flag).some((value) => is_unusable_value(value));
+}
+function attach_one(attached, argument, flags) {
+  const previous = attached.at(-1);
+  if (previous !== void 0 && flags.includes(previous)) {
+    attached[attached.length - 1] = `${previous}=${argument}`;
+  } else attached.push(argument);
+}
+function attach_values(argv, flags) {
+  const attached = [];
+  for (const argument of argv) attach_one(attached, argument, flags);
+  return attached;
+}
+var cli_flags = {
+  attach_values,
+  refuse_unknown_flags,
+  parse_or_undefined,
+  values_of,
+  arguments_of,
+  string_of,
+  option_name,
+  given_values,
+  is_value_unusable
+};
 
 // scripts/backlog/backlog-budget-cli.ts
 var ARGV_OFFSET = 2;
@@ -2500,7 +2324,7 @@ function refuse() {
   console.error(USAGE);
   return FAILURE_EXIT_CODE2;
 }
-function run2(argv, now_ms = Date.now()) {
+function run3(argv, now_ms = Date.now()) {
   const values = read_arguments(argv);
   if (values === void 0) return refuse();
   const input = build_input(values, now_ms);
@@ -2516,7 +2340,7 @@ function run2(argv, now_ms = Date.now()) {
   return SUCCESS_EXIT_CODE2;
 }
 function main(argv) {
-  process.exitCode = run2(argv);
+  process.exitCode = run3(argv);
 }
 var backlog_budget_cli = {
   JSON_KEY,
@@ -2526,7 +2350,7 @@ var backlog_budget_cli = {
   build_input,
   main,
   read_arguments,
-  run: run2,
+  run: run3,
   to_answer,
   to_count,
   to_time_ms
@@ -2537,38 +2361,34 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(
 var BACKLOG_COMMAND = "backlogrun";
 var KNOWN_FLAGS2 = ["--max", "--idle"];
 var ONLY_FLAG = "--only";
+var OPTIONS2 = {
+  max: { type: "string" },
+  idle: { type: "string" },
+  only: { type: "boolean" }
+};
 var ISSUE_PREFIX = "#";
+var FLAG_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;
+var NOT_FOUND = -1;
 function tokens_of(invocation) {
   return invocation.split(TOKEN_SEPARATOR).filter((token) => token.length > EMPTY_LENGTH2);
 }
-function flag_token(token, raw) {
-  const flag = KNOWN_FLAGS2.find((known) => known === token);
-  const value = backlog_budget_cli.to_count(raw);
+function render_option(token) {
+  if (token.name === cli_flags.option_name(ONLY_FLAG)) return ONLY_FLAG;
+  const flag = KNOWN_FLAGS2.find((known) => cli_flags.option_name(known) === token.name);
+  const value = backlog_budget_cli.to_count(token.value);
   if (flag === void 0 || value === void 0) return void 0;
   return `${flag} ${String(value)}`;
 }
-function read_flag(tokens, index) {
-  const token = tokens[index] ?? "";
-  if (token === ONLY_FLAG) return { part: ONLY_FLAG, advance: ONLY_STEP };
-  const part = flag_token(token, tokens[index + VALUE_OFFSET]);
-  return part === void 0 ? void 0 : { part, advance: FLAG_PAIR_LENGTH };
-}
-function flag_tokens(tokens, start) {
+function rendered_options(tokens) {
   const rendered = [];
-  let index = start;
-  while (index < tokens.length) {
-    const read3 = read_flag(tokens, index);
-    if (read3 === void 0) return void 0;
-    rendered.push(read3.part);
-    index += read3.advance;
+  for (const token of tokens) {
+    const part = render_option(token);
+    if (part === void 0) return void 0;
+    rendered.push(part);
   }
   return rendered;
 }
@@ -2579,49 +2399,59 @@ function issue_of(token) {
   const issue = Number(digits);
   return Number.isSafeInteger(issue) ? issue : void 0;
 }
-function take_leading_prefixed(args) {
-  const stop = args.findIndex((token) => !token.startsWith(ISSUE_PREFIX));
-  return args.slice(FIRST_TOKEN, stop === NOT_FOUND2 ? args.length : stop);
-}
-function leading_issues(tokens) {
+function issues_of(tokens) {
   const issues = [];
-  const prefixed = take_leading_prefixed(tokens.slice(FIRST_ARGUMENT_INDEX));
-  for (const token of prefixed) {
-    const issue = issue_of(token);
+  for (const token of tokens) {
+    const issue = issue_of(token.value ?? "");
     if (issue === void 0) return void 0;
     issues.push(issue);
   }
   return issues;
 }
+function argument_tokens(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  return cli_flags.parse_or_undefined({
+    args: tokens.slice(FIRST_ARGUMENT_INDEX),
+    options: OPTIONS2,
+    allowPositionals: true,
+    tokens: true
+  })?.tokens;
+}
+function parse2(invocation) {
+  const tokens = argument_tokens(invocation);
+  if (tokens === void 0) return void 0;
+  const stop = tokens.findIndex((token) => token.kind !== "positional");
+  const split_at = stop === NOT_FOUND ? tokens.length : stop;
+  const issues = issues_of(tokens.slice(FIRST_TOKEN, split_at));
+  const flags = rendered_options(tokens.slice(split_at));
+  if (issues === void 0 || flags === void 0) return void 0;
+  return { issues, flags };
+}
 function issue_token(issue) {
   return `${ISSUE_PREFIX}${String(issue)}`;
 }
 function joined(command, rendered) {
   return [command, ...rendered].join(TOKEN_SEPARATOR);
 }
-function rebuilt_backlog(tokens) {
-  const issues = leading_issues(tokens);
-  if (issues === void 0) return void 0;
-  const flags = flag_tokens(tokens, FIRST_ARGUMENT_INDEX + issues.length);
-  if (flags === void 0) return void 0;
-  return joined(BACKLOG_COMMAND, [...issues.map((issue) => issue_token(issue)), ...flags]);
-}
 function rebuild(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
-  return rebuilt_backlog(tokens);
+  const parsed = parse2(invocation);
+  if (parsed === void 0) return void 0;
+  return joined(BACKLOG_COMMAND, [
+    ...parsed.issues.map((issue) => issue_token(issue)),
+    ...parsed.flags
+  ]);
 }
 function issue_numbers(invocation) {
   const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
-  const issues = leading_issues(tokens);
+  const stop = tokens.findIndex((token) => token.startsWith(FLAG_PREFIX));
+  const leading = stop === NOT_FOUND ? tokens : tokens.slice(FIRST_TOKEN, stop);
+  const issues = parse2(leading.join(TOKEN_SEPARATOR))?.issues;
   if (issues === void 0 || issues.length === EMPTY_LENGTH2) return void 0;
   return issues;
 }
 function has_only(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return false;
-  return tokens.slice(FIRST_ARGUMENT_INDEX).includes(ONLY_FLAG);
+  return parse2(invocation)?.flags.includes(ONLY_FLAG) === true;
 }
 var run_invocation = {
   has_only,
@@ -2629,7 +2459,164 @@ var run_invocation = {
   rebuild
 };
 
-// scripts/run/run-carry.ts
+// scripts/run/carry/run-carry.ts
+import { z as z6 } from "zod";
+
+// scripts/run/carry/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 next_failures(carry, change) {
+  if (has_increment(change.merged)) return NO_INCREMENT;
+  return carry.failures + (change.failures ?? NO_INCREMENT);
+}
+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 folded_outage(carry) {
+  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
+}
+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 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 = { next_state };
+
+// scripts/run/carry/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;
+  const current = carry.merged_issues ?? [];
+  return current.includes(issue) ? current : [...current, issue];
+}
+function is_duplicate_merge(carry, change) {
+  const issue = change.merged_issue;
+  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
+}
+function has_other_change(change) {
+  const amounts = [change.filed, change.cuts, change.failures, change.outages];
+  const has_amount = amounts.some((amount) => (amount ?? NO_INCREMENT2) > NO_INCREMENT2);
+  return has_amount || change.done !== void 0 || change.retrospective === true;
+}
+function effective_change(carry, change) {
+  if (!is_duplicate_merge(carry, change)) return change;
+  return has_other_change(change) ? { ...change, merged: NO_INCREMENT2 } : void 0;
+}
+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()) {
+  const effective = effective_change(carry, change);
+  if (effective === void 0) return carry;
+  const streak = run_carry_streak.next_state(carry, effective, now);
+  const next = {
+    ...carry,
+    ...next_counts(carry, effective),
+    merged_issues: next_merged_issues(carry, effective.merged_issue),
+    failures: streak.failures,
+    outages: streak.outages,
+    last_outage_at: streak.last_outage_at,
+    done: next_done(carry, effective.done),
+    retrospective: effective.retrospective === true || carry.retrospective
+  };
+  stamp_file.write_stamp(target, next);
+  return next;
+}
+var run_carry_change = { apply_change };
+
+// scripts/run/carry/run-carry-conversation.ts
+import { existsSync, statSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/cost-runtime/own-session.ts
+var NOT_FOUND2 = -1;
+function session_id_of(environment3) {
+  const value = environment3[agent_session_environment.SESSION_ID_KEY];
+  return value === void 0 || value === "" ? void 0 : value;
+}
+function select_own_session(files, environment3) {
+  const session_id = session_id_of(environment3);
+  if (session_id === void 0) {
+    return { kind: "own", index: cost_transcript.latest_own_index(files) };
+  }
+  const index = files.findIndex((file) => file.session_id === session_id);
+  return index === NOT_FOUND2 ? { kind: "absent", session_id } : { kind: "own", index };
+}
+var own_session = {
+  session_id_of,
+  select_own_session
+};
+
+// scripts/run/carry/run-carry-conversation.ts
+var CONVERSATION_QUIET_MS = 6e5;
+function own_transcript(environment3 = process.env, directories2 = cost_transcript.transcript_directories(process.cwd())) {
+  const session_id = own_session.session_id_of(environment3);
+  if (session_id === void 0) return void 0;
+  const name = `${session_id}${cost_transcript.TRANSCRIPT_EXTENSION}`;
+  return directories2.map((directory) => path2.join(directory, name)).find((file) => existsSync(file));
+}
+function modified_ms(transcript) {
+  try {
+    return statSync(transcript).mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+function is_recent(modified, now) {
+  return modified !== void 0 && now.getTime() - modified <= CONVERSATION_QUIET_MS;
+}
+function is_conversation_live(carry, now = /* @__PURE__ */ new Date(), read_modified = modified_ms) {
+  if (carry.is_handed_off === true || carry.owner_transcript === void 0) return false;
+  return is_recent(read_modified(carry.owner_transcript), now);
+}
+function is_same_conversation(carry, owner) {
+  return owner.transcript !== void 0 && owner.transcript === carry.owner_transcript;
+}
+function reclaim_owner(carry, owner) {
+  if (carry.is_handed_off === true || !is_same_conversation(carry, owner)) return carry;
+  if (owner.pid === carry.owner_pid) return carry;
+  return { ...carry, owner_pid: owner.pid, owner_start: owner.start };
+}
+var run_carry_conversation = {
+  CONVERSATION_QUIET_MS,
+  own_transcript,
+  is_conversation_live,
+  is_same_conversation,
+  reclaim_owner
+};
+
+// scripts/run/carry/run-carry.ts
 var CARRY_PREFIX = "josh-run-carry-";
 var REPOSITORY_DIRECTORY_INDEX = 1;
 var CARRY_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
@@ -2852,10 +2839,9 @@ var run_carry = {
   unreadable_message: unreadable_message3
 };
 
-// scripts/run/run-ship-detach.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+// scripts/run/ship/run-ship-detach.ts
+import { randomUUID } 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";
@@ -2909,17 +2895,19 @@ function link_home_file(source_home, target_home, name) {
   const target = path4.join(target_home, name);
   if (!remove_old_home_link(source, target) && existsSync2(source)) symlinkSync(source, target);
 }
-function reviewer_home(cwd, environment2) {
-  const source = environment2["CODEX_HOME"] ?? process.env["CODEX_HOME"] ?? codex_home_source.default_home();
+function reviewer_home(cwd, environment3) {
+  const source = environment3["CODEX_HOME"] ?? process.env["CODEX_HOME"] ?? codex_home_source.default_home();
   const target = path4.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;
+function build(cwd, profile, environment3 = {}) {
+  if (profile === void 0) return environment3;
+  const marked = { ...agent_headless.environment(), ...environment3 };
+  if (profile.provider !== OPENAI_PROVIDER2) return marked;
+  const base = { ...openai_environment(), ...marked };
+  return profile.role === agent_role_profile.REVIEWER ? { ...base, CODEX_HOME: reviewer_home(cwd, environment3) } : base;
 }
 var agent_launch_environment = { build };
 
@@ -2977,12 +2965,12 @@ 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) {
+function spawn_options(cwd, log, environment3 = {}, is_detached = true) {
   return {
     cwd,
     detached: is_detached,
     stdio: log === void 0 ? "ignore" : ["ignore", log, log],
-    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment2 }
+    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment3 }
   };
 }
 function notify_spawn(pid, on_spawn, on_error) {
@@ -2995,11 +2983,11 @@ function notify_spawn(pid, on_spawn, on_error) {
 }
 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 environment3 = 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)
+      spawn_options(request.cwd, log, environment3, false)
     );
     child.once("error", (error) => {
       on_error(note_of(error));
@@ -3015,8 +3003,8 @@ 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));
+  const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
+  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment3));
   child.on("error", (error) => {
     on_error(note_of(error));
   });
@@ -3058,7 +3046,7 @@ var detached_launch = {
   note_of
 };
 
-// scripts/run/run-event-stream.ts
+// scripts/run/event/run-event-stream.ts
 import { z as z7 } from "zod";
 var EVENT_PREFIX = "josh-run-events-";
 var EVENT_SUFFIX = ".jsonl";
@@ -3074,6 +3062,10 @@ var EVENT_KIND = {
   SPLIT: "split",
   OUTAGE: "outage",
   CUT: "cut",
+  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`
+  // (joshuafolkken/kit#3375). The resume clears the cut record, so without this the `cut` stayed the
+  // newest position and `run:step` kept answering the resume command it had just run.
+  RESUME: "resume",
   // 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
@@ -3150,6 +3142,12 @@ function read_events(target) {
 function last_position(events) {
   return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
 }
+function bounded(events) {
+  const excess = events.length - EVENT_CAP;
+  if (excess <= 0) return events;
+  const dropped = new Set(events.filter((event) => TRACE_KINDS.has(event.kind)).slice(0, excess));
+  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
+}
 function serialize(events) {
   return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
 }
@@ -3157,8 +3155,8 @@ 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));
+  const events = bounded([...existing, { pos: position, at, kind, text }]);
+  stamp_file.write_text_stamp(target, serialize(events));
   return { appended: true, position };
 }
 function read_from(target, position) {
@@ -3193,7 +3191,7 @@ var run_event_stream = {
   target_of
 };
 
-// scripts/run/run-event-scope.ts
+// scripts/run/event/run-event-scope.ts
 var SINCE_SCOPE = "since";
 var UNKNOWN_SCOPE = "unknown";
 var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
@@ -3271,7 +3269,7 @@ var run_event_scope = {
   scoped_events
 };
 
-// scripts/run/run-event-stream-emit.ts
+// scripts/run/event/run-event-stream-emit.ts
 function now_iso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -3340,7 +3338,8 @@ var run_event_stream_emit = {
   stream_target
 };
 
-// scripts/run/run-ship-detach.ts
+// scripts/run/ship/run-ship-detach.ts
+import { z as z8 } from "zod";
 var LOG_PREFIX = "josh-ship-log-";
 var PID_PREFIX = "josh-ship-pid-";
 var BODY_PREFIX = "josh-ship-notify-";
@@ -3491,7 +3490,7 @@ function supervisor_argv(request) {
   };
 }
 function prepare_launch(request) {
-  const launch_id = randomUUID2();
+  const launch_id = randomUUID();
   const launcher = process_identity.own_fields();
   stamp_file.replace_stamp(result_path(request.repository, request.number), {
     launch_id,
@@ -3590,6 +3589,7 @@ 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 RELEASE_LABEL = "release";
 var INTERRUPT_ROUTE_LABEL = "route:interrupt";
 var REVIEW_CAP_ROUTE_LABEL = "route:review-cap";
 var SPLIT_ROUTE_LABEL = "route:split";
@@ -3663,6 +3663,11 @@ var WORKFLOW_LABELS = [
     color: "e99695",
     description: "Offered first in a backlogrun; only a person removes it"
   },
+  {
+    name: RELEASE_LABEL,
+    color: "fef2c0",
+    description: "Tracks the next release; its blockers are the merged work it publishes"
+  },
   ...FILING_ROUTE_LABELS,
   ...DEPTH_LABELS
 ];
@@ -3728,9 +3733,16 @@ 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 ROW3 = {
+  id: "lane-park",
+  is_trigger: bash_triggers.on_bash_command(is_unparked_stop),
+  reason: LANE_PARK_REASON,
+  keeps: bash_triggers.on_bash_command(records_the_park)
+};
 var lane_park = {
   COMMAND_NOTIFY_MARKER,
   LANE_PARK_REASON,
+  ROW: ROW3,
   is_confirmation_notify,
   is_parking_child,
   is_unparked_stop,
@@ -3739,7 +3751,7 @@ var lane_park = {
 };
 
 // scripts/discovery/repo-discovery.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import path5 from "node:path";
 
 // scripts/discovery/repo-origin.ts
@@ -3805,15 +3817,15 @@ function origin_section_lines(lines) {
   const end = rest.findIndex((line) => is_section_header(line));
   return end === NOT_FOUND3 ? rest : rest.slice(0, end);
 }
-function entry_value(line, key2) {
+function url_value(line) {
   const separator = line.indexOf("=");
   if (separator === NOT_FOUND3) return void 0;
-  if (line.slice(0, separator).trim() !== key2) return void 0;
+  if (line.slice(0, separator).trim() !== URL_KEY) return void 0;
   return line.slice(separator + 1).trim();
 }
 function parse_origin_from_config(content) {
   const lines = content.split("\n").map((line) => line.trim());
-  return origin_section_lines(lines).map((line) => entry_value(line, URL_KEY)).find((url) => url !== void 0);
+  return origin_section_lines(lines).map((line) => url_value(line)).find((url) => url !== void 0);
 }
 function section_groups(lines) {
   const groups = [];
@@ -3825,7 +3837,7 @@ function section_groups(lines) {
 }
 function parse_remote_urls_from_config(content) {
   const lines = content.split("\n").map((line) => line.trim());
-  return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line) => entry_value(line, URL_KEY))).filter((url) => url !== void 0);
+  return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line) => url_value(line))).filter((url) => url !== void 0);
 }
 function format_identity(identity) {
   return `${identity.owner}${PATH_SEPARATOR2}${identity.repo}`.toLowerCase();
@@ -3890,13 +3902,13 @@ function resolve_common_directory(git_directory) {
   const pointer = path5.join(git_directory, COMMON_DIRECTORY_FILE);
   if (!existsSync3(pointer)) return git_directory;
   try {
-    return path5.resolve(git_directory, readFileSync3(pointer, "utf8").trim());
+    return path5.resolve(git_directory, readFileSync2(pointer, "utf8").trim());
   } catch {
     return git_directory;
   }
 }
 function follow_git_file(repository_path, git_file) {
-  const pointer = readFileSync3(git_file, "utf8").trim();
+  const pointer = readFileSync2(git_file, "utf8").trim();
   if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
   return path5.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
 }
@@ -3915,7 +3927,7 @@ function read_config(repository_path) {
   const git_directory = resolve_git_directory(repository_path);
   if (git_directory === void 0) return void 0;
   try {
-    return readFileSync3(path5.join(git_directory, GIT_CONFIG), "utf8");
+    return readFileSync2(path5.join(git_directory, GIT_CONFIG), "utf8");
   } catch {
     return void 0;
   }
@@ -3952,14 +3964,14 @@ function main_worktree(repository_path) {
   if (path5.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
   return path5.dirname(git_directory);
 }
-function discover_repositories(repository_path, environment2 = process.env) {
+function discover_repositories(repository_path, environment3 = 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(path5.dirname(main2)),
     current_owner2,
-    environment2[OVERRIDE_ENV_KEY]
+    environment3[OVERRIDE_ENV_KEY]
   );
 }
 var repo_discovery = {
@@ -3994,8 +4006,8 @@ function gh_repo_owners(gh_repo) {
 function remote_owners(repository_path) {
   return repo_discovery.read_remote_urls(repository_path).map((url) => repo_origin.parse_origin_url(url)?.owner);
 }
-function placeholder_owners(repository_path = process.cwd(), environment2 = process.env) {
-  const gh_repo = environment2[GH_REPO_ENV_KEY];
+function placeholder_owners(repository_path = process.cwd(), environment3 = process.env) {
+  const gh_repo = environment3[GH_REPO_ENV_KEY];
   return gh_repo === void 0 || gh_repo === "" ? remote_owners(repository_path) : gh_repo_owners(gh_repo);
 }
 var repo_party = {
@@ -4009,23 +4021,22 @@ var repo_party = {
 };
 
 // scripts/lane/lane-reap.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+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_COMMAND2 = "/bin/ps";
+var PS_COMMAND = "/bin/ps";
 var PARENT_FORMAT = ["-o", "ppid=", "-p"];
 var TERMINATE_SIGNAL = "SIGTERM";
-var PROBE_TIMEOUT_MS3 = 2e3;
 var LOWEST_CHILD_PID = 2;
 function parse_pids(printed) {
   return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
 }
 function run_probe(command, args) {
   try {
-    return execFileSync3(command, [...args], {
+    return execFileSync2(command, [...args], {
       encoding: "utf8",
-      timeout: PROBE_TIMEOUT_MS3,
+      timeout: PROBE_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     });
   } catch {
@@ -4033,7 +4044,7 @@ function run_probe(command, args) {
   }
 }
 function parent_of(pid) {
-  return parse_pids(run_probe(PS_COMMAND2, [...PARENT_FORMAT, String(pid)]))[0];
+  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
 }
 function terminate(pid) {
   try {
@@ -4101,15 +4112,9 @@ function ls_remote_branch_arguments(branch_name) {
 }
 
 // scripts/git/repository-lock.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { linkSync, renameSync, rmSync } from "node:fs";
 import { setTimeout as sleep2 } from "node:timers/promises";
-
-// scripts/josh/process-owner.ts
-import { z as z9 } from "zod";
-var process_owner_schema = z9.object({ pid: z9.number(), process_start: z9.string().optional() });
-
-// scripts/git/repository-lock.ts
 var POLL_INTERVAL_MS = 200;
 function lock_path(prefix, cwd) {
   return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
@@ -4137,7 +4142,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)}.${randomUUID3()}`;
+  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
   try {
     renameSync(target, aside);
     return aside;
@@ -4151,7 +4156,7 @@ function clear_stale(target, is_gone2 = is_owner_gone) {
   const aside = move_aside(target);
   if (aside === void 0) return;
   if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
-  rmSync2(aside, { force: true });
+  rmSync(aside, { force: true });
 }
 function claim(target) {
   clear_stale(target);
@@ -4285,13 +4290,13 @@ function read_lane_seat(content) {
   return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
 }
 function read_lane_ports(content) {
-  const environment2 = {
+  const environment3 = {
     [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
     [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
   };
   return {
-    development: ports.resolve_development_port(environment2),
-    preview: ports.resolve_preview_port(environment2)
+    development: ports.resolve_development_port(environment3),
+    preview: ports.resolve_preview_port(environment3)
   };
 }
 function read_lane_output(content) {
@@ -4310,7 +4315,8 @@ function read_lane_profile(content) {
 function replace_assignment(lines, keep, assignment, key2) {
   return lines.flatMap((entry, index) => {
     if (index === keep) return [assignment];
-    return is_key_line(entry, key2) ? [] : [entry];
+    if (is_key_line(entry, key2)) return [];
+    return [entry];
   });
 }
 function upsert_assignment(content, key2, value) {
@@ -4422,6 +4428,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 registered_directories() {
+  const blocks = await worktree_blocks();
+  return blocks.flatMap((block) => line_value(block.split("\n"), WORKTREE_PREFIX) ?? []);
+}
 async function has_lanes_in_flight() {
   const lanes = await list_lanes();
   return lanes.some((lane) => !lane.is_stranded);
@@ -4446,6 +4456,7 @@ var lane_registry = {
   main_repository_root,
   parse_block,
   read_environment,
+  registered_directories,
   unreadable_lanes,
   used_seats
 };
@@ -4453,10 +4464,10 @@ var lane_registry = {
 // scripts/run/run-headless.ts
 var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
 var HEADLESS_VALUE = "1";
-function environment() {
+function environment2() {
   return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
 }
-function is_headless(source = process.env) {
+function is_headless2(source = process.env) {
   return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
 }
 function is_driving(read3) {
@@ -4467,7 +4478,7 @@ async function read_carry_here() {
   return repository2 === void 0 ? void 0 : run_carry.read_carry(run_carry.carry_path(repository2));
 }
 async function must_keep_waiting(source = process.env) {
-  const is_candidate2 = is_headless(source) && lane_child_marker.marked_issue(source) === void 0;
+  const is_candidate2 = is_headless2(source) && lane_child_marker.marked_issue(source) === void 0;
   if (!is_candidate2 || !await lane_registry.has_lanes_in_flight()) return false;
   return is_driving(await read_carry_here());
 }
@@ -4493,9 +4504,9 @@ var run_headless = {
   HEADLESS_ENV_KEY,
   current_carry,
   driving_carry,
-  environment,
+  environment: environment2,
   is_backlog_parent,
-  is_headless,
+  is_headless: is_headless2,
   is_owned_here,
   must_keep_waiting
 };
@@ -4561,8 +4572,8 @@ var issue_cite = {
 
 // scripts/gh/git-gh-api-path.ts
 var FULL_PAGE_QUERY = "?per_page=100";
-function repo_api_path(repo) {
-  return `repos/${repo ?? "{owner}/{repo}"}`;
+function repo_api_path(repo = "{owner}/{repo}") {
+  return `repos/${repo}`;
 }
 function issues_api_path(repo) {
   return `${repo_api_path(repo)}/issues`;
@@ -4628,10 +4639,6 @@ var git_gh_api_path = {
 // scripts/gh/git-gh-exec.ts
 import { execa as execa5, execaSync as execaSync3 } from "execa";
 
-// scripts/lib/timeouts.ts
-var FETCH_TIMEOUT_MS = 1e4;
-var COMMAND_TIMEOUT_MS = 3e4;
-
 // 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/";
@@ -4682,8 +4689,8 @@ var parse_json = {
 };
 
 // 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({});
+import { z as z9 } from "zod";
+var error_document_schema = z9.object({ status: z9.union([z9.string(), z9.number()]).optional() }).catch({});
 var GH_FAILURE_FIELD = "gh_failure";
 function has_gh_failure(error) {
   return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
@@ -4886,7 +4893,7 @@ var git_gh_helpers = {
 };
 
 // scripts/gh/git-gh-issue-rest.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 
 // scripts/gh/git-gh-rest-state.ts
 var MERGED_STATE = "MERGED";
@@ -4895,11 +4902,11 @@ function to_gh_state(state) {
 }
 
 // scripts/gh/git-gh-issue-rest.ts
-var rest_issue_schema = z11.looseObject({
-  number: z11.number(),
-  issue_dependencies_summary: z11.looseObject({ total_blocked_by: z11.number().optional() }).nullish(),
+var rest_issue_schema = z10.looseObject({
+  number: z10.number(),
+  issue_dependencies_summary: z10.looseObject({ total_blocked_by: z10.number().optional() }).nullish(),
   // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z11.looseObject({ merged_at: z11.string().nullish() }).nullish()
+  pull_request: z10.looseObject({ merged_at: z10.string().nullish() }).nullish()
 });
 var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
 var REPOSITORY_URL_GROUP = 1;
@@ -4951,8 +4958,8 @@ function parse_rest_issues(rest_json) {
 function empty_blocked_by() {
   return { nodes: [], totalCount: 0 };
 }
-function repo_of_url(repository_url) {
-  const match = REPOSITORY_URL.exec(repository_url ?? "");
+function repo_of_url(repository_url = "") {
+  const match = REPOSITORY_URL.exec(repository_url);
   return match?.[REPOSITORY_URL_GROUP];
 }
 function to_blocked_by(blockers_json, exact_total) {
@@ -5246,6 +5253,7 @@ var PATCH_METHOD = "PATCH";
 var DELETE_METHOD = "DELETE";
 var HTML_URL_FILTER = ".html_url";
 var ID_FILTER = ".id";
+var LABEL_NAMES_FILTER = ".[].name";
 var LABELS_SEGMENT = "/labels";
 var COMMENTS_SEGMENT = "/comments";
 var CLOSED_STATE = "closed";
@@ -5320,13 +5328,35 @@ async function issue_create_with_label(input) {
     issue_create_request({ title: input.title, body: input.body, labels: [input.label] })
   );
 }
-async function issue_add_label(issue_number, label2) {
-  return await did_write_succeed(
-    async () => await git_gh_exec.exec_gh_api({
+async function read_label_names(issue_number) {
+  try {
+    const raw = await git_gh_exec.exec_gh_api({
       path: `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`,
-      body: JSON.stringify({ labels: [label2] })
-    })
-  );
+      should_paginate: true,
+      jq_filter: LABEL_NAMES_FILTER
+    });
+    return raw.split("\n").map((name) => name.trim());
+  } catch (error) {
+    error_text.trace_swallowed("git_gh_issue_write.read_label_names", error);
+    return void 0;
+  }
+}
+async function issue_apply_label(issue_number, label2) {
+  const labels_path = `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`;
+  try {
+    await git_gh_exec.exec_gh_api({ path: labels_path, body: JSON.stringify({ labels: [label2] }) });
+    return { is_applied: true };
+  } catch (error) {
+    const names = await read_label_names(issue_number);
+    if (names?.includes(label2) === true) return { is_applied: true };
+    error_text.trace_swallowed("git_gh_issue_write.issue_apply_label", error);
+    const [gist = ""] = error_text.message_of(error).split("\n", 1);
+    return { is_applied: false, reason: gist };
+  }
+}
+async function issue_add_label(issue_number, label2) {
+  const write = await issue_apply_label(issue_number, label2);
+  return write.is_applied;
 }
 async function issue_remove_label(issue_number, label2) {
   const labels_path = `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`;
@@ -5373,6 +5403,7 @@ var git_gh_issue_write = {
   label_ensure,
   issue_create_request,
   issue_create_with_label,
+  issue_apply_label,
   issue_add_label,
   issue_remove_label,
   issue_add_blocked_by,
@@ -5433,20 +5464,20 @@ var git_gh_issue = {
 };
 
 // scripts/ci/pr-classification.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 var CLASSIFICATION_SET = new Set(RELEASE_CLASSIFICATION_NAMES);
 var ISSUE_BUG_LABEL = "bug";
 var DECLARATION_PREFIX = "- \u30EA\u30EA\u30FC\u30B9\u5206\u985E: ";
 var DECLARATION = new RegExp(`^${DECLARATION_PREFIX}(.+)$`, "gmu");
 var LEGACY_LABELS = /* @__PURE__ */ new Set(["semver-major", "semver-minor"]);
-var LABEL = z12.object({ name: z12.string() });
-var USER = z12.object({ login: z12.string() });
-var PULL_REQUEST = z12.object({ number: z12.number(), user: USER });
-var EVENT = z12.object({
+var LABEL = z11.object({ name: z11.string() });
+var USER = z11.object({ login: z11.string() });
+var PULL_REQUEST = z11.object({ number: z11.number(), user: USER });
+var EVENT = z11.object({
   pull_request: PULL_REQUEST,
-  repository: z12.object({ full_name: z12.string() })
+  repository: z11.object({ full_name: z11.string() })
 });
 function classification_error(labels, author) {
   const legacy = labels.filter((label2) => LEGACY_LABELS.has(label2.toLowerCase()));
@@ -5469,7 +5500,7 @@ function release_candidates(candidates) {
   return candidates.filter((candidate) => candidate !== ENHANCEMENT_LABEL);
 }
 function issue_candidates(issue_json) {
-  const issue = z12.object({ labels: z12.array(LABEL), body: z12.string().nullable() }).parse(JSON.parse(issue_json));
+  const issue = z11.object({ labels: z11.array(LABEL), body: z11.string().nullable() }).parse(JSON.parse(issue_json));
   const names = issue.labels.map((label2) => label2.name.toLowerCase());
   const declared = [...(issue.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
   const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
@@ -5502,7 +5533,7 @@ function fetch_current_labels(repository2, pull_number) {
   }
 }
 function check_event(event_path, read_labels = fetch_current_labels) {
-  const event = EVENT.parse(JSON.parse(readFileSync4(event_path, "utf8")));
+  const event = EVENT.parse(JSON.parse(readFileSync3(event_path, "utf8")));
   const labels = read_labels(event.repository.full_name, event.pull_request.number);
   return classification_error(labels, event.pull_request.user.login);
 }
@@ -5544,31 +5575,31 @@ async function poll_until(is_done2, options) {
 var poll = { poll_until, sleep: sleep3 };
 
 // scripts/gh/git-gh-pr.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 
 // scripts/gh/git-gh-pr-rest.ts
-import { z as z13 } from "zod";
-var rest_repo_schema = z13.looseObject({ full_name: z13.string().optional() }).nullish();
-var rest_pull_side_schema = z13.looseObject({ repo: rest_repo_schema });
-var rest_pull_schema = z13.looseObject({
-  number: z13.number(),
-  html_url: z13.string().optional(),
-  body: z13.string().nullish(),
-  state: z13.string().optional(),
-  merged: z13.boolean().nullish(),
-  merged_at: z13.string().nullish(),
-  mergeable: z13.boolean().nullish(),
-  mergeable_state: z13.string().optional(),
+import { z as z12 } from "zod";
+var rest_repo_schema = z12.looseObject({ full_name: z12.string().optional() }).nullish();
+var rest_pull_side_schema = z12.looseObject({ repo: rest_repo_schema });
+var rest_pull_schema = z12.looseObject({
+  number: z12.number(),
+  html_url: z12.string().optional(),
+  body: z12.string().nullish(),
+  state: z12.string().optional(),
+  merged: z12.boolean().nullish(),
+  merged_at: z12.string().nullish(),
+  mergeable: z12.boolean().nullish(),
+  mergeable_state: z12.string().optional(),
   // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
   // REST hangs the check runs and the status contexts off the commit rather than off the pull
   // request (joshuafolkken/kit#1028).
-  head: z13.looseObject({ ref: z13.string().optional(), sha: z13.string().optional(), repo: rest_repo_schema }).nullish(),
+  head: z12.looseObject({ ref: z12.string().optional(), sha: z12.string().optional(), repo: rest_repo_schema }).nullish(),
   base: rest_pull_side_schema.nullish(),
   // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
   // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`
   // (joshuafolkken/kit#2497).
-  node_id: z13.string().optional(),
-  auto_merge: z13.looseObject({}).nullish()
+  node_id: z12.string().optional(),
+  auto_merge: z12.looseObject({}).nullish()
 });
 var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
 var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
@@ -5644,6 +5675,7 @@ async function fetch_pr_number(branch_name) {
   return git_gh_pr_rest.select_pull(git_gh_pr_rest.parse_rest_pulls(json))?.number;
 }
 var pending_pr_number_by_branch = /* @__PURE__ */ new Map();
+var pull_by_number = /* @__PURE__ */ new Map();
 async function fetch_pr_number_read(branch_name) {
   try {
     const pr_number = await fetch_pr_number(branch_name);
@@ -5668,6 +5700,7 @@ async function start_pr_number_read(branch_name) {
 function forget_pr_numbers() {
   pr_number_by_branch.clear();
   pending_pr_number_by_branch.clear();
+  pull_by_number.clear();
 }
 async function read_pr_number(branch_name) {
   const cached = pr_number_by_branch.get(branch_name);
@@ -5693,15 +5726,29 @@ async function read_pull(pr_number) {
   });
   return git_gh_pr_rest.parse_rest_pull(json);
 }
-async function read_pull_of_branch(branch_name) {
-  const pr_number = await resolve_pr_number(branch_name);
-  if (pr_number === void 0) return void 0;
+async function read_remembered_pull(pr_number) {
+  const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number);
+  pull_by_number.set(pr_number, pending);
   try {
-    return await read_pull(pr_number);
-  } catch {
-    return void 0;
+    return await pending;
+  } catch (error) {
+    if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number);
+    throw error;
+  }
+}
+async function read_pull_of_branch(branch_name, read3 = read_remembered_pull) {
+  const number_read = await read_pr_number(branch_name);
+  if (number_read.kind !== "read") return number_read;
+  try {
+    return { kind: "read", pull: await read3(number_read.pr_number) };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
   }
 }
+async function read_pull_or_undefined(branch_name) {
+  const read3 = await read_pull_of_branch(branch_name);
+  return read3.kind === "read" ? read3.pull : void 0;
+}
 async function pr_exists(branch_name) {
   const read3 = await read_pr_number(branch_name);
   if (read3.kind === "unreadable") throw to_unreadable_error(branch_name, read3.cause);
@@ -5711,13 +5758,14 @@ async function pr_get_number(branch_name) {
   return await resolve_pr_number(branch_name);
 }
 async function pr_get_url(branch_name) {
-  const pull = await read_pull_of_branch(branch_name);
+  const pull = await read_pull_or_undefined(branch_name);
   if (pull?.html_url === void 0) return void 0;
   return git_gh_helpers.parse_pr_state_string(pull.html_url);
 }
 async function pr_get_merge_state(branch_name) {
-  const pull = await read_pull_of_branch(branch_name);
-  if (pull === void 0) return void 0;
+  const read3 = await read_pull_of_branch(branch_name, read_pull);
+  if (read3.kind !== "read") return void 0;
+  const { pull } = read3;
   return {
     is_merged: git_gh_pr_rest.is_merged(pull),
     merged_at: pull.merged_at ?? void 0,
@@ -5726,14 +5774,15 @@ async function pr_get_merge_state(branch_name) {
   };
 }
 async function pr_get_body(branch_name) {
-  const pull = await read_pull_of_branch(branch_name);
+  const pull = await read_pull_or_undefined(branch_name);
   const body = pull?.body;
   return typeof body === "string" && body.length > 0 ? body : void 0;
 }
 async function pr_view(branch_name) {
-  const pull = await read_pull_of_branch(branch_name);
-  if (pull === void 0) return "";
-  return JSON.stringify(git_gh_pr_rest.to_pr_info(pull));
+  const read3 = await read_pull_of_branch(branch_name, read_pull);
+  if (read3.kind === "unreadable") throw to_unreadable_error(branch_name, read3.cause);
+  if (read3.kind === "missing") return "";
+  return JSON.stringify(git_gh_pr_rest.to_pr_info(read3.pull));
 }
 async function read_comments(branch_name, to_path, to_json) {
   const pr_number = await resolve_pr_number(branch_name);
@@ -5769,14 +5818,14 @@ var git_gh_pr_read = {
 };
 
 // scripts/gh/git-gh-pr-review.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 var REVIEW_APPROVED = "APPROVED";
 var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
 var REVIEW_NONE = "";
 var STATE_CHANGING_REVIEWS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
-var rest_review_schema = z14.looseObject({
-  state: z14.string().optional(),
-  user: z14.looseObject({ login: z14.string().optional() }).nullish()
+var rest_review_schema = z13.looseObject({
+  state: z13.string().optional(),
+  user: z13.looseObject({ login: z13.string().optional() }).nullish()
 });
 var NOT_A_REVIEW_LISTING = "gh api answered something other than a review listing";
 function parse_rest_reviews(reviews_json) {
@@ -5809,18 +5858,18 @@ function to_review_decision(reviews_json) {
 var git_gh_pr_review = { to_review_decision };
 
 // scripts/gh/git-gh-pr-rollup.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
 var TYPE_NAME_KEY = "__typename";
-var rollup_element_schema = z15.looseObject({});
-var check_runs_page_schema = z15.looseObject({
+var rollup_element_schema = z14.looseObject({});
+var check_runs_page_schema = z14.looseObject({
   // Required, not optional: GitHub always names the key, and accepting a page without one would
   // answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
-  check_runs: z15.array(rollup_element_schema)
+  check_runs: z14.array(rollup_element_schema)
 });
-var id_holder_schema = z15.object({ id: z15.number() });
-var status_page_schema = z15.looseObject({
-  statuses: z15.array(rollup_element_schema)
+var id_holder_schema = z14.object({ id: z14.number() });
+var status_page_schema = z14.looseObject({
+  statuses: z14.array(rollup_element_schema)
 });
 var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
 var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
@@ -5834,15 +5883,15 @@ function read_id(value) {
   const parsed = id_holder_schema.safeParse(value);
   return parsed.success ? parsed.data.id : void 0;
 }
-function check_run_group_key(run3) {
-  const { name, app } = run3;
+function check_run_group_key(run4) {
+  const { name, app } = run4;
   if (typeof name !== "string") return void 0;
   return JSON.stringify([name, read_id(app)]);
 }
-function read_rank(run3) {
-  const id = read_id(run3);
+function read_rank(run4) {
+  const id = read_id(run4);
   if (id === void 0) return void 0;
-  return { suite: read_id(run3["check_suite"]) ?? NO_SUITE, run: id };
+  return { suite: read_id(run4["check_suite"]) ?? NO_SUITE, run: id };
 }
 function is_ranked_above(candidate, current) {
   if (candidate.suite !== current.suite) return candidate.suite > current.suite;
@@ -5852,23 +5901,23 @@ function should_replace(previous, rank) {
   const previous_rank = previous === void 0 ? void 0 : read_rank(previous);
   return previous_rank === void 0 || is_ranked_above(rank, previous_rank);
 }
-function remember_newest_run(run3, newest) {
-  const key2 = check_run_group_key(run3);
-  const rank = read_rank(run3);
+function remember_newest_run(run4, newest) {
+  const key2 = check_run_group_key(run4);
+  const rank = read_rank(run4);
   if (key2 === void 0 || rank === void 0) return;
-  if (should_replace(newest.get(key2), rank)) newest.set(key2, run3);
+  if (should_replace(newest.get(key2), rank)) newest.set(key2, run4);
 }
-function is_newest_run(run3, newest) {
-  const key2 = check_run_group_key(run3);
-  if (key2 === void 0 || read_rank(run3) === void 0) return true;
-  return newest.get(key2) === run3;
+function is_newest_run(run4, newest) {
+  const key2 = check_run_group_key(run4);
+  if (key2 === void 0 || read_rank(run4) === void 0) return true;
+  return newest.get(key2) === run4;
 }
 function to_check_run_items(check_runs_json) {
   const pages = read_pages(check_runs_json, check_runs_page_schema, NOT_A_CHECK_RUNS_LISTING);
   const runs = pages.flatMap((page) => page.check_runs);
   const newest = /* @__PURE__ */ new Map();
-  for (const run3 of runs) remember_newest_run(run3, newest);
-  return runs.filter((run3) => is_newest_run(run3, newest));
+  for (const run4 of runs) remember_newest_run(run4, newest);
+  return runs.filter((run4) => is_newest_run(run4, newest));
 }
 function to_status_context_items(status_json) {
   const pages = read_pages(status_json, status_page_schema, NOT_A_STATUS_LISTING);
@@ -5954,7 +6003,7 @@ var MERGE_READ_BACK_ATTEMPTS = 3;
 var MERGE_READ_BACK_INTERVAL_MS = 1e3;
 var PR_NUMBER_PATTERN = /\/pull\/([1-9]\d*)$/u;
 var LABELS_SEGMENT2 = "/labels";
-var PR_LABELS = z16.array(z16.object({ name: z16.string() }));
+var PR_LABELS = z15.array(z15.object({ name: z15.string() }));
 async function add_pr_classification(number, label2) {
   await git_gh_exec.exec_gh_api({
     path: `${git_gh_api_path.issue_api_path(number)}${LABELS_SEGMENT2}`,
@@ -6007,6 +6056,7 @@ async function pr_comment(branch_name, body) {
 }
 async function pr_update_body(branch_name, body) {
   const pr_number = await require_pr_number(branch_name);
+  forget_pr_numbers();
   await git_gh_exec.exec_gh_api({
     path: git_gh_api_path.pull_api_path(String(pr_number)),
     method: PATCH_METHOD2,
@@ -6014,6 +6064,7 @@ async function pr_update_body(branch_name, body) {
   });
 }
 async function put_merge(pr_number) {
+  forget_pr_numbers();
   await git_gh_exec.exec_gh_api({
     path: git_gh_api_path.pull_merge_api_path(String(pr_number)),
     method: PUT_METHOD,
@@ -6141,7 +6192,9 @@ var PR_CHECKS_TIMEOUT_MESSAGE = "Timed out while waiting for PR checks to comple
 function is_pr_checks_timeout(error) {
   return error instanceof Error && error.message === PR_CHECKS_TIMEOUT_MESSAGE;
 }
-var SHOULD_ALWAYS_READ_REVIEW_DECISION = () => true;
+function should_always_read_review_decision() {
+  return true;
+}
 var MERGE_GATE_EVALUATOR = {
   evaluate: evaluate_pr_state,
   describe: describe_pr_failure,
@@ -6168,7 +6221,7 @@ async function read_pr_state(input, evaluator) {
   try {
     const snapshot = await input.options.fetcher(
       input.options.branch_name,
-      evaluator.should_read_review_decision ?? SHOULD_ALWAYS_READ_REVIEW_DECISION
+      evaluator.should_read_review_decision ?? should_always_read_review_decision
     );
     return { kind: "read", snapshot };
   } catch (error) {
@@ -6222,7 +6275,7 @@ async function wait_for_pr_success(options) {
   }
   throw to_exhaustion_error(carried.read_failure);
 }
-async function default_fetch_pr_state(branch_name, should_read_review_decision = SHOULD_ALWAYS_READ_REVIEW_DECISION) {
+async function default_fetch_pr_state(branch_name, should_read_review_decision = should_always_read_review_decision) {
   const checks = await git_gh_pr_snapshot.pr_get_checks_snapshot(branch_name);
   const snapshot = parse_pr_state_snapshot(checks.snapshot_json);
   if (!should_read_review_decision(snapshot)) return snapshot;
@@ -6250,11 +6303,13 @@ function describe_checks_failure(snapshot) {
   const failed = snapshot.rollup.filter((check) => check.status === CHECK_STATUS_FAIL);
   return `${CHECKS_FAILED_MESSAGE}: ${failed.map((check) => check.name).join(", ")}`;
 }
-var SHOULD_NEVER_READ_REVIEW_DECISION = () => false;
+function should_never_read_review_decision() {
+  return false;
+}
 var CHECKS_SETTLED_EVALUATOR = {
   evaluate: evaluate_checks_settled,
   describe: describe_checks_failure,
-  should_read_review_decision: SHOULD_NEVER_READ_REVIEW_DECISION
+  should_read_review_decision: should_never_read_review_decision
 };
 async function watch_until_settled(branch_name) {
   await wait_for_pr_success({
@@ -6270,7 +6325,7 @@ async function watch_until_settled(branch_name) {
   });
 }
 async function fail_when_no_checks(branch_name) {
-  const snapshot = await default_fetch_pr_state(branch_name, SHOULD_NEVER_READ_REVIEW_DECISION);
+  const snapshot = await default_fetch_pr_state(branch_name, should_never_read_review_decision);
   if (snapshot.rollup.length === 0) throw new Error(NO_CHECKS_MESSAGE);
 }
 async function pr_checks_watch(branch_name) {
@@ -6304,7 +6359,6 @@ export {
   git_spawn_sync,
   git_command,
   git_common_directory,
-  error_text,
   tail_commands,
   filing_cap,
   CONTEXT_CUT_THRESHOLD,
@@ -6312,10 +6366,10 @@ export {
   cli_flags,
   own_session,
   backlog_budget,
-  run_cut_handoff,
   run_hold,
+  run_cut_handoff,
   run_cut,
-  run_tail,
+  run_tail_rule,
   lane_background,
   IN_PROGRESS_LABEL,
   NEEDS_DECISION_LABEL,
@@ -6325,7 +6379,7 @@ export {
   ALREADY_DONE_LABEL,
   has_any_label,
   has_label_name,
-  process_identity,
+  agent_headless,
   run_event_stream,
   run_invocation,
   run_carry,
@@ -6334,11 +6388,9 @@ export {
   lane_park,
   repo_origin,
   repo_party,
-  process_owner_schema,
   lane_registry,
   run_headless,
   git_gh_api_path,
-  FETCH_TIMEOUT_MS,
   read_json_listing,
   parse_json_object_safe,
   git_gh_exec,