@joshuafolkken/kit 1.872.0

package/dist/hooks/chunk-AUFY653N.js

@@ -0,0 +1,3425 @@
+import {
+  lane_child_marker,
+  run_issue_number
+} from "./chunk-N3MJADY7.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  cost_blocks,
+  cost_usage,
+  lane_paths,
+  stamp_file,
+  time_density_hook,
+  time_shell,
+  time_transcript_line
+} from "./chunk-IMYMAODK.js";
+import {
+  ENV_FILE_NAME,
+  LANE_SEAT_KEY,
+  PORT_SEED_KEY,
+  ports
+} from "./chunk-SSX23SJ2.js";
+
+// scripts/rules/bash-triggers.ts
+function on_bash_command(is_match) {
+  return function is_trigger(call) {
+    if (call.name !== cost_blocks.BASH_TOOL) return false;
+    return is_match(time_shell.bash_command(call.input));
+  };
+}
+var ISSUE_CREATE_COMMAND = /\bgh\s+(?:\S+\s+)*?issue\s+create\b/u;
+var ISSUES_ENDPOINT = /repos\/[^\s'"]*\/issues(?=$|["'\s])/u;
+var TITLE_FIELD = /(?:-f|-F|--field|--raw-field)\s*'?title=/u;
+function is_issue_filing(command) {
+  if (ISSUE_CREATE_COMMAND.test(command)) return true;
+  return ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command);
+}
+var bash_triggers = { is_issue_filing, on_bash_command };
+
+// scripts/rules/tail-commands.ts
+function is_bash_use(block) {
+  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
+}
+function bash_commands_of(line) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return [];
+  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
+}
+function prior_bash_commands(tail) {
+  return tail.split("\n").flatMap((line) => bash_commands_of(line));
+}
+var tail_commands = { bash_commands_of, is_bash_use, prior_bash_commands };
+
+// scripts/rules/filing-cap.ts
+var FILING_CAP = 10;
+var CAP_REACHED = FILING_CAP;
+function is_filing_use(block) {
+  if (!tail_commands.is_bash_use(block)) return false;
+  return bash_triggers.is_issue_filing(time_shell.bash_command(block.input));
+}
+function collect_block(block, found) {
+  if (block.result_id !== "") found.refusals.set(block.result_id, block.refusal_guard);
+  if (is_filing_use(block)) found.filing_ids.push(block.id);
+}
+function collect_line(line, found) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return;
+  for (const block of parsed.blocks) collect_block(block, found);
+}
+function scan_tail(tail) {
+  const found = { filing_ids: [], refusals: /* @__PURE__ */ new Map() };
+  for (const line of tail.split("\n")) collect_line(line, found);
+  return found;
+}
+function prior_filing_count(tail) {
+  const { filing_ids, refusals } = scan_tail(tail);
+  return filing_ids.filter((id) => (refusals.get(id) ?? "") === "").length;
+}
+function is_prompt_line(line) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed?.type !== "user") return false;
+  return parsed.blocks.every((block) => block.result_id === "");
+}
+function current_turn(tail) {
+  const lines = tail.split("\n");
+  const start = lines.findLastIndex((line) => is_prompt_line(line));
+  return lines.slice(Math.max(start, 0)).join("\n");
+}
+function turn_filing_count(tail) {
+  return prior_filing_count(current_turn(tail));
+}
+function decide(_call, run2) {
+  return prior_filing_count(time_density_hook.read_tail(run2.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 \xA72d, \`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 = {
+  id: "filing-cap",
+  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+  reason: FILING_CAP_REASON,
+  decide
+};
+var filing_cap = {
+  FILING_CAP,
+  FILING_CAP_REASON,
+  ROW,
+  current_turn,
+  decide,
+  prior_filing_count,
+  turn_filing_count
+};
+
+// scripts/git/constants.ts
+import { platform } from "node:os";
+var GIT_COMMAND_UNIX = "/usr/bin/git";
+var PORCELAIN_FLAG = "--porcelain";
+function get_git_command() {
+  if (platform() === "win32") {
+    return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
+  }
+  return GIT_COMMAND_UNIX;
+}
+function get_git_command_for_spawn() {
+  if (platform() === "win32") {
+    return String.raw`C:\Program Files\Git\cmd\git.exe`;
+  }
+  return GIT_COMMAND_UNIX;
+}
+var git_utilities = {
+  get_git_command,
+  get_git_command_for_spawn
+};
+
+// scripts/git/git-push-transport.ts
+import { execa } from "execa";
+
+// scripts/git/git-execa-error.ts
+function get_exit_code(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  if (!("exitCode" in error)) return void 0;
+  const { exitCode: exit_code } = error;
+  return typeof exit_code === "number" ? exit_code : void 0;
+}
+function has_timed_out(error) {
+  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
+  return error.timedOut === true;
+}
+function create_spawn_error(command, exit_code) {
+  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
+  const error_message = `git ${command} exited with code ${exit_code_string}`;
+  return new Error(error_message, { cause: { exit_code: exit_code_string } });
+}
+
+// scripts/git/git-push-transport.ts
+var MS_PER_SECOND = 1e3;
+var PUSH_TIMEOUT_SECONDS = 120;
+var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
+var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
+var PUSH_TIMEOUT_MESSAGE = "git push timed out";
+var PUSH_TIMEOUT_EXIT_CODE = "timeout";
+var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
+var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
+var SSH_LEGACY_VARIABLE = "GIT_SSH";
+var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
+var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
+var PUSH_SUBCOMMAND = "push";
+function to_environment_value(name) {
+  return process.env[name]?.trim() ?? "";
+}
+function to_configured_ssh_command() {
+  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
+  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
+}
+async function has_configured_ssh_command() {
+  if (to_configured_ssh_command() !== "") return true;
+  try {
+    const git_command_bin = git_utilities.get_git_command_for_spawn();
+    const { stdout } = await execa(git_command_bin, ["config", "--get", SSH_COMMAND_CONFIG_KEY]);
+    return stdout.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+async function to_push_options() {
+  const should_keep_alive = !await has_configured_ssh_command();
+  return {
+    stdio: "inherit",
+    timeout: PUSH_TIMEOUT_MS,
+    env: should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {}
+  };
+}
+async function did_push_time_out(arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const options = await to_push_options();
+  try {
+    await execa(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    return false;
+  } catch (error) {
+    if (has_timed_out(error)) return true;
+    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
+  }
+}
+function to_manual_command(arguments_list) {
+  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
+}
+function to_retry_notice(arguments_list) {
+  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
+}
+function create_timeout_error(arguments_list) {
+  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
+  return new Error(message, { cause: { exit_code: PUSH_TIMEOUT_EXIT_CODE } });
+}
+async function push(arguments_list) {
+  if (!await did_push_time_out(arguments_list)) return;
+  console.warn(to_retry_notice(arguments_list));
+  if (!await did_push_time_out(arguments_list)) return;
+  throw create_timeout_error(arguments_list);
+}
+var git_push_transport = {
+  push
+};
+
+// scripts/git/git-spawn.ts
+import { execa as execa2 } from "execa";
+async function read(arguments_) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  const { stdout } = await execa2(git_cmd, arguments_);
+  return stdout.trimEnd();
+}
+async function with_output(command, arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  try {
+    await execa2(git_command_bin, [command, ...arguments_list], { stdio: "inherit" });
+  } catch (error) {
+    throw create_spawn_error(command, get_exit_code(error));
+  }
+}
+var git_spawn = {
+  read,
+  with_output
+};
+
+// scripts/git/git-command.ts
+async function branch() {
+  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+async function status() {
+  return await git_spawn.read(["status", PORCELAIN_FLAG, "--untracked-files=normal"]);
+}
+async function repository_root() {
+  return await git_spawn.read(["rev-parse", "--show-toplevel"]);
+}
+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]);
+}
+var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
+var NAME_ONLY_FLAG = "--name-only";
+var DEFAULT_BRANCH_FALLBACK = "main";
+async function get_default_branch() {
+  try {
+    const output = await git_spawn.read(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+    const trimmed2 = output.trim();
+    if (trimmed2.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) {
+      return trimmed2.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
+    }
+  } catch {
+  }
+  return DEFAULT_BRANCH_FALLBACK;
+}
+var MERGE_BASE_COMMAND = "merge-base";
+async function reference_exists(reference) {
+  try {
+    await git_spawn.read(["rev-parse", "--verify", "--quiet", reference]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function default_branch_reference() {
+  const default_branch = await get_default_branch();
+  const remote_reference = `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
+  return await reference_exists(remote_reference) ? remote_reference : default_branch;
+}
+async function change_base() {
+  const default_branch = await default_branch_reference();
+  try {
+    return await git_spawn.read([MERGE_BASE_COMMAND, default_branch, "HEAD"]);
+  } catch {
+    return default_branch;
+  }
+}
+async function diff_main(file_path) {
+  return await git_spawn.read(["diff", await change_base(), "--", file_path]);
+}
+var NO_PATH_QUOTING = ["-c", "core.quotePath=false"];
+var NO_RELATIVE_PATHS = "--no-relative";
+var NO_RENAME_DETECTION = "--no-renames";
+async function change_base_commit() {
+  return await git_spawn.read(["rev-parse", await change_base()]);
+}
+async function diff_main_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    await change_base(),
+    "--"
+  ]);
+}
+async function diff_cached_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--cached",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION
+  ]);
+}
+async function diff_main_numstat() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--numstat",
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    await change_base(),
+    "--"
+  ]);
+}
+var WHOLE_TREE_PATHSPEC = ":/";
+async function untracked_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "--full-name",
+    WHOLE_TREE_PATHSPEC
+  ]);
+}
+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]);
+}
+async function merge_fast_forward(branch_name) {
+  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`]);
+}
+async function merge_branch(branch_name, message) {
+  const message_arguments = message === void 0 ? [] : ["-m", message];
+  await git_spawn.with_output("merge", [...message_arguments, `origin/${branch_name}`]);
+}
+async function checkout_b(branch_name) {
+  return await git_spawn.read(["checkout", "-b", branch_name]);
+}
+async function checkout(branch_name) {
+  return await git_spawn.read(["checkout", branch_name]);
+}
+async function commit(message) {
+  await git_spawn.with_output("commit", ["-m", message]);
+}
+async function delete_branch(branch_name) {
+  await git_spawn.read(["branch", "-d", branch_name]);
+}
+async function commit_count_beyond(base, tip) {
+  const range = `${base}..${tip}`;
+  const output = await git_spawn.read(["rev-list", "--count", range]);
+  const parsed = Number(output);
+  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
+  throw new Error(`\`git rev-list --count ${range}\` printed \`${output}\` rather than a count`);
+}
+function is_exit_code_128(cause) {
+  return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
+}
+function is_upstream_not_set_error(error) {
+  if (!(error instanceof Error)) return false;
+  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]);
+}
+async function push2() {
+  try {
+    await git_push_transport.push([]);
+  } catch (error) {
+    if (is_upstream_not_set_error(error)) {
+      const current_branch = await branch();
+      await push_with_upstream(current_branch);
+      return;
+    }
+    throw error;
+  }
+}
+async function pull_fast_forward() {
+  await git_spawn.with_output("pull", ["--ff-only"]);
+}
+var SHORT_NAME_FORMAT = "--format=%(refname:short)";
+var REMOTES_FLAG = "--remotes";
+async function list_branches(flags, pattern) {
+  try {
+    const output = await git_spawn.read([
+      "branch",
+      "--list",
+      SHORT_NAME_FORMAT,
+      ...flags,
+      pattern
+    ]);
+    return output.split("\n").filter((line) => line.trim() !== "");
+  } catch {
+    return [];
+  }
+}
+async function branch_names(pattern) {
+  return await list_branches([], pattern);
+}
+async function branch_names_remote(pattern) {
+  return await list_branches([REMOTES_FLAG], pattern);
+}
+async function branch_exists(branch_name) {
+  const names = await branch_names(branch_name);
+  return names.length > 0;
+}
+var ALL_PATHS_PATHSPEC = ":/";
+function exclude_pathspec(file_path) {
+  return `:(exclude,top)${file_path}`;
+}
+async function add_tracked(excluded_paths) {
+  const exclusions = excluded_paths.map((file_path) => exclude_pathspec(file_path));
+  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
+}
+async function add_path(file_path) {
+  await git_spawn.with_output("add", ["--", file_path]);
+}
+var FIRST_PARENT_FLAG = "--first-parent";
+async function log_first_parent(limit, file_path, tip = "HEAD") {
+  const output = await git_spawn.read([
+    "log",
+    FIRST_PARENT_FLAG,
+    "--format=%H",
+    `-n`,
+    String(limit),
+    tip,
+    "--",
+    file_path
+  ]);
+  return output.split("\n").filter((line) => line.length > 0);
+}
+async function show_file(spec) {
+  return await git_spawn.read(["show", spec]);
+}
+var MERGE_COUNT_ARGUMENTS = [
+  "rev-list",
+  "--count",
+  "--merges",
+  FIRST_PARENT_FLAG
+];
+function merge_count_arguments(range) {
+  return [...MERGE_COUNT_ARGUMENTS, range];
+}
+async function count_merges(range) {
+  const output = await git_spawn.read(merge_count_arguments(range));
+  const parsed = Number(output.trim());
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+var git_command = {
+  GIT_DIRECTORY_ARGUMENTS,
+  branch,
+  status,
+  repository_root,
+  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,
+  fetch_branch,
+  merge_fast_forward,
+  merge_branch,
+  checkout_b,
+  checkout,
+  commit,
+  commit_count_beyond,
+  delete_branch,
+  push: push2,
+  pull_fast_forward,
+  branch_exists,
+  branch_names,
+  branch_names_remote,
+  add_tracked,
+  add_path,
+  log_first_parent,
+  show_file,
+  count_merges,
+  merge_count_arguments,
+  is_upstream_not_set_error
+};
+
+// scripts/run/run-hold.ts
+import { z } from "zod";
+var HOLD_PREFIX = "josh-run-hold-";
+var UNNUMBERED_ISSUE = "new";
+var HOLD_MAX_AGE_HOURS = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
+var RELEASE_COMMAND = "pnpm josh run:release";
+var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
+var NOT_IDLE = 'that is not "nothing is running here"';
+var FREE_READ = { kind: "free" };
+var UNREADABLE_READ = { kind: "unreadable" };
+function hold_path(git_directory) {
+  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
+}
+async function worktree_directory() {
+  const directories = await git_command.git_directories();
+  return directories[0];
+}
+async function is_linked_worktree() {
+  const directories = await git_command.git_directories();
+  return directories[0] !== void 0 && directories[0] !== directories[1];
+}
+var run_hold_schema = z.object({
+  issue: z.string(),
+  taken_at: z.string(),
+  pid: z.number()
+});
+function parse_hold(raw) {
+  try {
+    const parsed = run_hold_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_stale(hold, now) {
+  const taken = Date.parse(hold.taken_at);
+  if (Number.isNaN(taken)) return true;
+  return now.getTime() - taken > HOLD_MAX_AGE_MS;
+}
+function classify(raw, now) {
+  if (raw === void 0) return FREE_READ;
+  const hold = parse_hold(raw);
+  if (hold === void 0) return UNREADABLE_READ;
+  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
+}
+function read_hold(target, now = /* @__PURE__ */ new Date()) {
+  return classify(stamp_file.read_stamp_text(target), now);
+}
+function build_hold(issue, now) {
+  return { issue, taken_at: now.toISOString(), pid: process.pid };
+}
+function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  const hold = build_hold(issue, now);
+  stamp_file.write_stamp(target, hold);
+  return hold;
+}
+function create_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  return stamp_file.create_stamp(target, build_hold(issue, now));
+}
+async function is_tree_dirty() {
+  try {
+    const status2 = await git_command.status();
+    return status2.trim() !== "";
+  } catch {
+    return true;
+  }
+}
+function release_hold(target) {
+  stamp_file.remove_stamp(target);
+}
+function describe_holder(hold) {
+  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : `#${hold.issue}`;
+  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.pid)})`;
+}
+function own_release_command(issue) {
+  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
+}
+function is_own_hold(hold, claimant) {
+  return hold.issue === claimant;
+}
+function held_message(hold) {
+  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
+}
+function foreign_release_message(hold) {
+  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
+}
+function forced_release_message(hold) {
+  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
+}
+function unreadable_message() {
+  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
+}
+function stale_message(hold) {
+  return `Replaced a stale run record held by ${describe_holder(hold)}: older than ${String(HOLD_MAX_AGE_HOURS)} hours, so the run that wrote it has ended without releasing it.`;
+}
+function uncommitted_message(hold) {
+  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
+}
+function race_message(read2, target) {
+  if (read2.kind === "held") return held_message(read2.hold);
+  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
+}
+function unknown_message() {
+  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
+}
+var run_hold = {
+  FORCE_RELEASE_COMMAND,
+  HOLD_MAX_AGE_HOURS,
+  HOLD_MAX_AGE_MS,
+  RELEASE_COMMAND,
+  UNNUMBERED_ISSUE,
+  classify,
+  create_hold,
+  describe_holder,
+  foreign_release_message,
+  forced_release_message,
+  held_message,
+  hold_path,
+  is_linked_worktree,
+  is_own_hold,
+  is_tree_dirty,
+  own_release_command,
+  parse_hold,
+  race_message,
+  read_hold,
+  release_hold,
+  stale_message,
+  uncommitted_message,
+  unknown_message,
+  unreadable_message,
+  worktree_directory,
+  write_hold
+};
+
+// scripts/run/run-cut.ts
+import { execFileSync } from "node:child_process";
+
+// scripts/josh/agent-session-environment.ts
+var SESSION_ID_KEY = "CLAUDE_CODE_SESSION_ID";
+var PARENT_SESSION_KEYS = [
+  "CLAUDE_CODE_MESSAGING_SOCKET",
+  "CLAUDE_CODE_MESSAGING_TOKEN",
+  SESSION_ID_KEY,
+  "CLAUDE_CODE_CHILD_SESSION"
+];
+var PROXY_KEYS = [
+  "ALL_PROXY",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "all_proxy",
+  "http_proxy",
+  "https_proxy",
+  "GLOBAL_AGENT_HTTP_PROXY",
+  "GLOBAL_AGENT_HTTPS_PROXY"
+];
+var PROXY_CERTIFICATE_KEY = "NODE_EXTRA_CA_CERTS";
+var LOOPBACK_HOSTS = ["localhost", "ip6-localhost", "[::1]"];
+var LOOPBACK_PREFIX = "127.";
+var NO_HOST = "";
+function parsed_host(value) {
+  try {
+    return new URL(value).hostname;
+  } catch {
+    return NO_HOST;
+  }
+}
+function proxy_host(value) {
+  const direct = parsed_host(value);
+  return direct === NO_HOST ? parsed_host(`http://${value}`) : direct;
+}
+function is_loopback_host(host) {
+  return host.startsWith(LOOPBACK_PREFIX) || LOOPBACK_HOSTS.includes(host);
+}
+function is_loopback_proxy(value) {
+  if (value === void 0 || value === NO_HOST) return false;
+  return is_loopback_host(proxy_host(value));
+}
+function is_declared(value) {
+  return value !== void 0 && value !== NO_HOST;
+}
+function loopback_proxy_keys(source, is_removed = is_loopback_proxy) {
+  const declared = PROXY_KEYS.filter((key) => is_declared(source[key]));
+  const matched = declared.filter((key) => is_removed(source[key]));
+  const is_certificate_included = matched.length > 0 && matched.length === declared.length;
+  return is_certificate_included ? [...matched, PROXY_CERTIFICATE_KEY] : matched;
+}
+function to_removed(keys) {
+  return Object.fromEntries(keys.map((key) => [key, void 0]));
+}
+function removed_environment(source = process.env) {
+  return to_removed([...PARENT_SESSION_KEYS, ...loopback_proxy_keys(source)]);
+}
+var SCANNER_DIRECTORY = ".safe-chain";
+var PATH_SEPARATOR = /[/\\]/u;
+function is_scanner_certificate(value) {
+  return value?.split(PATH_SEPARATOR).includes(SCANNER_DIRECTORY) ?? false;
+}
+var SCANNER_PROXY_KEY = "HTTPS_PROXY";
+function is_scanner_proxy(source) {
+  const scanner_proxy = source[SCANNER_PROXY_KEY];
+  return function is_match(value) {
+    return value === scanner_proxy && is_loopback_proxy(value);
+  };
+}
+function removed_proxy_environment(source = process.env) {
+  if (!is_scanner_certificate(source[PROXY_CERTIFICATE_KEY])) return {};
+  return to_removed(loopback_proxy_keys(source, is_scanner_proxy(source)));
+}
+var agent_session_environment = {
+  LOOPBACK_HOSTS,
+  PARENT_SESSION_KEYS,
+  PROXY_CERTIFICATE_KEY,
+  PROXY_KEYS,
+  SESSION_ID_KEY,
+  removed_environment,
+  removed_proxy_environment
+};
+
+// scripts/agent/agent-role-profile.ts
+import { z as z2 } from "zod";
+var FIRST_PRINTABLE_CODE = 32;
+var DELETE_CODE = 127;
+var FIRST_CODE_POINT = 0;
+var EMPTY_LENGTH = 0;
+var MAX_VALUE_LENGTH = 4096;
+var ROLE_SCHEMA = z2.enum(["scheduler", "worker", "reviewer"]);
+var PROVIDER_SCHEMA = z2.enum(["anthropic", "openai"]);
+var EFFORT_SCHEMA = z2.enum(["low", "medium", "high", "xhigh", "max"]);
+var PHASE_SCHEMA = z2.enum(["setup", "implementation", "pre-gate"]);
+var PROFILE_SCHEMA = z2.object({
+  provider: PROVIDER_SCHEMA.default("anthropic"),
+  role: ROLE_SCHEMA,
+  model: z2.string(),
+  effort: EFFORT_SCHEMA
+});
+var SCHEDULER = "scheduler";
+var WORKER = "worker";
+var REVIEWER = "reviewer";
+var SETUP_PHASE = "setup";
+var IMPLEMENTATION_PHASE = "implementation";
+var PRE_GATE_PHASE = "pre-gate";
+var ANTHROPIC_PROVIDER = "anthropic";
+var OPENAI_PROVIDER = "openai";
+var OPENAI_MODEL = "gpt-6-sol";
+var ANTHROPIC_MODEL = "claude-opus-5-5";
+var CODEX_SESSION_KEY = "CODEX_THREAD_ID";
+var DEFAULT_PROFILES = {
+  scheduler: {
+    provider: ANTHROPIC_PROVIDER,
+    role: SCHEDULER,
+    model: ANTHROPIC_MODEL,
+    effort: "medium"
+  },
+  worker: { provider: ANTHROPIC_PROVIDER, role: WORKER, model: ANTHROPIC_MODEL, effort: "medium" },
+  reviewer: {
+    provider: ANTHROPIC_PROVIDER,
+    role: REVIEWER,
+    model: ANTHROPIC_MODEL,
+    effort: "high"
+  }
+};
+var OPENAI_PROFILES = {
+  scheduler: { provider: OPENAI_PROVIDER, role: SCHEDULER, model: OPENAI_MODEL, effort: "medium" },
+  worker: { provider: OPENAI_PROVIDER, role: WORKER, model: OPENAI_MODEL, effort: "medium" },
+  reviewer: { provider: OPENAI_PROVIDER, role: REVIEWER, model: OPENAI_MODEL, effort: "high" }
+};
+var PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES };
+var SHIP_EFFORT = "low";
+var PHASE_EFFORT = {
+  worker: { [PRE_GATE_PHASE]: SHIP_EFFORT }
+};
+var ENV_KEYS = {
+  scheduler: { model: "JOSH_SCHEDULER_MODEL", effort: "JOSH_SCHEDULER_EFFORT" },
+  worker: { model: "JOSH_WORKER_MODEL", effort: "JOSH_WORKER_EFFORT" },
+  reviewer: { model: "JOSH_REVIEWER_MODEL", effort: "JOSH_REVIEWER_EFFORT" }
+};
+var LEGACY_WORKER_KEYS = { model: "JOSH_LANE_MODEL", effort: "JOSH_LANE_EFFORT" };
+function is_control_character(character) {
+  const code = character.codePointAt(FIRST_CODE_POINT) ?? FIRST_PRINTABLE_CODE;
+  return code < FIRST_PRINTABLE_CODE || code === DELETE_CODE;
+}
+function is_safe_value(value) {
+  if (value.length === EMPTY_LENGTH || value.length > MAX_VALUE_LENGTH) return false;
+  for (const character of value) if (is_control_character(character)) return false;
+  return true;
+}
+function trimmed(value) {
+  const result = value?.trim();
+  return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
+}
+function override_value(role, field, environment2) {
+  const key = ENV_KEYS[role][field];
+  const value = trimmed(environment2[key]);
+  if (value !== void 0) return { key, value };
+  if (role !== WORKER) return { key, value: void 0 };
+  const legacy = LEGACY_WORKER_KEYS[field];
+  const legacy_value = trimmed(environment2[legacy]);
+  return legacy_value === void 0 ? { key, value: void 0 } : { key: legacy, value: legacy_value };
+}
+function model_override(role, environment2, provider) {
+  const key = ENV_KEYS[role].model;
+  return provider === OPENAI_PROVIDER ? { key, value: void 0 } : override_value(role, "model", environment2);
+}
+function rejection(key, value, expected) {
+  return { kind: "rejected", note: `${key}=${value} ${expected}, so the agent was not started` };
+}
+function resolved_effort(override, fallback) {
+  const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback);
+  return parsed.success ? { kind: "effort", effort: parsed.data } : rejection(override.key, override.value ?? "", "is not an allowed effort");
+}
+function has_session(environment2, keys) {
+  return keys.some((key) => trimmed(environment2[key]) !== void 0);
+}
+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 };
+}
+function resolve_provider(environment2 = process.env) {
+  const has_codex = has_session(environment2, [CODEX_SESSION_KEY]);
+  const has_claude = has_session(environment2, agent_session_environment.PARENT_SESSION_KEYS);
+  if (has_codex === has_claude) return session_rejection(has_codex);
+  return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
+}
+function validate(profile, model_key) {
+  if (!is_safe_value(profile.model)) {
+    return rejection(model_key, profile.model, "is not a safe model");
+  }
+  return { kind: "profile", profile };
+}
+function phase_effort(role, phase, fallback) {
+  const parsed = PHASE_SCHEMA.safeParse(phase);
+  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);
+  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 resolve(role, environment2 = process.env, phase) {
+  const selected = resolve_provider(environment2);
+  if (selected.kind === "rejected") return selected;
+  const defaults = PROVIDER_PROFILES[selected.provider][role];
+  const model = model_override(role, environment2, selected.provider);
+  const effort = override_value(role, "effort", environment2);
+  const resolved = resolved_effort(effort, phase_effort(role, phase, defaults.effort));
+  if (resolved.kind === "rejected") return resolved;
+  const profile = {
+    provider: selected.provider,
+    role,
+    model: model.value ?? defaults.model,
+    effort: resolved.effort
+  };
+  return validate(profile, model.key);
+}
+function describe(profile) {
+  return `provider=${profile.provider} role=${profile.role} model=${profile.model} effort=${profile.effort}`;
+}
+function parse(value) {
+  const parsed = PROFILE_SCHEMA.safeParse(value);
+  return parsed.success && is_safe_value(parsed.data.model) ? parsed.data : void 0;
+}
+var agent_role_profile = {
+  DEFAULT_PROFILES,
+  EFFORT_SCHEMA,
+  ENV_KEYS,
+  IMPLEMENTATION_PHASE,
+  LEGACY_WORKER_KEYS,
+  MAX_VALUE_LENGTH,
+  OPENAI_PROFILES,
+  PHASE_EFFORT,
+  PHASE_SCHEMA,
+  PRE_GATE_PHASE,
+  PROVIDER_SCHEMA,
+  PROFILE_SCHEMA,
+  REVIEWER,
+  SCHEDULER,
+  SETUP_PHASE,
+  WORKER,
+  describe,
+  is_safe_value,
+  parse,
+  phase_effort,
+  resolve,
+  resolve_provider,
+  with_phase_effort
+};
+
+// scripts/backlog/backlog-budget.ts
+var MS_PER_MINUTE = 6e4;
+var MINUTES_PER_HOUR = 60;
+var WHOLE_RUN_BUDGET_HOURS = 8;
+var WHOLE_RUN_BUDGET_MINUTES = WHOLE_RUN_BUDGET_HOURS * MINUTES_PER_HOUR;
+var WHOLE_RUN_BUDGET_MS = WHOLE_RUN_BUDGET_MINUTES * MS_PER_MINUTE;
+var DEFAULT_IDLE_MINUTES = 30;
+var DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE;
+var IDLE_POLL_MINUTES = 5;
+var RUN_VERDICT = "run";
+var WATCH_VERDICT = "watch";
+var STOP_VERDICT = "stop";
+var ANSWERS = ["blocked", "candidates", "exhausted", "parked", "unreadable"];
+var WHOLE_RUN_REASON = `The whole-run bound of ${String(WHOLE_RUN_BUDGET_HOURS)} hours has passed. An unattended run that has not finished overnight needs a person, not more waiting.`;
+var PARKED_REASON = "Nothing opted in can proceed without a person. Report the parked issues and finish.";
+var UNREADABLE_REASON = "The backlog listing could not be read, so nothing was offered. Report what the command printed and finish \u2014 it is not an empty backlog.";
+var BLOCKED_REASON = "Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.";
+var NO_IDLE_WATCH_REASON = "The backlog is empty and the idle watch was turned off with `--idle 0`, so the run finishes here.";
+function to_minutes(duration_ms) {
+  return String(Math.ceil(duration_ms / MS_PER_MINUTE));
+}
+function max_reached_reason(merged, max_issues) {
+  return `This run's maximum of ${String(max_issues)} is reached, with ${String(merged)} merged. Report what was done, including how many were picked up during an idle watch, and finish.`;
+}
+function draining_reason(running, reason) {
+  return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish \u2014 ${reason}`;
+}
+function idle_expired_reason(idle_budget_ms) {
+  return `The backlog stayed empty for the whole ${to_minutes(idle_budget_ms)}-minute idle watch. Report what was done, including how many were picked up during the watch, and finish.`;
+}
+function next_ask_minutes(left_ms) {
+  const left_minutes = Number(to_minutes(left_ms));
+  return String(Math.min(IDLE_POLL_MINUTES, left_minutes));
+}
+function idle_watch_reason(left_ms) {
+  return `The backlog is empty and the idle watch has about ${to_minutes(left_ms)} minutes left. Release the working tree, ask again in ${next_ask_minutes(left_ms)} minutes, and restart the watch the moment a candidate appears.`;
+}
+function running_watch_reason(running, left_ms) {
+  return `The backlog is empty and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree until they merge and poll at the polling interval, not the idle poll \u2014 the watch is running down meanwhile.`;
+}
+function watching_reason(input, left_ms) {
+  if (input.running === 0) return idle_watch_reason(left_ms);
+  return running_watch_reason(input.running, left_ms);
+}
+function taken_by(input) {
+  return input.merged + input.running;
+}
+function run_reason(input) {
+  const { max_issues } = input;
+  if (max_issues === void 0) return "No maximum was given, so start every issue offered.";
+  return `Start at most ${String(max_issues - taken_by(input))} more: this run's maximum is ${String(max_issues)}, with ${String(input.merged)} merged and ${String(input.running)} running.`;
+}
+var ANSWER_STOP_REASONS = {
+  parked: PARKED_REASON,
+  unreadable: UNREADABLE_REASON
+};
+function whole_run_reason(input) {
+  if (input.now_ms - input.started_at_ms < WHOLE_RUN_BUDGET_MS) return void 0;
+  return WHOLE_RUN_REASON;
+}
+function stop_reason(input) {
+  return ANSWER_STOP_REASONS[input.answer] ?? whole_run_reason(input);
+}
+function stopping(input, reason) {
+  if (input.running === 0) return { verdict: STOP_VERDICT, reason };
+  return { verdict: WATCH_VERDICT, reason: draining_reason(input.running, reason) };
+}
+function max_decision(input) {
+  const { max_issues } = input;
+  if (max_issues === void 0 || taken_by(input) < max_issues) return void 0;
+  return stopping(input, max_reached_reason(input.merged, max_issues));
+}
+function idle_decision(input) {
+  const { idle_budget_ms } = input;
+  if (idle_budget_ms === void 0) return stopping(input, NO_IDLE_WATCH_REASON);
+  const left_ms = idle_budget_ms - (input.now_ms - input.active_at_ms);
+  if (left_ms <= 0) return stopping(input, idle_expired_reason(idle_budget_ms));
+  return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) };
+}
+function decide2(input) {
+  const reason = stop_reason(input);
+  if (reason !== void 0) return stopping(input, reason);
+  const capped = max_decision(input);
+  if (capped !== void 0) return capped;
+  if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
+  if (input.answer === "blocked") return { verdict: WATCH_VERDICT, reason: BLOCKED_REASON };
+  return idle_decision(input);
+}
+var backlog_budget = {
+  ANSWERS,
+  ANSWER_STOP_REASONS,
+  BLOCKED_REASON,
+  DEFAULT_IDLE_MINUTES,
+  DEFAULT_IDLE_MS,
+  IDLE_POLL_MINUTES,
+  MS_PER_MINUTE,
+  NO_IDLE_WATCH_REASON,
+  PARKED_REASON,
+  RUN_VERDICT,
+  STOP_VERDICT,
+  UNREADABLE_REASON,
+  WATCH_VERDICT,
+  WHOLE_RUN_BUDGET_HOURS,
+  WHOLE_RUN_BUDGET_MINUTES,
+  WHOLE_RUN_BUDGET_MS,
+  WHOLE_RUN_REASON,
+  decide: decide2,
+  draining_reason,
+  idle_expired_reason,
+  idle_watch_reason,
+  max_reached_reason,
+  run_reason,
+  running_watch_reason,
+  taken_by
+};
+
+// scripts/cost-runtime/cost-pricing.ts
+var CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var CACHE_WRITE_1H_MULTIPLIER = 2;
+var CACHE_READ_MULTIPLIER = 0.1;
+var TOKENS_PER_MILLION = 1e6;
+var MODEL_PRICES = {
+  "claude-fable-5": { input: 10, output: 50 },
+  "claude-mythos-5": { input: 10, output: 50 },
+  "claude-opus-5": { input: 5, output: 25 },
+  "claude-opus-4-8": { input: 5, output: 25 },
+  "claude-opus-4-7": { input: 5, output: 25 },
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-sonnet-5": { input: 2, output: 10 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-haiku-4-5": { input: 1, output: 5 }
+};
+var CONTEXT_MARKER = "[";
+function resolve_price(model) {
+  const base = model.split(CONTEXT_MARKER)[0] ?? model;
+  const direct = MODEL_PRICES[base];
+  if (direct !== void 0) return direct;
+  const [matched] = Object.keys(MODEL_PRICES).filter((id) => base.startsWith(id)).toSorted((left, right) => right.length - left.length);
+  return matched === void 0 ? void 0 : MODEL_PRICES[matched];
+}
+function estimate_cost(totals, price) {
+  const weighted_input = totals.input_tokens + totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER + totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER + totals.cache_read_tokens * CACHE_READ_MULTIPLIER;
+  return (weighted_input * price.input + totals.output_tokens * price.output) / TOKENS_PER_MILLION;
+}
+function priced(tokens, rate) {
+  return tokens * rate / TOKENS_PER_MILLION;
+}
+function estimate_composition(totals, price) {
+  return {
+    input_usd: priced(totals.input_tokens, price.input),
+    cache_write_5m_usd: priced(
+      totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER,
+      price.input
+    ),
+    cache_write_1h_usd: priced(
+      totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER,
+      price.input
+    ),
+    cache_read_usd: priced(totals.cache_read_tokens * CACHE_READ_MULTIPLIER, price.input),
+    output_usd: priced(totals.output_tokens, price.output)
+  };
+}
+function to_model_cost(model, totals) {
+  const price = resolve_price(model);
+  if (price === void 0) return { model, totals };
+  return { model, totals, cost_usd: estimate_cost(totals, price) };
+}
+function cost_by_model(records) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const running = grouped.get(record.model) ?? cost_usage.EMPTY_TOTALS;
+    grouped.set(record.model, cost_usage.add_totals(running, record.totals));
+  }
+  return [...grouped].map(([model, totals]) => to_model_cost(model, totals));
+}
+function total_cost(costs) {
+  return {
+    usd: costs.reduce((sum, entry) => sum + (entry.cost_usd ?? 0), 0),
+    unpriced: costs.filter((entry) => entry.cost_usd === void 0).map((entry) => entry.model)
+  };
+}
+function cost_of(records) {
+  return total_cost(cost_by_model(records)).usd;
+}
+var cost_pricing = {
+  CACHE_WRITE_5M_MULTIPLIER,
+  CACHE_WRITE_1H_MULTIPLIER,
+  CACHE_READ_MULTIPLIER,
+  MODEL_PRICES,
+  resolve_price,
+  estimate_cost,
+  estimate_composition,
+  cost_by_model,
+  total_cost,
+  cost_of
+};
+
+// scripts/cost-runtime/context-cut-payback.ts
+var POST_CUT_CONTEXT = 6e4;
+var EXPECTED_REMAINING_REQUESTS = 10;
+function write_over_read() {
+  return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.CACHE_READ_MULTIPLIER;
+}
+function break_even_context(remaining = EXPECTED_REMAINING_REQUESTS) {
+  if (remaining <= 0) return Infinity;
+  return Math.round(POST_CUT_CONTEXT * (1 + write_over_read() / remaining));
+}
+function break_even_requests(current_context) {
+  const saved_per_request = current_context - POST_CUT_CONTEXT;
+  if (saved_per_request <= 0) return Infinity;
+  return POST_CUT_CONTEXT * write_over_read() / saved_per_request;
+}
+function pays_back(current_context, remaining = EXPECTED_REMAINING_REQUESTS) {
+  return current_context > break_even_context(remaining);
+}
+var context_cut_payback = {
+  POST_CUT_CONTEXT,
+  EXPECTED_REMAINING_REQUESTS,
+  break_even_context,
+  break_even_requests,
+  pays_back
+};
+
+// scripts/cost-runtime/context-cut-threshold.ts
+var CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context();
+var RECENT_REQUEST_WINDOW = 10;
+
+// scripts/lane/lane-child-invocation.ts
+var CHILD_INVOCATION = "fullrun";
+var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
+var SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`;
+function child_invocation(issue) {
+  run_issue_number.require_issue_number(issue);
+  return `${CHILD_INVOCATION} #${issue}`;
+}
+function process_pattern(issue) {
+  run_issue_number.require_issue_number(issue);
+  return `(${CHILD_INVOCATION}|${SHIP_PROCESS} .*) #${issue}$`;
+}
+function resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue #${issue} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function outage_resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue #${issue} after an API disconnection \u2014 your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function ship_stop_invocation(issue) {
+  const preamble = `Resuming the lane child for issue #${issue} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md. Do not re-plan or re-implement what is already on the branch.`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+var lane_child_invocation = {
+  CHILD_INVOCATION,
+  child_invocation,
+  outage_resume_invocation,
+  process_pattern,
+  resume_invocation,
+  ship_stop_invocation
+};
+
+// scripts/run/run-cut.ts
+import { z as z4 } from "zod";
+
+// scripts/run/run-cut-handoff.ts
+import { readFileSync } from "node:fs";
+import { z as z3 } from "zod";
+var handoff_schema = z3.object({
+  instruction: z3.string(),
+  completed: z3.array(z3.string()),
+  remaining: z3.array(z3.string()),
+  untouched: z3.array(z3.string())
+});
+var COMPLETED_LABEL = "Completed";
+var REMAINING_LABEL = "Remaining";
+var UNTOUCHED_LABEL = "Deliberately untouched";
+var INSTRUCTION_LABEL = "Instruction (verbatim)";
+var EMPTY_LIST_NOTE = "(none)";
+function parse_handoff(raw) {
+  try {
+    const parsed = handoff_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function read_handoff_file(handoff_path) {
+  try {
+    return parse_handoff(readFileSync(handoff_path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function is_complete_handoff(handoff) {
+  return handoff !== void 0 && handoff.instruction.trim() !== "";
+}
+function is_within_bound(handoff, max_bytes) {
+  return Buffer.byteLength(JSON.stringify(handoff), "utf8") <= max_bytes;
+}
+function load_handoff(handoff_path, max_bytes) {
+  if (handoff_path === void 0) return { kind: "ok", handoff: void 0 };
+  const handoff = read_handoff_file(handoff_path);
+  if (handoff === void 0) {
+    return { kind: "bad", note: `--handoff ${handoff_path} is not a readable handoff file` };
+  }
+  if (!is_within_bound(handoff, max_bytes)) {
+    return { kind: "bad", note: `--handoff ${handoff_path} is too large to carry across the cut` };
+  }
+  return { kind: "ok", handoff };
+}
+function describe_list(label, items) {
+  if (items.length === 0) return `${label}: ${EMPTY_LIST_NOTE}`;
+  const bullets = items.map((item) => `  - ${item}`).join("\n");
+  return `${label}:
+${bullets}`;
+}
+function describe_handoff(handoff) {
+  return [
+    `${INSTRUCTION_LABEL}:
+${handoff.instruction}`,
+    describe_list(COMPLETED_LABEL, handoff.completed),
+    describe_list(REMAINING_LABEL, handoff.remaining),
+    describe_list(UNTOUCHED_LABEL, handoff.untouched)
+  ].join("\n\n");
+}
+var run_cut_handoff = {
+  describe_handoff,
+  handoff_schema,
+  is_complete_handoff,
+  load_handoff,
+  parse_handoff,
+  read_handoff_file
+};
+
+// scripts/run/run-cut.ts
+var CUT_PREFIX = "josh-run-cut-";
+var { PRE_GATE_PHASE: PRE_GATE_PHASE2, IMPLEMENTATION_PHASE: IMPLEMENTATION_PHASE2, SETUP_PHASE: SETUP_PHASE2 } = agent_role_profile;
+var IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD;
+var CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS;
+var CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
+var GIT_READ_TIMEOUT_MS = 5e3;
+var WORKTREE_DIRECTORY_INDEX = 0;
+var COMMON_DIRECTORY_INDEX = 1;
+var END_COMMAND = "pnpm josh run:cut --end";
+var READ_COMMAND = "pnpm josh run:cut --json";
+var MAX_HANDOFF_BYTES = 8192;
+var NONE_READ = { kind: "none" };
+var UNREADABLE_READ2 = { kind: "unreadable" };
+var run_cut_schema = z4.object({
+  invocation: z4.string(),
+  issue: z4.string(),
+  branch: z4.string(),
+  phase: z4.string(),
+  cut_at: z4.string(),
+  is_handed_off: z4.boolean().optional(),
+  handoff: run_cut_handoff.handoff_schema.optional()
+});
+function cut_path(git_directory) {
+  return stamp_file.stamp_path(CUT_PREFIX, git_directory);
+}
+var { worktree_directory: worktree_directory2 } = run_hold;
+function invocation_for(issue) {
+  return lane_child_invocation.child_invocation(issue);
+}
+function parse_cut(raw) {
+  try {
+    const parsed = run_cut_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_expired(cut, now) {
+  const started = Date.parse(cut.cut_at);
+  if (Number.isNaN(started)) return true;
+  return now.getTime() - started > CUT_MAX_AGE_MS;
+}
+function classify2(raw, now) {
+  if (raw === void 0) return NONE_READ;
+  const cut = parse_cut(raw);
+  if (cut === void 0) return UNREADABLE_READ2;
+  return { kind: is_expired(cut, now) ? "expired" : "carried", cut };
+}
+function read_cut(target, now = /* @__PURE__ */ new Date()) {
+  return classify2(stamp_file.read_stamp_text(target), now);
+}
+function git_directories_sync() {
+  try {
+    const output = execFileSync(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      // git's own diagnostics are discarded: a checkout it cannot describe is already the
+      // `undefined` below, and a hook that let `fatal: not a git repository` through would print it
+      // in front of a tool call that is about to be allowed.
+      // A `PreToolUse` hook holds the tool call while it runs, so the read is bounded rather than
+      // left to whatever git does.
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: GIT_READ_TIMEOUT_MS }
+    );
+    return output.split("\n").filter((line) => line !== "");
+  } catch {
+    return [];
+  }
+}
+function worktree_git_directory_sync() {
+  return git_directories_sync()[WORKTREE_DIRECTORY_INDEX];
+}
+function common_git_directory_sync() {
+  return git_directories_sync()[COMMON_DIRECTORY_INDEX];
+}
+function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
+  if (directory === void 0) return void 0;
+  const read2 = read_cut(cut_path(directory), now);
+  return read2.kind === "carried" ? read2.cut : void 0;
+}
+function fresh_cut(spec, now) {
+  return {
+    invocation: invocation_for(spec.issue),
+    issue: spec.issue,
+    branch: spec.branch,
+    phase: spec.phase,
+    cut_at: now.toISOString(),
+    is_handed_off: true,
+    handoff: spec.handoff
+  };
+}
+function resumes_into_implementation(phase) {
+  return phase === SETUP_PHASE2 || phase === IMPLEMENTATION_PHASE2;
+}
+function within_handoff_bound(cut) {
+  return Buffer.byteLength(JSON.stringify(cut), "utf8") <= MAX_HANDOFF_BYTES;
+}
+function record_within_bound(spec, now = /* @__PURE__ */ new Date()) {
+  return within_handoff_bound(fresh_cut(spec, now));
+}
+function begin_cut(target, spec, now = /* @__PURE__ */ new Date()) {
+  const cut = fresh_cut(spec, now);
+  if (!within_handoff_bound(cut)) return void 0;
+  return stamp_file.create_stamp(target, cut) ? cut : void 0;
+}
+function is_declared_cut(cut, issue) {
+  return cut.is_handed_off === true && cut.invocation === invocation_for(issue);
+}
+function matches_state(cut, request) {
+  return cut.branch === request.current_branch && cut.issue === request.issue && request.is_dirty && request.is_held;
+}
+function is_adopted_cut(cut, issue) {
+  return cut.is_handed_off === false && cut.invocation === invocation_for(issue);
+}
+function has_required_handoff(cut) {
+  return !resumes_into_implementation(cut.phase) || run_cut_handoff.is_complete_handoff(cut.handoff);
+}
+function classify_resume(cut, request) {
+  if (is_adopted_cut(cut, request.issue)) return "handed-off";
+  if (!is_declared_cut(cut, request.issue) || !matches_state(cut, request)) return "stale";
+  return has_required_handoff(cut) ? "resume" : "incomplete";
+}
+function adopt_cut(target, cut) {
+  const next = { ...cut, is_handed_off: false };
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, next) ? next : void 0;
+}
+function end_cut(target) {
+  stamp_file.remove_stamp(target);
+}
+function tree_is_held(directory) {
+  if (directory === void 0) return false;
+  const read2 = run_hold.read_hold(run_hold.hold_path(directory));
+  return read2.kind === "held" || read2.kind === "stale";
+}
+async function current_state() {
+  const branch2 = await git_command.branch();
+  const is_dirty = await run_hold.is_tree_dirty();
+  const directory = await worktree_directory2();
+  return { branch: branch2, is_dirty, is_held: tree_is_held(directory) };
+}
+function describe_cut(cut) {
+  return `${cut.invocation} cut at ${cut.cut_at} on ${cut.branch} (${cut.phase})`;
+}
+function busy_message(cut) {
+  return `Another process already resumed this cut \u2014 ${describe_cut(cut)}. Nothing was resumed here; a double launch was detected.`;
+}
+function handed_off_message(cut) {
+  return `This cut was already handed off to a successor \u2014 ${describe_cut(cut)}. Nothing was resumed here; the run is being carried on by the process that adopted it, so this one has nothing to do.`;
+}
+function stale_message2(cut) {
+  return `This cut does not match the current tree \u2014 ${describe_cut(cut)}. Resume failed; verify the branch and the uncommitted work, then clear it with \`${END_COMMAND}\` if the run is over.`;
+}
+function incomplete_message(cut) {
+  return `This cut carries no instruction to resume on \u2014 ${describe_cut(cut)}. Resume was refused rather than continuing without it; recover the run's instruction and work state before implementing, and clear the record with \`${END_COMMAND}\` if the run is over.`;
+}
+function unreadable_message2() {
+  return `A cut record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it. Read it with \`${READ_COMMAND}\`.`;
+}
+function unknown_message2() {
+  return "This working tree\u2019s git directory could not be read, so no cut record was acted on.";
+}
+var run_cut = {
+  CUT_MAX_AGE_HOURS,
+  CUT_MAX_AGE_MS,
+  END_COMMAND,
+  IMPLEMENTATION_CONTEXT_THRESHOLD,
+  IMPLEMENTATION_PHASE: IMPLEMENTATION_PHASE2,
+  MAX_HANDOFF_BYTES,
+  PRE_GATE_PHASE: PRE_GATE_PHASE2,
+  SETUP_PHASE: SETUP_PHASE2,
+  adopt_cut,
+  begin_cut,
+  busy_message,
+  carried_cut_sync,
+  classify: classify2,
+  classify_resume,
+  common_git_directory_sync,
+  current_state,
+  cut_path,
+  describe_cut,
+  end_cut,
+  fresh_cut,
+  handed_off_message,
+  incomplete_message,
+  invocation_for,
+  is_expired,
+  read_cut,
+  record_within_bound,
+  resumes_into_implementation,
+  stale_message: stale_message2,
+  unknown_message: unknown_message2,
+  unreadable_message: unreadable_message2,
+  within_handoff_bound,
+  worktree_directory: worktree_directory2,
+  worktree_git_directory_sync
+};
+
+// scripts/git/issue-labels.ts
+var IN_PROGRESS_LABEL = "in-progress";
+var NEEDS_DECISION_LABEL = "needs-decision";
+var NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
+var ALREADY_DONE_LABEL = "already-done";
+function has_any_label(labels, wanted) {
+  return (labels ?? []).some((label) => wanted.has(label.name.toLowerCase()));
+}
+
+// scripts/rules/shell-segments.ts
+var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
+function segments_of(command) {
+  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
+}
+function is_josh_command(segment, names) {
+  const named = time_shell.josh_command_of(segment);
+  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
+  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
+}
+var shell_segments = {
+  SEGMENT_SEPARATOR,
+  is_josh_command,
+  segments_of
+};
+
+// scripts/rules/lane-park.ts
+var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
+var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
+function is_confirmation_notify(command) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
+  );
+}
+var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
+function mentions_confirmation_notify(text) {
+  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
+}
+function is_unparked_stop(command, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  if (!is_confirmation_notify(command)) return false;
+  return is_lane_child;
+}
+var APPLIES_NEEDS_DECISION = new RegExp(
+  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
+  "u"
+);
+function records_the_park(command) {
+  return APPLIES_NEEDS_DECISION.test(command);
+}
+var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
+var lane_park = {
+  LANE_PARK_REASON,
+  is_confirmation_notify,
+  is_unparked_stop,
+  mentions_confirmation_notify,
+  records_the_park
+};
+
+// scripts/run/run-event-stream.ts
+import { z as z5 } from "zod";
+var EVENT_PREFIX = "josh-run-events-";
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 500;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR = "\n";
+var EVENT_KIND = {
+  PLAN: "plan",
+  CHILD_LAUNCH: "child-launch",
+  MERGE: "merge",
+  PARK: "park",
+  OUTAGE: "outage",
+  CUT: "cut",
+  // The backlog emptied while nothing of the run's own was in flight — the drain
+  // (joshuafolkken/kit#2335). It marks the position at which the end-of-run retrospective is owed,
+  // *before* the idle watch opens, so `run:step` fires the retrospective at the drain rather than after
+  // the watch runs its course. It is not itself a stop: the run watches on once the retrospective has
+  // run, and the real `STOP` follows when the watch expires.
+  DRAIN: "drain",
+  STOP: "stop",
+  PR_OPENED: "pr-opened",
+  REVIEW_ROUND: "review-round",
+  // The end-of-run retrospective's result, recorded when the run marks the retrospective done
+  // (joshuafolkken/kit#2342). A retrospective that files zero improvements and one that never ran look
+  // the same from outside — no new Issue either way — so the result is put on the stream the report is
+  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
+  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
+  // what it found are one action rather than two the run could do only one of.
+  RETROSPECTIVE: "retrospective",
+  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
+  // while (joshuafolkken/kit#2359). Emitted once per stall episode by the stop-time detector, it is
+  // both the dedup marker — `emit_once` refuses a second while it is the newest event — and the line a
+  // terminal reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
+  // stalled is pointed straight at dispatching the work rather than left waiting.
+  STALL: "stall",
+  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
+  // is watching (joshuafolkken/kit#2375). Emitted once per strand episode by the stop-time detector,
+  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
+  // than once, and a terminal reader following the stream sees the line. The strand is the step before
+  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
+  STRANDED: "stranded",
+  // One `josh ship` stage starting, succeeding or failing (joshuafolkken/kit#2426). It is a trace of the
+  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
+  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
+  // — so it is one of the `TRACE_KINDS` the last-event read skips.
+  SHIP_STAGE: "ship-stage",
+  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints
+  // (joshuafolkken/kit#2437). Printed only to the watcher's own output, a headless successor's heartbeat
+  // was buried in its log after a cut; on the stream it reaches the attached session's relay. It says
+  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
+  HEARTBEAT: "heartbeat",
+  // The post-implementation region handed to a detached `josh ship --detach` supervisor
+  // (joshuafolkken/kit#2428). Unlike a stage trace it is a position: the agent has ended and the
+  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
+  SHIP_LAUNCH: "ship-launch",
+  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
+  // (joshuafolkken/kit#2428). The position that hands control back: `run:step` prints the command that
+  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
+  SHIP_STOP: "ship-stop"
+};
+var EVENT_KINDS = Object.values(EVENT_KIND);
+var TRACE_KINDS = /* @__PURE__ */ new Set([EVENT_KIND.SHIP_STAGE, EVENT_KIND.HEARTBEAT]);
+var event_schema = z5.object({
+  pos: z5.number(),
+  at: z5.string(),
+  kind: z5.string(),
+  text: z5.string()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository) {
+  return stamp_file.stamp_path(EVENT_PREFIX, repository, EVENT_SUFFIX);
+}
+function is_present(event) {
+  return event !== void 0;
+}
+function parse_line(line) {
+  try {
+    return event_schema.safeParse(JSON.parse(line)).data;
+  } catch {
+    return void 0;
+  }
+}
+function read_events(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
+}
+function last_position(events) {
+  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
+}
+function serialize(events) {
+  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
+}
+function append(target, kind, text, at) {
+  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
+  const existing = read_events(target);
+  const position = last_position(existing) + POSITION_INCREMENT;
+  const bounded = [...existing, { pos: position, at, kind, text }].slice(-EVENT_CAP);
+  stamp_file.write_text_stamp(target, serialize(bounded));
+  return { appended: true, position };
+}
+function read_from(target, position) {
+  const events = read_events(target);
+  return {
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
+  };
+}
+function read_last(target) {
+  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
+}
+var FIELD_SEPARATOR = " \xB7 ";
+function format_event(event) {
+  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
+}
+var run_event_stream = {
+  EVENT_CAP,
+  EVENT_KIND,
+  EVENT_KINDS,
+  EVENT_PREFIX,
+  EVENT_SUFFIX,
+  TRACE_KINDS,
+  append,
+  format_event,
+  is_event_kind,
+  read_events,
+  read_from,
+  read_last,
+  target_of
+};
+
+// scripts/discovery/repo-discovery.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import path from "node:path";
+
+// scripts/discovery/repo-origin.ts
+var GITHUB_HOST = "github.com";
+var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
+var GIT_SUFFIX = ".git";
+var PATH_SEPARATOR2 = "/";
+var USER_SEPARATOR = "@";
+var HOST_SEPARATOR = ":";
+var OWNER_INDEX = 0;
+var REPO_INDEX = 1;
+var REPO_PATH_SEGMENTS = 2;
+var NOT_FOUND = -1;
+var SECTION_PREFIX = "[";
+var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
+var URL_KEY = "url";
+function is_github_hostname(host) {
+  return host.toLowerCase() === GITHUB_HOST;
+}
+function is_github_ssh_host(host) {
+  const normalized = host.toLowerCase();
+  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
+}
+function strip_git_suffix(name) {
+  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
+}
+function to_identity(repository_path) {
+  const segments = repository_path.split(PATH_SEPARATOR2).filter((segment) => segment !== "");
+  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
+  const owner = segments[OWNER_INDEX] ?? "";
+  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
+  return repo === "" ? void 0 : { owner, repo };
+}
+function parse_scp_like(url) {
+  const user_end = url.indexOf(USER_SEPARATOR);
+  const authority = user_end === NOT_FOUND ? url : url.slice(user_end + 1);
+  const host_end = authority.indexOf(HOST_SEPARATOR);
+  if (host_end === NOT_FOUND) return void 0;
+  if (!is_github_ssh_host(authority.slice(0, host_end))) return void 0;
+  return to_identity(authority.slice(host_end + 1));
+}
+function parse_url_like(url) {
+  try {
+    const parsed = new URL(url);
+    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parse_origin_url(url) {
+  const trimmed2 = url.trim();
+  if (trimmed2 === "") return void 0;
+  return parse_url_like(trimmed2) ?? parse_scp_like(trimmed2);
+}
+function is_section_header(line) {
+  return line.startsWith(SECTION_PREFIX);
+}
+function origin_section_lines(lines) {
+  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
+  if (start === NOT_FOUND) return [];
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => is_section_header(line));
+  return end === NOT_FOUND ? rest : rest.slice(0, end);
+}
+function entry_value(line, key) {
+  const separator = line.indexOf("=");
+  if (separator === NOT_FOUND) return void 0;
+  if (line.slice(0, separator).trim() !== key) return void 0;
+  return line.slice(separator + 1).trim();
+}
+function parse_origin_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return origin_section_lines(lines).map((line) => entry_value(line, URL_KEY)).find((url) => url !== void 0);
+}
+function format_identity(identity) {
+  return `${identity.owner}${PATH_SEPARATOR2}${identity.repo}`.toLowerCase();
+}
+var repo_origin = {
+  GITHUB_HOST,
+  is_github_hostname,
+  is_github_ssh_host,
+  parse_origin_from_config,
+  parse_origin_url,
+  format_identity
+};
+
+// scripts/discovery/repo-map-logic.ts
+var OVERRIDE_ENTRY_SEPARATOR = ",";
+var OVERRIDE_PAIR_SEPARATOR = "=";
+var OVERRIDE_PAIR_PARTS = 2;
+var KEY_INDEX = 0;
+var PATH_INDEX = 1;
+function is_same_owner(identity, current_owner2) {
+  return identity.owner.toLowerCase() === current_owner2.toLowerCase();
+}
+function add_entry(target, origin_url, repository_path, current_owner2) {
+  if (origin_url === void 0) return;
+  const identity = repo_origin.parse_origin_url(origin_url);
+  if (identity === void 0 || !is_same_owner(identity, current_owner2)) return;
+  target.set(repo_origin.format_identity(identity), repository_path);
+}
+function parse_override_entry(entry) {
+  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
+  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
+  const key = parts[KEY_INDEX] ?? "";
+  const repository_path = parts[PATH_INDEX] ?? "";
+  if (repository_path === "") return void 0;
+  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key}` };
+}
+function parse_overrides(raw) {
+  if (raw === void 0) return [];
+  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
+}
+function build_repository_map(discovered, current_owner2, override_value2) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner2);
+  for (const entry of parse_overrides(override_value2)) {
+    add_entry(result, entry.origin_url, entry.path, current_owner2);
+  }
+  return result;
+}
+var repo_map_logic = {
+  is_same_owner,
+  parse_overrides,
+  build_repository_map
+};
+
+// scripts/discovery/repo-discovery.ts
+var GIT_DIRECTORY = ".git";
+var GIT_CONFIG = "config";
+var GITDIR_PREFIX = "gitdir:";
+var COMMON_DIRECTORY_FILE = "commondir";
+var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
+function resolve_common_directory(git_directory) {
+  const pointer = path.join(git_directory, COMMON_DIRECTORY_FILE);
+  if (!existsSync(pointer)) return git_directory;
+  try {
+    return path.resolve(git_directory, readFileSync2(pointer, "utf8").trim());
+  } catch {
+    return git_directory;
+  }
+}
+function follow_git_file(repository_path, git_file) {
+  const pointer = readFileSync2(git_file, "utf8").trim();
+  if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
+  return path.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
+}
+function resolve_git_directory(repository_path) {
+  const candidate = path.join(repository_path, GIT_DIRECTORY);
+  if (!existsSync(candidate)) return void 0;
+  try {
+    if (statSync(candidate).isDirectory()) return candidate;
+    const linked = follow_git_file(repository_path, candidate);
+    return linked === void 0 ? void 0 : resolve_common_directory(linked);
+  } catch {
+    return void 0;
+  }
+}
+function read_origin_url(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0) return void 0;
+  try {
+    return repo_origin.parse_origin_from_config(
+      readFileSync2(path.join(git_directory, GIT_CONFIG), "utf8")
+    );
+  } catch {
+    return void 0;
+  }
+}
+function sibling_directories(parent) {
+  try {
+    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function scan_siblings(parent) {
+  return sibling_directories(parent).map((repository_path) => ({
+    path: repository_path,
+    origin_url: read_origin_url(repository_path)
+  }));
+}
+function resolve_current_owner(repository_path) {
+  const origin_url = read_origin_url(repository_path);
+  if (origin_url === void 0) return void 0;
+  return repo_origin.parse_origin_url(origin_url)?.owner;
+}
+function main_worktree(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0) return repository_path;
+  if (path.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
+  return path.dirname(git_directory);
+}
+function discover_repositories(repository_path, environment2 = process.env) {
+  const main2 = main_worktree(repository_path);
+  const current_owner2 = resolve_current_owner(main2);
+  if (current_owner2 === void 0) return /* @__PURE__ */ new Map();
+  return repo_map_logic.build_repository_map(
+    scan_siblings(path.dirname(main2)),
+    current_owner2,
+    environment2[OVERRIDE_ENV_KEY]
+  );
+}
+var repo_discovery = {
+  OVERRIDE_ENV_KEY,
+  main_worktree,
+  read_origin_url,
+  resolve_current_owner,
+  scan_siblings,
+  discover_repositories
+};
+
+// scripts/discovery/repo-party.ts
+var FIRST_PARTY = "first-party";
+var THIRD_PARTY = "third-party";
+var UNKNOWN = "unknown";
+function classify3(session_owner, target) {
+  if (session_owner === void 0 || target === void 0) return UNKNOWN;
+  return session_owner.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
+}
+function target_owner(owner_repo) {
+  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
+}
+function current_owner(repository_path = process.cwd()) {
+  return repo_discovery.resolve_current_owner(repository_path);
+}
+var repo_party = { FIRST_PARTY, THIRD_PARTY, UNKNOWN, classify: classify3, current_owner, target_owner };
+
+// scripts/josh/process-identity.ts
+import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync as readFileSync3, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import path2 from "node:path";
+var PS_COMMAND = "/bin/ps";
+var FORMAT_FLAG = "-o";
+var START_TIME_FORMAT = "lstart=";
+var PID_FLAG = "-p";
+var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
+var PROBE_TIMEOUT_MS = 2e3;
+var LIVENESS_SIGNAL = 0;
+var LOWEST_REAL_PID = 1;
+var PROC_START_FIELD_INDEX = 19;
+var BEACON_SCHEME = "socket:";
+var BEACON_SUFFIX = ".sock";
+var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
+var BEACON_ID_LENGTH = 36;
+var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
+var WINDOWS_PLATFORM = "win32";
+var SOCKET_PROBE_SOURCE = "const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(0));socket.once('error',()=>process.exit(1));socket.setTimeout(1000,()=>process.exit(1));";
+var beacons = /* @__PURE__ */ new Map();
+var exit_cleanup = { is_registered: false };
+function is_live_pid(pid) {
+  if (pid < LOWEST_REAL_PID) return false;
+  try {
+    process.kill(pid, LIVENESS_SIGNAL);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function read_proc_start(pid) {
+  try {
+    const stat = readFileSync3(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
+    const start = fields[PROC_START_FIELD_INDEX];
+    return start === void 0 ? void 0 : `proc:${start}`;
+  } catch {
+    return void 0;
+  }
+}
+function read_ps_start(pid) {
+  try {
+    const printed = execFileSync2(
+      PS_COMMAND,
+      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
+      {
+        encoding: "utf8",
+        timeout: PROBE_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: PROBE_ENVIRONMENT
+      }
+    ).trim();
+    return printed.length > 0 ? printed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+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 = path2.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
+  const token = `${BEACON_SCHEME}${target}`;
+  const server = try_bind_beacon(bind, target);
+  if (server === void 0) return void 0;
+  server.unref();
+  beacons.set(token, server);
+  ensure_exit_cleanup();
+  return token;
+}
+function 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 (path2.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
+  return is_valid_beacon_name(path2.basename(target)) ? target : void 0;
+}
+function is_live_beacon(target) {
+  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
+    stdio: "ignore",
+    timeout: PROBE_TIMEOUT_MS
+  }).status === 0;
+}
+function has_matching_start(pid, recorded_start, read2) {
+  const observed = read2(pid);
+  return observed === void 0 ? void 0 : observed === recorded_start;
+}
+function matches_recorded_start(pid, recorded_start, read2) {
+  const target = beacon_target(recorded_start);
+  return target === void 0 ? has_matching_start(pid, recorded_start, read2) : is_live_beacon(target);
+}
+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, read2 = read_start) {
+  if (pid === void 0 || !is_live_pid(pid)) return false;
+  if (recorded_start === void 0) return void 0;
+  return matches_recorded_start(pid, recorded_start, read2);
+}
+function 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 = { OUTAGE_FOLD_WINDOW_MS, next_state };
+
+// scripts/backlog/backlog-budget-cli.ts
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+// scripts/git/changed-paths.ts
+function to_paths(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+}
+async function read_changed_paths(is_staged) {
+  if (is_staged) return to_paths(await git_command.diff_cached_names());
+  const tracked = to_paths(await git_command.diff_main_names());
+  const untracked = to_paths(await git_command.untracked_names());
+  return [...tracked, ...untracked];
+}
+var changed_paths = { read_changed_paths, to_paths };
+
+// scripts/josh/path-decision.ts
+var STAGED_FLAG = "--staged";
+var JSON_FLAG = "--json";
+var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
+var FAILURE_EXIT_CODE = 1;
+var MAX_LISTED_PATHS = 5;
+function has_unknown_flag(argv, known) {
+  return argv.some((argument) => !known.includes(argument));
+}
+function parse_options(argv) {
+  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
+  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
+}
+function format_path_list(paths) {
+  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
+  if (paths.length <= MAX_LISTED_PATHS) return listed;
+  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
+}
+function print_decision(key, answer, reason, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [key]: answer, reason }));
+    return;
+  }
+  console.info(answer);
+  console.error(reason);
+}
+async function run_path_decision(argv, command) {
+  const options = parse_options(argv);
+  if (options === void 0) {
+    console.error(command.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const paths = await changed_paths.read_changed_paths(options.is_staged);
+  const answer = command.decide(paths);
+  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
+  return 0;
+}
+var path_decision = {
+  format_path_list,
+  has_unknown_flag,
+  JSON_FLAG,
+  KNOWN_FLAGS,
+  MAX_LISTED_PATHS,
+  parse_options,
+  print_decision,
+  run_path_decision,
+  STAGED_FLAG
+};
+
+// scripts/backlog/backlog-budget-cli.ts
+var ARGV_OFFSET = 2;
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE2 = 1;
+var JSON_KEY = "budget";
+var USAGE = `Usage: josh backlog:budget --answer <${backlog_budget.ANSWERS.join("|")}> --started <ISO-8601> [--active <ISO-8601>, required unless the watch is off] [--merged <count>] [--running <count>] [--max <count>] [--idle <minutes>, 0 to turn the watch off] [--json]`;
+var OPTIONS = {
+  active: { type: "string" },
+  answer: { type: "string" },
+  idle: { type: "string" },
+  json: { type: "boolean" },
+  max: { type: "string" },
+  merged: { type: "string" },
+  running: { type: "string" },
+  started: { type: "string" }
+};
+function read_arguments(argv) {
+  try {
+    return parseArgs({ args: [...argv], options: OPTIONS, strict: true }).values;
+  } catch {
+    return void 0;
+  }
+}
+function text_of(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function to_answer(raw) {
+  return backlog_budget.ANSWERS.find((answer) => answer === raw);
+}
+function to_time_ms(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+var COUNT_PATTERN = /^\d+$/u;
+function to_count(raw) {
+  if (raw === void 0 || !COUNT_PATTERN.test(raw)) return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+function is_readable(raw, parsed) {
+  return raw === void 0 || parsed !== void 0;
+}
+var COUNT_NAMES = ["idle", "max", "merged", "running"];
+function counts_of(values) {
+  return {
+    idle: to_count(text_of(values.idle)),
+    max: to_count(text_of(values.max)),
+    merged: to_count(text_of(values.merged)),
+    running: to_count(text_of(values.running))
+  };
+}
+function are_counts_readable(values, counts) {
+  return COUNT_NAMES.every((name) => is_readable(text_of(values[name]), counts[name]));
+}
+var NO_IDLE_MINUTES = 0;
+function to_idle_ms(idle_minutes) {
+  if (idle_minutes === void 0) return backlog_budget.DEFAULT_IDLE_MS;
+  if (idle_minutes === NO_IDLE_MINUTES) return void 0;
+  return idle_minutes * backlog_budget.MS_PER_MINUTE;
+}
+function is_watch_readable(values) {
+  if (to_idle_ms(to_count(text_of(values.idle))) === void 0) return true;
+  return text_of(values.active) !== void 0;
+}
+function are_values_readable(values) {
+  return is_readable(text_of(values.active), to_time_ms(text_of(values.active))) && is_watch_readable(values) && are_counts_readable(values, counts_of(values));
+}
+function input_of(values, base) {
+  const counts = counts_of(values);
+  return {
+    ...base,
+    active_at_ms: to_time_ms(text_of(values.active)) ?? base.started_at_ms,
+    merged: counts.merged ?? 0,
+    running: counts.running ?? 0,
+    max_issues: counts.max,
+    idle_budget_ms: to_idle_ms(counts.idle)
+  };
+}
+function build_input(values, now_ms) {
+  const answer = to_answer(text_of(values.answer));
+  if (answer === void 0) return void 0;
+  const started_at_ms = to_time_ms(text_of(values.started));
+  if (started_at_ms === void 0) return void 0;
+  if (!are_values_readable(values)) return void 0;
+  return input_of(values, { answer, now_ms, started_at_ms });
+}
+function refuse() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE2;
+}
+function run(argv, now_ms = Date.now()) {
+  const values = read_arguments(argv);
+  if (values === void 0) return refuse();
+  const input = build_input(values, now_ms);
+  if (input === void 0) return refuse();
+  const { verdict, reason } = backlog_budget.decide(input);
+  path_decision.print_decision(JSON_KEY, verdict, reason, values.json === true);
+  return SUCCESS_EXIT_CODE;
+}
+function main(argv) {
+  process.exitCode = run(argv);
+}
+var backlog_budget_cli = {
+  JSON_KEY,
+  OPTIONS,
+  SUCCESS_EXIT_CODE,
+  USAGE,
+  build_input,
+  main,
+  read_arguments,
+  run,
+  to_answer,
+  to_count,
+  to_time_ms
+};
+if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
+
+// scripts/run/run-invocation.ts
+var BACKLOG_COMMAND = "backlogrun";
+var KNOWN_FLAGS2 = ["--max", "--idle"];
+var ONLY_FLAG = "--only";
+var ISSUE_PREFIX = "#";
+var TOKEN_SEPARATOR = " ";
+var FIRST_TOKEN = 0;
+var FIRST_ARGUMENT_INDEX = 1;
+var VALUE_OFFSET = 1;
+var FLAG_PAIR_LENGTH = 2;
+var ONLY_STEP = 1;
+var EMPTY_LENGTH2 = 0;
+var NOT_FOUND2 = -1;
+function tokens_of(invocation) {
+  return invocation.split(TOKEN_SEPARATOR).filter((token) => token.length > EMPTY_LENGTH2);
+}
+function flag_token(token, raw) {
+  const flag = KNOWN_FLAGS2.find((known) => known === token);
+  const value = backlog_budget_cli.to_count(raw);
+  if (flag === void 0 || value === void 0) return void 0;
+  return `${flag} ${String(value)}`;
+}
+function read_flag(tokens, index) {
+  const token = tokens[index] ?? "";
+  if (token === ONLY_FLAG) return { part: ONLY_FLAG, advance: ONLY_STEP };
+  const part = flag_token(token, tokens[index + VALUE_OFFSET]);
+  return part === void 0 ? void 0 : { part, advance: FLAG_PAIR_LENGTH };
+}
+function flag_tokens(tokens, start) {
+  const rendered = [];
+  let index = start;
+  while (index < tokens.length) {
+    const read2 = read_flag(tokens, index);
+    if (read2 === void 0) return void 0;
+    rendered.push(read2.part);
+    index += read2.advance;
+  }
+  return rendered;
+}
+function issue_of(token) {
+  if (!token.startsWith(ISSUE_PREFIX)) return void 0;
+  const digits = token.slice(ISSUE_PREFIX.length);
+  if (!run_issue_number.ISSUE_NUMBER_PATTERN.test(digits)) return void 0;
+  const issue = Number(digits);
+  return Number.isSafeInteger(issue) ? issue : void 0;
+}
+function take_leading_prefixed(args) {
+  const stop = args.findIndex((token) => !token.startsWith(ISSUE_PREFIX));
+  return args.slice(FIRST_TOKEN, stop === NOT_FOUND2 ? args.length : stop);
+}
+function leading_issues(tokens) {
+  const issues = [];
+  const prefixed = take_leading_prefixed(tokens.slice(FIRST_ARGUMENT_INDEX));
+  for (const token of prefixed) {
+    const issue = issue_of(token);
+    if (issue === void 0) return void 0;
+    issues.push(issue);
+  }
+  return issues;
+}
+function issue_token(issue) {
+  return `${ISSUE_PREFIX}${String(issue)}`;
+}
+function joined(command, rendered) {
+  return [command, ...rendered].join(TOKEN_SEPARATOR);
+}
+function rebuilt_backlog(tokens) {
+  const issues = leading_issues(tokens);
+  if (issues === void 0) return void 0;
+  const flags = flag_tokens(tokens, FIRST_ARGUMENT_INDEX + issues.length);
+  if (flags === void 0) return void 0;
+  return joined(BACKLOG_COMMAND, [...issues.map((issue) => issue_token(issue)), ...flags]);
+}
+function rebuild(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  return rebuilt_backlog(tokens);
+}
+function issue_numbers(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
+  const issues = leading_issues(tokens);
+  if (issues === void 0 || issues.length === EMPTY_LENGTH2) return void 0;
+  return issues;
+}
+function has_only(invocation) {
+  const tokens = tokens_of(invocation);
+  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return false;
+  return tokens.slice(FIRST_ARGUMENT_INDEX).includes(ONLY_FLAG);
+}
+var run_invocation = {
+  has_only,
+  issue_numbers,
+  rebuild
+};
+
+// scripts/run/run-carry.ts
+var CARRY_PREFIX = "josh-run-carry-";
+var REPOSITORY_DIRECTORY_INDEX = 1;
+var CARRY_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
+var CARRY_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS;
+var NO_INCREMENT2 = 0;
+var MAX_CUTS = 6;
+var END_COMMAND2 = "pnpm josh run:carry --end";
+var RESUME_COMMAND = "pnpm josh run:carry --resume";
+var READ_COMMAND2 = "pnpm josh run:carry --json";
+var OWNER_ARGUMENT = '--owner "$PPID"';
+var NONE_READ2 = { kind: "none" };
+var UNREADABLE_READ3 = { kind: "unreadable" };
+var NO_OWNER = {};
+var run_carry_schema = z6.object({
+  invocation: z6.string(),
+  started_at: z6.string(),
+  merged: z6.number(),
+  filed: z6.number(),
+  cuts: z6.number(),
+  // Defaulted, so a record written before this field existed parses with a zero streak rather than
+  // failing to read — the same backward-compatibility the optional owner fields below carry.
+  failures: z6.number().default(0),
+  // Defaulted for the same backward-compatibility as `failures` (joshuafolkken/kit#2240).
+  outages: z6.number().default(0),
+  // Optional, so a record written before the outage fold existed still parses (joshuafolkken/kit#2317).
+  last_outage_at: z6.string().optional(),
+  // Optional, so a record written by the previous shape still parses. Read as "no owner declared",
+  // which is the not-provably-live answer rather than a live one.
+  owner_pid: z6.number().optional(),
+  owner_start: z6.string().optional(),
+  is_handed_off: z6.boolean().optional(),
+  done: z6.array(z6.number()).optional(),
+  // Optional, so a record written before the retrospective existed still parses (joshuafolkken/kit#2328).
+  retrospective: z6.boolean().optional()
+});
+function carry_path(git_directory) {
+  return stamp_file.stamp_path(CARRY_PREFIX, git_directory);
+}
+async function repository_directory() {
+  const directories = await git_command.git_directories();
+  return directories[REPOSITORY_DIRECTORY_INDEX];
+}
+function parse_carry(raw) {
+  try {
+    const parsed = run_carry_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_expired2(carry, now) {
+  const started = Date.parse(carry.started_at);
+  if (Number.isNaN(started)) return true;
+  return now.getTime() - started > CARRY_MAX_AGE_MS;
+}
+function classify4(raw, now) {
+  if (raw === void 0) return NONE_READ2;
+  const carry = parse_carry(raw);
+  if (carry === void 0) return UNREADABLE_READ3;
+  return { kind: is_expired2(carry, now) ? "expired" : "carried", carry };
+}
+function read_carry(target, now = /* @__PURE__ */ new Date()) {
+  return classify4(stamp_file.read_stamp_text(target), now);
+}
+function owner_of(pid, read2 = process_identity.read_start) {
+  return { pid, start: read2(pid) };
+}
+function fresh_carry(invocation, owner, now) {
+  return {
+    invocation,
+    started_at: now.toISOString(),
+    merged: NO_INCREMENT2,
+    filed: NO_INCREMENT2,
+    cuts: NO_INCREMENT2,
+    failures: NO_INCREMENT2,
+    outages: NO_INCREMENT2,
+    owner_pid: owner.pid,
+    owner_start: owner.start
+  };
+}
+function begin_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+  const carry = fresh_carry(invocation, owner, now);
+  return stamp_file.create_stamp(target, carry) ? carry : void 0;
+}
+function replace_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+  stamp_file.remove_stamp(target);
+  return begin_carry(target, invocation, owner, now);
+}
+function adopt_carry(target, carry, owner = NO_OWNER) {
+  const next = {
+    ...carry,
+    owner_pid: owner.pid,
+    owner_start: owner.start,
+    is_handed_off: false
+  };
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, next) ? next : void 0;
+}
+function next_done(carry, done) {
+  if (done === void 0) return carry.done;
+  const current = carry.done ?? [];
+  return current.includes(done) ? current : [...current, done];
+}
+function next_retrospective(carry, change) {
+  return change.retrospective === true || carry.retrospective;
+}
+function apply_change(target, carry, change, now = /* @__PURE__ */ new Date()) {
+  const cuts = change.cuts ?? NO_INCREMENT2;
+  const streak = run_carry_streak.next_state(carry, change, now);
+  const next = {
+    ...carry,
+    merged: carry.merged + (change.merged ?? NO_INCREMENT2),
+    filed: carry.filed + (change.filed ?? NO_INCREMENT2),
+    cuts: carry.cuts + cuts,
+    failures: streak.failures,
+    outages: streak.outages,
+    last_outage_at: streak.last_outage_at,
+    done: next_done(carry, change.done),
+    retrospective: next_retrospective(carry, change),
+    // A cut declares the hand-off; any other count is the run carrying on, which spends it.
+    is_handed_off: cuts > NO_INCREMENT2
+  };
+  stamp_file.write_stamp(target, next);
+  return next;
+}
+function is_owner_live(carry) {
+  return process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false;
+}
+function is_owned_by(carry, owner) {
+  return carry.owner_pid === owner.pid && carry.owner_start === owner.start;
+}
+function is_foreign_live_owner(carry, owner) {
+  return is_owner_live(carry) && !is_owned_by(carry, owner);
+}
+function is_handed_off_to(carry, invocation) {
+  return carry.is_handed_off === true && carry.invocation === invocation;
+}
+function classify_claim(carry, request) {
+  if (is_handed_off_to(carry, request.invocation)) return "resume";
+  if (is_foreign_live_owner(carry, request.owner)) return "busy";
+  if (carry.invocation !== request.invocation) return "mismatch";
+  return request.is_adoption ? "resume" : "standing";
+}
+function is_count_refused(carry, owner) {
+  return carry.is_handed_off === true || is_foreign_live_owner(carry, owner);
+}
+function is_at_cut_cap(carry) {
+  return carry.cuts >= MAX_CUTS;
+}
+function end_carry(target) {
+  stamp_file.remove_stamp(target);
+}
+function retrospective_done_of(read2) {
+  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
+  return read2.carry.retrospective === true;
+}
+function remaining_of(carry) {
+  if (carry === void 0) return void 0;
+  const declared = run_invocation.issue_numbers(carry.invocation);
+  if (declared === void 0) return void 0;
+  const done = carry.done ?? [];
+  return declared.filter((issue) => !done.includes(issue));
+}
+function done_note(carry) {
+  const done = carry.done ?? [];
+  return done.length === 0 ? "" : `, issues ${done.join(", ")} done`;
+}
+function describe_carry(carry) {
+  return `${carry.invocation} started ${carry.started_at}; ${String(carry.merged)} merged, ${String(carry.filed)} filed, ${String(carry.failures)} failed in a row, ${String(carry.outages)} outage(s) in a row, ${String(carry.cuts)} cut(s) crossed${done_note(carry)}`;
+}
+function expired_message(carry) {
+  return `The ${String(CARRY_MAX_AGE_HOURS)}-hour whole-run bound is spent: ${describe_carry(carry)}. Clear it with \`${END_COMMAND2}\`.`;
+}
+function mismatch_message(carry, invocation) {
+  return `A different invocation is carried here \u2014 ${describe_carry(carry)}. This one is \`${invocation}\`. End the standing record with \`${END_COMMAND2}\` once you know its run is over, then begin again.`;
+}
+function busy_message2(carry) {
+  return `A live run holds this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was established. Wait for that run, or end its record with \`${END_COMMAND2}\` once you know it is over.`;
+}
+function standing_message(carry) {
+  return `A run record is standing here that no cut handed off \u2014 ${describe_carry(carry)}. Nothing was established. Carry that budget with \`${RESUME_COMMAND} "${carry.invocation}" ${OWNER_ARGUMENT}\`, or discard it with \`${END_COMMAND2}\` and begin again.`;
+}
+function count_refused_message(carry) {
+  if (carry.is_handed_off === true) {
+    return `This budget was handed off at a cut and is waiting for its successor \u2014 ${describe_carry(carry)}. Nothing was counted; the cutting session must not advance a handed-off budget.`;
+  }
+  return `A live run owns this budget \u2014 ${describe_carry(carry)}, owner pid ${String(carry.owner_pid)} still running. Nothing was counted; only its owner advances the budget.`;
+}
+function lost_message() {
+  return `Another process established a run record here first, so nothing was established. Read it with \`${READ_COMMAND2}\`.`;
+}
+function nothing_to_resume_message() {
+  return `Nothing is carried here, so there is no budget to resume. Begin one with \`pnpm josh run:carry --begin "<invocation>"\`.`;
+}
+function unreadable_message3() {
+  return `A run record is here but could not be read; clear it with \`${END_COMMAND2}\` once you know no run is using it.`;
+}
+function unknown_message3() {
+  return "This repository\u2019s git directory could not be read, so no run record was established.";
+}
+var run_carry = {
+  CARRY_MAX_AGE_HOURS,
+  CARRY_MAX_AGE_MS,
+  END_COMMAND: END_COMMAND2,
+  MAX_CUTS,
+  NO_OWNER,
+  RESUME_COMMAND,
+  adopt_carry,
+  apply_change,
+  begin_carry,
+  busy_message: busy_message2,
+  carry_path,
+  classify: classify4,
+  classify_claim,
+  count_refused_message,
+  is_at_cut_cap,
+  describe_carry,
+  end_carry,
+  expired_message,
+  mismatch_message,
+  fresh_carry,
+  is_count_refused,
+  is_expired: is_expired2,
+  is_foreign_live_owner,
+  is_owner_live,
+  lost_message,
+  nothing_to_resume_message,
+  owner_of,
+  parse_carry,
+  read_carry,
+  remaining_of,
+  replace_carry,
+  repository_directory,
+  retrospective_done_of,
+  standing_message,
+  unknown_message: unknown_message3,
+  unreadable_message: unreadable_message3
+};
+
+// scripts/lane/lane-registry.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import path3 from "node:path";
+
+// scripts/git/git-ls-remote.ts
+var LS_REMOTE_COMMAND = "ls-remote";
+var HEADS_FLAG = "--heads";
+var ORIGIN_REMOTE = "origin";
+var HEADS_REF_PREFIX = "refs/heads/";
+function ls_remote_branch_arguments(branch_name) {
+  return [LS_REMOTE_COMMAND, HEADS_FLAG, ORIGIN_REMOTE, `${HEADS_REF_PREFIX}${branch_name}`];
+}
+
+// scripts/git/git-worktree.ts
+var WORKTREE = "worktree";
+async function worktree_list() {
+  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
+}
+async function worktree_add(directory, branch_name, start_point) {
+  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
+  return await git_spawn.read([WORKTREE, ...flags, directory, start_point ?? branch_name]);
+}
+async function worktree_remove(directory) {
+  return await git_spawn.read([WORKTREE, "remove", "--force", directory]);
+}
+async function worktree_prune() {
+  return await git_spawn.read([WORKTREE, "prune"]);
+}
+async function ls_remote_branch(branch_name) {
+  return await git_spawn.read(ls_remote_branch_arguments(branch_name));
+}
+async function branch_delete(branch_name) {
+  return await git_spawn.read(["branch", "-D", branch_name]);
+}
+var git_worktree = {
+  branch_delete,
+  ls_remote_branch,
+  worktree_add,
+  worktree_list,
+  worktree_prune,
+  worktree_remove
+};
+
+// scripts/lane/lane-environment.ts
+var LANE_OUTPUT_KEY = "JOSH_LANE_OUTPUT";
+var LANE_PROVIDER_KEY = "JOSH_LANE_AGENT_PROVIDER";
+var LANE_ROLE_KEY = "JOSH_LANE_AGENT_ROLE";
+var LANE_MODEL_KEY = "JOSH_LANE_AGENT_MODEL";
+var LANE_EFFORT_KEY = "JOSH_LANE_AGENT_EFFORT";
+var ASSIGNMENT_SEPARATOR = "=";
+var EXPORT_PREFIX = "export ";
+var QUOTE_CHARACTERS = /* @__PURE__ */ new Set(['"', "'"]);
+var MIN_QUOTED_LENGTH = 2;
+var FIRST_CHARACTER_END = 1;
+var LAST_CHARACTER_START = -1;
+function strip_export(line) {
+  const trimmed2 = line.trimStart();
+  return trimmed2.startsWith(EXPORT_PREFIX) ? trimmed2.slice(EXPORT_PREFIX.length).trimStart() : trimmed2;
+}
+function is_key_line(line, key) {
+  const body = strip_export(line);
+  if (!body.startsWith(key)) return false;
+  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
+}
+function is_seed_line(line) {
+  return is_key_line(line, PORT_SEED_KEY);
+}
+function is_seat_line(line) {
+  return is_key_line(line, LANE_SEAT_KEY);
+}
+function is_output_line(line) {
+  return is_key_line(line, LANE_OUTPUT_KEY);
+}
+function split_lines(content) {
+  const trimmed2 = content.trimEnd();
+  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
+}
+function is_quoted(raw) {
+  const first = raw.slice(0, FIRST_CHARACTER_END);
+  if (!QUOTE_CHARACTERS.has(first)) return false;
+  return raw.length >= MIN_QUOTED_LENGTH && raw.endsWith(first);
+}
+function unquote(raw) {
+  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : raw;
+}
+function assignment_value(line) {
+  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
+}
+function read_assignment(content, key) {
+  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
+  return line === void 0 ? void 0 : assignment_value(line);
+}
+function read_root_seed(content) {
+  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
+}
+function read_lane_seat(content) {
+  const raw = read_assignment(content, LANE_SEAT_KEY);
+  return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
+}
+function read_lane_ports(content) {
+  const environment2 = {
+    [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
+    [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
+  };
+  return {
+    development: ports.resolve_development_port(environment2),
+    preview: ports.resolve_preview_port(environment2)
+  };
+}
+function read_lane_output(content) {
+  const line = split_lines(content).findLast((entry) => is_output_line(entry));
+  const raw = line === void 0 ? void 0 : assignment_value(line);
+  return raw === void 0 || raw.length === 0 ? void 0 : raw;
+}
+function read_lane_profile(content) {
+  return agent_role_profile.parse({
+    provider: read_assignment(content, LANE_PROVIDER_KEY),
+    role: read_assignment(content, LANE_ROLE_KEY),
+    model: read_assignment(content, LANE_MODEL_KEY),
+    effort: read_assignment(content, LANE_EFFORT_KEY)
+  });
+}
+function replace_assignment(lines, keep, assignment, key) {
+  return lines.flatMap((entry, index) => {
+    if (index === keep) return [assignment];
+    return is_key_line(entry, key) ? [] : [entry];
+  });
+}
+function upsert_assignment(content, key, value) {
+  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
+  const lines = split_lines(content);
+  const last = lines.findLastIndex((entry) => is_key_line(entry, key));
+  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
+  return `${body.join("\n")}
+`;
+}
+function lane_file_content(root_content, seat) {
+  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
+}
+function with_lane_output(content, output, profile) {
+  const recorded = upsert_assignment(content, LANE_OUTPUT_KEY, `"${output}"`);
+  if (profile === void 0) return recorded;
+  const with_provider = upsert_assignment(recorded, LANE_PROVIDER_KEY, profile.provider);
+  const with_role = upsert_assignment(with_provider, LANE_ROLE_KEY, profile.role);
+  const with_model = upsert_assignment(with_role, LANE_MODEL_KEY, profile.model);
+  return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
+}
+var lane_environment = {
+  LANE_OUTPUT_KEY,
+  LANE_PROVIDER_KEY,
+  LANE_ROLE_KEY,
+  is_output_line,
+  is_seat_line,
+  is_seed_line,
+  lane_file_content,
+  read_lane_output,
+  read_lane_profile,
+  read_lane_ports,
+  read_lane_seat,
+  read_root_seed,
+  with_lane_output
+};
+
+// scripts/lane/lane-registry.ts
+var WORKTREE_PREFIX = "worktree ";
+var BRANCH_PREFIX = "branch refs/heads/";
+var BLOCK_SEPARATOR = "\n\n";
+var ISSUE_PATTERN = /^[1-9]\d*$/u;
+function line_value(lines, prefix) {
+  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
+}
+function seat_from_content(content) {
+  const seat = lane_environment.read_lane_seat(content);
+  if (seat === void 0) return void 0;
+  const port_pair = lane_environment.read_lane_ports(content);
+  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
+}
+var EMPTY_SEAT = {
+  seat: void 0,
+  development_port: void 0,
+  preview_port: void 0
+};
+function held_seat(content) {
+  if (content === void 0) return EMPTY_SEAT;
+  return seat_from_content(content) ?? EMPTY_SEAT;
+}
+function read_environment(directory) {
+  try {
+    return readFileSync4(path3.join(directory, ENV_FILE_NAME), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function branch_issue(branch2) {
+  if (!branch2?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
+  const issue = branch2.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
+  return ISSUE_PATTERN.test(issue) ? issue : void 0;
+}
+function is_gone(directory) {
+  return !existsSync2(directory);
+}
+function build_lane(issue, branch2, directory, is_stranded) {
+  const content = is_stranded ? void 0 : read_environment(directory);
+  const held = held_seat(content);
+  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
+  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
+  return {
+    issue,
+    branch: branch2,
+    directory,
+    seat: held.seat,
+    development_port: held.development_port,
+    preview_port: held.preview_port,
+    output,
+    profile,
+    is_stranded
+  };
+}
+function is_lane_directory(root, issue, directory) {
+  return directory === lane_paths.lane_directory(root, issue);
+}
+function parse_block(block, root) {
+  const lines = block.split("\n");
+  const directory = line_value(lines, WORKTREE_PREFIX);
+  const branch2 = line_value(lines, BRANCH_PREFIX);
+  const issue = branch_issue(branch2);
+  if (directory === void 0 || branch2 === void 0 || issue === void 0) return void 0;
+  if (!is_lane_directory(root, issue, directory)) return void 0;
+  return build_lane(issue, branch2, directory, is_gone(directory));
+}
+function is_lane(lane) {
+  return lane !== void 0;
+}
+async function worktree_blocks() {
+  const listing = await git_worktree.worktree_list();
+  return listing.split(BLOCK_SEPARATOR);
+}
+async function main_repository_root() {
+  return repo_discovery.main_worktree(await git_command.repository_root());
+}
+async function list_lanes() {
+  const root = lane_paths.lane_root(await main_repository_root());
+  const blocks = await worktree_blocks();
+  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
+  return lanes.toSorted((left, right) => Number(left.issue) - Number(right.issue));
+}
+function used_seats(lanes) {
+  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
+}
+function unreadable_lanes(lanes) {
+  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
+}
+function find_lane(lanes, issue) {
+  return lanes.find((lane) => lane.issue === issue);
+}
+async function find_open_lane(issue) {
+  return find_lane(await list_lanes(), issue);
+}
+var lane_registry = {
+  find_lane,
+  find_open_lane,
+  list_lanes,
+  main_repository_root,
+  parse_block,
+  read_environment,
+  unreadable_lanes,
+  used_seats
+};
+
+// scripts/run/run-event-follow.ts
+var MS_PER_SECOND2 = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var FOLLOW_INTERVAL_MINUTES = 20;
+var FOLLOW_INTERVAL_MS = FOLLOW_INTERVAL_MINUTES * SECONDS_PER_MINUTE * MS_PER_SECOND2;
+var FOLLOW_TICK_MS = MS_PER_SECOND2;
+async function follow(ports2, position, options) {
+  const deadline = ports2.now() + options.interval_ms;
+  let read2 = ports2.read(position);
+  while (read2.events.length === 0 && ports2.now() < deadline) {
+    await ports2.sleep(options.tick_ms);
+    read2 = ports2.read(position);
+  }
+  return read2;
+}
+var run_event_follow = { FOLLOW_INTERVAL_MS, FOLLOW_TICK_MS, follow };
+
+// scripts/run/run-progress-clock.ts
+import { execaSync } from "execa";
+import { z as z7 } from "zod";
+var PROGRESS_PREFIX = "josh-run-progress-";
+var LIFE_PREFIX = "josh-run-progress-life-";
+var LOG_SUFFIX = ".log";
+var LOG_KEEP = 12;
+var MS_PER_MINUTE2 = 6e4;
+var LOG_STALE_MINUTES = 90;
+var LOG_STALE_MS = LOG_STALE_MINUTES * MS_PER_MINUTE2;
+var BLOCK_SEPARATOR2 = "\n\n";
+var GIT_TIMEOUT_MS = 5e3;
+var GIT_DIRECTORY_ARGUMENTS2 = ["rev-parse", "--absolute-git-dir"];
+var report_stamp_schema = z7.object({ reported_at: z7.string(), line: z7.string().optional() });
+function parse_stamp(raw) {
+  const parsed = report_stamp_schema.safeParse(JSON.parse(raw));
+  if (!parsed.success) return void 0;
+  const reported_at = Date.parse(parsed.data.reported_at);
+  return Number.isNaN(reported_at) ? void 0 : reported_at;
+}
+function read_last_line(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  try {
+    return report_stamp_schema.safeParse(JSON.parse(raw)).data?.line;
+  } catch {
+    return void 0;
+  }
+}
+function read_last_report(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return void 0;
+  try {
+    return parse_stamp(raw);
+  } catch {
+    return void 0;
+  }
+}
+function log_path_of(target) {
+  return `${target}${LOG_SUFFIX}`;
+}
+function is_log_stale(target, now_ms) {
+  const previous_ms = read_last_report(target);
+  return previous_ms === void 0 || now_ms - previous_ms > LOG_STALE_MS;
+}
+function recent_blocks(log_target, is_fresh) {
+  if (is_fresh) return [];
+  const raw = stamp_file.read_stamp_text(log_target);
+  if (raw === void 0) return [];
+  return raw.split(BLOCK_SEPARATOR2).map((block) => block.trimEnd()).filter((block) => block.length > 0);
+}
+function append_line(log_target, reported_at, line, is_fresh) {
+  const block = `${reported_at}
+${line}`;
+  const blocks = [...recent_blocks(log_target, is_fresh), block].slice(-LOG_KEEP);
+  stamp_file.write_text_stamp(log_target, `${blocks.join(BLOCK_SEPARATOR2)}
+`);
+}
+function mark(target, now_ms, line) {
+  const reported_at = new Date(now_ms).toISOString();
+  const kept = line ?? read_last_line(target);
+  if (line !== void 0) {
+    append_line(log_path_of(target), reported_at, line, is_log_stale(target, now_ms));
+  }
+  stamp_file.write_stamp(target, kept === void 0 ? { reported_at } : { reported_at, line: kept });
+}
+function stamp_target_of(git_directory) {
+  return stamp_file.stamp_path(PROGRESS_PREFIX, git_directory);
+}
+function life_target_of(git_directory) {
+  return stamp_file.stamp_path(LIFE_PREFIX, git_directory);
+}
+var life_schema = z7.object({ alive: z7.literal(true), pinged_at: z7.string().optional() });
+function begin_life(target) {
+  stamp_file.write_stamp(target, { alive: true, pinged_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function ping_life(target) {
+  begin_life(target);
+}
+function parse_pinged_at(raw) {
+  const parsed = life_schema.safeParse(JSON.parse(raw));
+  if (!parsed.success || parsed.data.pinged_at === void 0) return void 0;
+  const pinged_ms = Date.parse(parsed.data.pinged_at);
+  return Number.isNaN(pinged_ms) ? void 0 : pinged_ms;
+}
+function is_life_fresh(target, threshold_ms) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return false;
+  try {
+    const pinged_ms = parse_pinged_at(raw);
+    return pinged_ms !== void 0 && Date.now() - pinged_ms < threshold_ms;
+  } catch {
+    return false;
+  }
+}
+function is_life_ended(target) {
+  return stamp_file.read_stamp_text(target) === void 0;
+}
+function end_life(target) {
+  stamp_file.remove_stamp(target);
+}
+function git_directory_sync() {
+  const git_binary = git_utilities.get_git_command_for_spawn();
+  const result = execaSync(git_binary, GIT_DIRECTORY_ARGUMENTS2, {
+    reject: false,
+    timeout: GIT_TIMEOUT_MS
+  });
+  if (result.exitCode !== 0) return void 0;
+  const output = result.stdout.trim();
+  return output === "" ? void 0 : output;
+}
+function stamp_target_sync() {
+  const directory = git_directory_sync();
+  return directory === void 0 ? void 0 : stamp_target_of(directory);
+}
+function read_last_report_sync() {
+  const target = stamp_target_sync();
+  return target === void 0 ? void 0 : read_last_report(target);
+}
+var run_progress_clock = {
+  LIFE_PREFIX,
+  LOG_KEEP,
+  LOG_STALE_MS,
+  PROGRESS_PREFIX,
+  append_line,
+  begin_life,
+  end_life,
+  is_life_ended,
+  is_life_fresh,
+  life_target_of,
+  log_path_of,
+  mark,
+  parse_stamp,
+  ping_life,
+  read_last_line,
+  read_last_report,
+  read_last_report_sync,
+  stamp_target_of,
+  stamp_target_sync
+};
+
+// scripts/run/run-watcher-guard.ts
+var WATCHER_TICK_MS = 3e4;
+var TICK_MULTIPLIER = 3;
+var MS_PER_SECOND3 = 1e3;
+var NO_CUTS = 0;
+var RELAY_LIFE_PREFIX = "josh-run-relay-life-";
+var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
+var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND3;
+var RELAY_STALE_THRESHOLD_MS = run_event_follow.FOLLOW_INTERVAL_MS + STALE_THRESHOLD_MS;
+var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding`;
+var RELAY_STALE_NOTE = 'This `backlogrun` has cut, and nothing is relaying its event stream to this session \u2014 run `pnpm josh run:event --follow <position>` in the background, relay what it prints, and restart it from the `next_position` it reports each time it exits (`backlogrun-progress.md` \u2192 "The report surface belongs to the run")';
+var OK_RESULT = { kind: "ok" };
+async function has_lanes_in_flight() {
+  const all_lanes = await lane_registry.list_lanes();
+  return all_lanes.some((lane) => !lane.is_stranded);
+}
+async function check(life_target) {
+  if (!await has_lanes_in_flight()) return OK_RESULT;
+  if (run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) return OK_RESULT;
+  return { kind: "stale", note: STALE_NOTE };
+}
+function has_cut(read2) {
+  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
+  return read2.carry.cuts > NO_CUTS;
+}
+function check_relay(relay_target, read2) {
+  if (!has_cut(read2)) return OK_RESULT;
+  if (run_progress_clock.is_life_fresh(relay_target, RELAY_STALE_THRESHOLD_MS)) return OK_RESULT;
+  return { kind: "stale", note: RELAY_STALE_NOTE };
+}
+function relay_target_of(repository) {
+  return stamp_file.stamp_path(RELAY_LIFE_PREFIX, repository);
+}
+async function relay_inputs() {
+  const repository = await run_carry.repository_directory();
+  if (repository === void 0) return void 0;
+  return {
+    target: relay_target_of(repository),
+    read: run_carry.read_carry(run_carry.carry_path(repository))
+  };
+}
+async function check_relay_here() {
+  const inputs = await relay_inputs();
+  return inputs === void 0 ? OK_RESULT : check_relay(inputs.target, inputs.read);
+}
+async function ping_relay() {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository !== void 0) run_progress_clock.ping_life(relay_target_of(repository));
+  } catch {
+  }
+}
+var run_watcher_guard = {
+  RELAY_STALE_NOTE,
+  RELAY_STALE_THRESHOLD_MS,
+  STALE_NOTE,
+  STALE_THRESHOLD_MS,
+  check,
+  check_relay,
+  check_relay_here,
+  has_lanes_in_flight,
+  ping_relay,
+  relay_target_of
+};
+
+// scripts/run/run-headless.ts
+var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
+var HEADLESS_VALUE = "1";
+function environment() {
+  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
+}
+function is_headless(source = process.env) {
+  return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
+}
+function is_driving(read2) {
+  return read2?.kind === "carried" && read2.carry.is_handed_off !== true;
+}
+async function read_carry_here() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_carry.read_carry(run_carry.carry_path(repository));
+}
+async function must_keep_waiting(source = process.env) {
+  const is_candidate = is_headless(source) && lane_child_marker.marked_issue(source) === void 0;
+  if (!is_candidate || !await run_watcher_guard.has_lanes_in_flight()) return false;
+  return is_driving(await read_carry_here());
+}
+async function is_backlog_parent(source = process.env) {
+  if (lane_child_marker.marked_issue(source) !== void 0) return false;
+  return is_driving(await read_carry_here());
+}
+var run_headless = {
+  HEADLESS_ENV_KEY,
+  environment,
+  is_backlog_parent,
+  is_headless,
+  must_keep_waiting
+};
+
+// scripts/git/git-gh-api-path.ts
+var FULL_PAGE_QUERY = "?per_page=100";
+function repo_api_path(repo) {
+  return `repos/${repo ?? "{owner}/{repo}"}`;
+}
+function issues_api_path(repo) {
+  return `${repo_api_path(repo)}/issues`;
+}
+function issue_api_path(issue_number, repo) {
+  return `${issues_api_path(repo)}/${issue_number}`;
+}
+function blocked_by_api_path(issue_number, repo) {
+  return `${issue_api_path(issue_number, repo)}/dependencies/blocked_by`;
+}
+function issue_comments_api_path(issue_number, repo) {
+  return `${issue_api_path(issue_number, repo)}/comments`;
+}
+function pulls_api_path(repo) {
+  return `${repo_api_path(repo)}/pulls`;
+}
+function pull_api_path(pr_number, repo) {
+  return `${pulls_api_path(repo)}/${pr_number}`;
+}
+function pull_merge_api_path(pr_number, repo) {
+  return `${pull_api_path(pr_number, repo)}/merge`;
+}
+function pull_comments_api_path(pr_number, repo) {
+  return `${pull_api_path(pr_number, repo)}/comments`;
+}
+function pull_reviews_api_path(pr_number, repo) {
+  return `${pull_api_path(pr_number, repo)}/reviews`;
+}
+function commit_api_path(commit_sha, repo) {
+  return `${repo_api_path(repo)}/commits/${commit_sha}`;
+}
+function commit_check_runs_api_path(commit_sha, repo) {
+  return `${commit_api_path(commit_sha, repo)}/check-runs`;
+}
+function commit_status_api_path(commit_sha, repo) {
+  return `${commit_api_path(commit_sha, repo)}/status`;
+}
+function tag_reference_api_path(tag, repo) {
+  return `${repo_api_path(repo)}/git/ref/tags/${tag}`;
+}
+var git_gh_api_path = {
+  FULL_PAGE_QUERY,
+  repo_api_path,
+  tag_ref_api_path: tag_reference_api_path,
+  issues_api_path,
+  issue_api_path,
+  blocked_by_api_path,
+  issue_comments_api_path,
+  pulls_api_path,
+  pull_api_path,
+  pull_merge_api_path,
+  pull_comments_api_path,
+  pull_reviews_api_path,
+  commit_api_path,
+  commit_check_runs_api_path,
+  commit_status_api_path
+};
+
+// scripts/git/parse-json-array.ts
+var MALFORMED_JSON = /* @__PURE__ */ Symbol("malformed-json");
+function parse_json_loose(raw_json) {
+  try {
+    return JSON.parse(raw_json);
+  } catch (error) {
+    if (error instanceof SyntaxError) return MALFORMED_JSON;
+    throw error;
+  }
+}
+function parse_json_array_or_undefined(raw_json, element_schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === MALFORMED_JSON || !Array.isArray(value)) return void 0;
+  return element_schema.array().parse(value);
+}
+function read_json_listing(raw_json, element_schema) {
+  try {
+    const rows = parse_json_array_or_undefined(raw_json, element_schema);
+    return rows === void 0 ? { kind: "unreadable" } : { kind: "read", rows };
+  } catch {
+    return { kind: "unexpected_shape" };
+  }
+}
+function parse_json_array_safe(raw_json, element_schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === MALFORMED_JSON) return [];
+  return element_schema.array().parse(value);
+}
+function parse_json_object_safe(raw_json, schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === MALFORMED_JSON) return void 0;
+  return schema.parse(value);
+}
+var parse_json = {
+  parse_json_array_safe,
+  parse_json_array_or_undefined,
+  parse_json_object_safe,
+  read_json_listing
+};
+
+// scripts/git/git-gh-exec.ts
+import { execa as execa4, execaSync as execaSync2 } from "execa";
+
+// scripts/git/git-gh-check.ts
+import { execa as execa3 } from "execa";
+var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
+var gh_check = {};
+async function run_gh_check() {
+  try {
+    await execa3("gh", ["--version"]);
+  } catch {
+    delete gh_check.promise;
+    throw new Error(GH_NOT_INSTALLED_MSG);
+  }
+}
+async function check_gh_installed() {
+  gh_check.promise ??= run_gh_check();
+  await gh_check.promise;
+}
+
+// scripts/git/git-gh-failure.ts
+import { z as z8 } from "zod";
+var error_document_schema = z8.object({ status: z8.union([z8.string(), z8.number()]).optional() }).catch({});
+var GH_FAILURE_FIELD = "gh_failure";
+function has_gh_failure(error) {
+  return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
+}
+function parse_response_status(stdout) {
+  const document = parse_json.parse_json_object_safe(stdout, error_document_schema);
+  if (document?.status === void 0) return void 0;
+  const status2 = Number(document.status);
+  return Number.isSafeInteger(status2) ? status2 : void 0;
+}
+function classify_stdout(stdout) {
+  return { status: parse_response_status(stdout) };
+}
+function attach(error, failure) {
+  Object.defineProperty(error, GH_FAILURE_FIELD, {
+    value: failure,
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+function failure_of(error) {
+  return has_gh_failure(error) ? error.gh_failure : void 0;
+}
+var gh_failure = { attach, classify_stdout, failure_of, parse_response_status };
+
+// scripts/git/git-gh-exec.ts
+var BODY_FROM_STDIN = "-";
+var GH_REQUEST_TIMEOUT_MS = 6e4;
+function to_timeout_option(timeout_ms) {
+  return { timeout: timeout_ms ?? GH_REQUEST_TIMEOUT_MS };
+}
+function direct_environment() {
+  const removed = agent_session_environment.removed_proxy_environment();
+  return Object.keys(removed).length > 0 ? { env: removed } : {};
+}
+function to_spawn_options(timeout_ms) {
+  return { ...to_timeout_option(timeout_ms), ...direct_environment() };
+}
+var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
+function has_stderr_field(error) {
+  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
+}
+function has_stdout_field(error) {
+  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
+}
+function to_timeout_prefix(error) {
+  return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
+}
+function to_error_message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function to_gh_error(error) {
+  const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
+  const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
+  const summary = stderr.length > 0 ? stderr : to_error_message(error);
+  const detail = stdout.length > 0 ? `${summary}
+${stdout}` : summary;
+  return gh_failure.attach(
+    new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
+    gh_failure.classify_stdout(stdout)
+  );
+}
+async function exec_gh_command(arguments_, timeout_ms) {
+  await check_gh_installed();
+  try {
+    const { stdout } = await execa4("gh", arguments_, to_spawn_options(timeout_ms));
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+async function exec_gh_command_with_stdin(input) {
+  await check_gh_installed();
+  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms) };
+  try {
+    const { stdout } = await execa4("gh", input.args, options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
+function parse_status_line(output) {
+  const { status: status2 } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
+  return status2 === void 0 ? void 0 : Number(status2);
+}
+async function exec_gh_api_status(path4, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  try {
+    await check_gh_installed();
+    const { stdout } = await execa4("gh", ["api", "--include", "--silent", path4], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+  }
+}
+var METHOD_FLAG = "--method";
+var INPUT_FLAG = "--input";
+var PAGINATE_FLAG = "--paginate";
+var SLURP_FLAG = "--slurp";
+var JQ_FLAG = "--jq";
+function optional_flag(flag, value) {
+  return value === void 0 ? [] : [flag, value];
+}
+function to_gh_api_args(request) {
+  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
+  const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
+  const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
+  return [
+    "api",
+    request.path,
+    ...optional_flag(METHOD_FLAG, request.method),
+    ...body_args,
+    ...paginate_args,
+    ...slurp_args,
+    ...optional_flag(JQ_FLAG, request.jq_filter)
+  ];
+}
+async function exec_gh_api(request) {
+  const args = to_gh_api_args(request);
+  if (request.body === void 0) return await exec_gh_command(args, request.timeout_ms);
+  return await exec_gh_command_with_stdin({
+    args,
+    stdin_body: request.body,
+    timeout_ms: request.timeout_ms
+  });
+}
+function exec_gh_api_sync(request) {
+  const body_option = request.body === void 0 ? {} : { input: request.body };
+  const options = { ...body_option, ...to_spawn_options(request.timeout_ms) };
+  try {
+    const { stdout } = execaSync2("gh", to_gh_api_args(request), options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+var git_gh_exec = {
+  direct_environment,
+  exec_gh_command,
+  exec_gh_command_with_stdin,
+  exec_gh_api,
+  exec_gh_api_sync,
+  exec_gh_api_status,
+  parse_status_line
+};
+
+export {
+  bash_triggers,
+  run_progress_clock,
+  shell_segments,
+  tail_commands,
+  filing_cap,
+  CONTEXT_CUT_THRESHOLD,
+  RECENT_REQUEST_WINDOW,
+  agent_session_environment,
+  agent_role_profile,
+  backlog_budget,
+  git_command,
+  run_hold,
+  run_cut,
+  IN_PROGRESS_LABEL,
+  NEEDS_DECISION_LABEL,
+  NEEDS_HUMAN_REVIEW_LABEL,
+  ALREADY_DONE_LABEL,
+  has_any_label,
+  lane_park,
+  run_event_stream,
+  repo_party,
+  process_identity,
+  run_carry,
+  lane_registry,
+  run_watcher_guard,
+  run_headless,
+  FULL_PAGE_QUERY,
+  git_gh_api_path,
+  parse_json_array_or_undefined,
+  read_json_listing,
+  parse_json_object_safe,
+  gh_failure,
+  has_stderr_field,
+  git_gh_exec
+};