@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/hooks/chunk-APUO6U4J.js

@@ -1,2451 +0,0 @@
-import {
-  GIT_TIMEOUT_MS,
-  PLATFORM_TEMP_ROOT,
-  PROBE_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS,
-  stamp_file
-} from "./chunk-DGT54IH5.js";
-
-// scripts/lib/json-value.ts
-function parse_or_undefined(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
-function parse_with(text, schema) {
-  const value = parse_or_undefined(text);
-  if (value === void 0) return void 0;
-  const parsed = schema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
-}
-function is_record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var json_value = { parse_or_undefined, parse_with, is_record };
-
-// scripts/git/constants.ts
-import { platform } from "node:os";
-var GIT_COMMAND_UNIX = "/usr/bin/git";
-var PORCELAIN_FLAG = "--porcelain";
-var UNTRACKED_FILES_FLAG = "--untracked-files=all";
-var GIT_BINARY_KEY = "JOSH_GIT_BINARY";
-function get_git_command() {
-  if (platform() === "win32") return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
-  return GIT_COMMAND_UNIX;
-}
-function get_git_command_for_spawn() {
-  const binary = process.env[GIT_BINARY_KEY];
-  if (binary !== void 0 && binary !== "") return binary;
-  if (platform() === "win32") return String.raw`C:\Program Files\Git\cmd\git.exe`;
-  return GIT_COMMAND_UNIX;
-}
-var git_utilities = {
-  get_git_command,
-  get_git_command_for_spawn
-};
-
-// scripts/git/git-spawn.ts
-import { execa as execa3 } from "execa";
-
-// scripts/git/git-execa-error.ts
-function get_exit_code(error) {
-  if (typeof error !== "object" || error === null || !("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;
-}
-var TIMEOUT_EXIT_CODE = "timeout";
-function create_spawn_error(command, exit_code) {
-  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
-  const error_message = `git ${command} exited with code ${exit_code_string}`;
-  return new Error(error_message, { cause: { exit_code: exit_code_string } });
-}
-
-// scripts/git/git-push-transport.ts
-import { execa as execa2 } from "execa";
-
-// scripts/git/git-ssh-keepalive.ts
-import { execa } from "execa";
-var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
-var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
-var SSH_LEGACY_VARIABLE = "GIT_SSH";
-var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
-var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
-var CONFIG_PROBE_ARGUMENTS = ["config", "--get", SSH_COMMAND_CONFIG_KEY];
-var PROBE_OPTIONS = { timeout: PROBE_TIMEOUT_MS };
-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_PROBE_ARGUMENTS, PROBE_OPTIONS);
-    return stdout.trim() !== "";
-  } catch (error) {
-    return has_timed_out(error);
-  }
-}
-async function to_environment() {
-  const should_keep_alive = !await has_configured_ssh_command();
-  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
-}
-var git_ssh_keepalive = {
-  to_environment
-};
-
-// scripts/git/git-push-transport.ts
-var MS_PER_SECOND = 1e3;
-var PUSH_TIMEOUT_SECONDS = 120;
-var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
-var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
-var PUSH_TIMEOUT_MESSAGE = "git push timed out";
-var PUSH_SUBCOMMAND = "push";
-async function to_push_options() {
-  return {
-    stdio: "inherit",
-    timeout: PUSH_TIMEOUT_MS,
-    env: await git_ssh_keepalive.to_environment()
-  };
-}
-async function did_push_time_out(arguments_list) {
-  const git_command_bin = git_utilities.get_git_command_for_spawn();
-  const options = await to_push_options();
-  try {
-    await execa2(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: 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
-async function read(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
-  const git_cmd = git_utilities.get_git_command_for_spawn();
-  const { stdout } = await execa3(git_cmd, arguments_, { timeout: timeout_ms });
-  return stdout.trimEnd();
-}
-var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
-var MS_PER_SECOND2 = 1e3;
-function to_budget_error(command, error, timeout_ms) {
-  if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
-  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND2));
-  return new Error(`git ${command} timed out after ${seconds}s`, {
-    cause: { exit_code: TIMEOUT_EXIT_CODE }
-  });
-}
-async function spawn_remote(arguments_, options) {
-  const git_cmd = git_utilities.get_git_command_for_spawn();
-  try {
-    const { stdout } = await execa3(git_cmd, arguments_, options);
-    return typeof stdout === "string" ? stdout.trimEnd() : "";
-  } catch (error) {
-    throw to_budget_error(arguments_[0] ?? "", error, options.timeout);
-  }
-}
-async function read_remote(arguments_, timeout_ms = REMOTE_TIMEOUT_MS) {
-  return await spawn_remote(arguments_, {
-    timeout: timeout_ms,
-    env: await git_ssh_keepalive.to_environment()
-  });
-}
-async function with_output_remote(command, arguments_list) {
-  await spawn_remote([command, ...arguments_list], {
-    stdio: "inherit",
-    timeout: REMOTE_TIMEOUT_MS,
-    env: await git_ssh_keepalive.to_environment()
-  });
-}
-async function with_output(command, arguments_list, options = {}) {
-  const { config_options = [], timeout_ms = GIT_TIMEOUT_MS } = options;
-  const git_command_bin = git_utilities.get_git_command_for_spawn();
-  const spawn_arguments = [...config_options, command, ...arguments_list];
-  try {
-    await execa3(git_command_bin, spawn_arguments, { stdio: "inherit", timeout: timeout_ms });
-  } catch (error) {
-    throw to_budget_error(command, error, timeout_ms);
-  }
-}
-var git_spawn = {
-  read,
-  read_remote,
-  with_output,
-  with_output_remote
-};
-
-// scripts/git/git-diff-reads.ts
-var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
-var NAME_ONLY_FLAG = "--name-only";
-var DEFAULT_BRANCH_FALLBACK = "main";
-var DEFAULT_BRANCH_ARGUMENTS = ["symbolic-ref", "refs/remotes/origin/HEAD"];
-function default_branch_of(output) {
-  const trimmed = output?.trim() ?? "";
-  if (!trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) return DEFAULT_BRANCH_FALLBACK;
-  return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
-}
-async function get_default_branch() {
-  try {
-    return default_branch_of(await git_spawn.read([...DEFAULT_BRANCH_ARGUMENTS]));
-  } 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
-  ]);
-}
-var git_diff_reads = {
-  DEFAULT_BRANCH_ARGUMENTS,
-  change_base,
-  change_base_commit,
-  default_branch_of,
-  default_branch_reference,
-  diff_cached_names,
-  diff_main,
-  diff_main_names,
-  diff_main_numstat,
-  get_default_branch,
-  untracked_names
-};
-
-// scripts/git/git-pre-push-hook.ts
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-var REMOTE = "origin";
-var HOOK_NAME = "pre-push";
-var PROBE_HOOK_NAME = "kit-hook-run-probe";
-var ALLOW_UNKNOWN_HOOK_NAME_FLAG = "--allow-unknown-hook-name";
-var HOOK_RUN = "run";
-var STDIN_FILE = "refs";
-var TEMPORARY_PREFIX = "kit-pre-push-";
-var ZERO_DIGIT = "0";
-async function read_remote_oid(branch2) {
-  try {
-    return await git_spawn.read([
-      "rev-parse",
-      "--verify",
-      "--quiet",
-      `refs/remotes/${REMOTE}/${branch2}`
-    ]);
-  } catch {
-    return void 0;
-  }
-}
-async function read_push_references() {
-  const [branch2, local_oid] = await Promise.all([
-    git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]),
-    git_spawn.read(["rev-parse", "HEAD"])
-  ]);
-  return { branch: branch2, local_oid, remote_oid: await read_remote_oid(branch2) };
-}
-function to_stdin_line(references) {
-  const reference = `refs/heads/${references.branch}`;
-  const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
-  return `${reference} ${references.local_oid} ${reference} ${remote_oid}
-`;
-}
-function to_hook_run_arguments(stdin_path, hook_name) {
-  return [HOOK_RUN, "--ignore-missing", `--to-stdin=${stdin_path}`, hook_name];
-}
-async function can_probe(probe_arguments) {
-  try {
-    await git_spawn.read(["hook", ...probe_arguments]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function can_run_hooks(stdin_path) {
-  const [, ...options] = to_hook_run_arguments(stdin_path, PROBE_HOOK_NAME);
-  if (await can_probe([HOOK_RUN, ALLOW_UNKNOWN_HOOK_NAME_FLAG, ...options])) return true;
-  return await can_probe([HOOK_RUN, ...options]);
-}
-async function run_with_stdin(stdin_line) {
-  const directory = await mkdtemp(path.join(tmpdir(), TEMPORARY_PREFIX));
-  const stdin_path = path.join(directory, STDIN_FILE);
-  try {
-    await writeFile(stdin_path, stdin_line);
-    if (!await can_run_hooks(stdin_path)) return false;
-    const url = await git_spawn.read(["remote", "get-url", REMOTE]);
-    await git_spawn.with_output(
-      "hook",
-      [...to_hook_run_arguments(stdin_path, HOOK_NAME), "--", REMOTE, url],
-      { timeout_ms: SUITE_TIMEOUT_MS }
-    );
-    return true;
-  } finally {
-    await rm(directory, { force: true, recursive: true });
-  }
-}
-async function run() {
-  const references = await read_push_references();
-  if (references.local_oid === references.remote_oid) return true;
-  return await run_with_stdin(to_stdin_line(references));
-}
-var git_pre_push_hook = {
-  run
-};
-
-// scripts/lib/spawn-exit.ts
-function read_spawn_stdout(result) {
-  return result.stdout ?? "";
-}
-function read_spawn_stderr(result) {
-  return result.stderr ?? "";
-}
-
-// scripts/git/git-spawn-sync.ts
-import { execaSync } from "execa";
-
-// scripts/git/git-location-environment.ts
-var GIT_LOCATION_VARIABLES = [
-  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
-  "GIT_COMMON_DIR",
-  "GIT_DIR",
-  "GIT_INDEX_FILE",
-  "GIT_NAMESPACE",
-  "GIT_OBJECT_DIRECTORY",
-  "GIT_WORK_TREE"
-];
-function location_free_environment() {
-  return Object.fromEntries(GIT_LOCATION_VARIABLES.map((name) => [name, void 0]));
-}
-function forget(name) {
-  Reflect.deleteProperty(process.env, name);
-}
-function restore_one(name, value) {
-  if (value === void 0) forget(name);
-  else process.env[name] = value;
-}
-function clear_git_location_variables() {
-  const previous = GIT_LOCATION_VARIABLES.map((name) => [name, process.env[name]]);
-  for (const [name] of previous) forget(name);
-  return () => {
-    for (const [name, value] of previous) restore_one(name, value);
-  };
-}
-var git_location_environment = { clear_git_location_variables, location_free_environment };
-
-// scripts/git/git-spawn-sync.ts
-var SUCCESS_EXIT_CODE = 0;
-var C_LOCALE = { LC_ALL: "C", LANGUAGE: "C" };
-function run2(args, options = {}) {
-  const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
-    ...options,
-    extendEnv: true,
-    reject: false,
-    timeout: options.timeout ?? GIT_TIMEOUT_MS
-  });
-  return {
-    exit_code: result.exitCode,
-    stdout: read_spawn_stdout(result),
-    stderr: read_spawn_stderr(result)
-  };
-}
-function read2(args, options = {}) {
-  const result = run2(args, options);
-  return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
-}
-function origin_url(cwd) {
-  return read2(["config", "--get", "remote.origin.url"], {
-    cwd,
-    env: git_location_environment.location_free_environment()
-  });
-}
-function toplevel(timeout = GIT_TIMEOUT_MS) {
-  return run2(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
-}
-var git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run: run2, read: read2, origin_url, toplevel };
-
-// scripts/git/git-command.ts
-async function branch() {
-  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
-}
-async function status(directory) {
-  const location = directory === void 0 ? [] : ["-C", directory];
-  return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
-}
-async function repository_root() {
-  const result = git_spawn_sync.toplevel();
-  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
-  return result.stdout.trim();
-}
-async function head_commit() {
-  return await git_spawn.read(["rev-parse", "HEAD"]);
-}
-var GIT_DIRECTORY_ARGUMENTS = [
-  "rev-parse",
-  "--absolute-git-dir",
-  "--path-format=absolute",
-  "--git-common-dir"
-];
-async function git_directories() {
-  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
-  return output.split("\n").filter((line) => line !== "");
-}
-async function diff_cached(file_path) {
-  return await git_spawn.read(["diff", "--cached", file_path]);
-}
-async function fetch_branch(branch_name) {
-  const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
-  return await git_spawn.read_remote(["fetch", "origin", refspec]);
-}
-async function merge_fast_forward(branch_name) {
-  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`], SUITE_TIMEOUT_MS);
-}
-async function fast_forward_local(branch_name) {
-  return await git_spawn.read_remote(["fetch", "origin", `${branch_name}:${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}`], {
-    timeout_ms: SUITE_TIMEOUT_MS
-  });
-}
-async function checkout_b(branch_name) {
-  return await git_spawn.read(["checkout", "-b", branch_name], SUITE_TIMEOUT_MS);
-}
-async function checkout(branch_name) {
-  return await git_spawn.read(["checkout", branch_name], SUITE_TIMEOUT_MS);
-}
-async function commit(message) {
-  await git_spawn.with_output("commit", ["-m", message], { timeout_ms: SUITE_TIMEOUT_MS });
-}
-async function delete_branch(branch_name) {
-  await git_spawn.read(["branch", "-d", branch_name]);
-}
-async function read_commit_count(revisions) {
-  const output = await git_spawn.read(["rev-list", "--count", ...revisions]);
-  const parsed = Number(output);
-  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
-  throw new Error(
-    `\`git rev-list --count ${revisions.join(" ")}\` printed \`${output}\` rather than a count`
-  );
-}
-async function commit_count_beyond(base, tip) {
-  return await read_commit_count([`${base}..${tip}`]);
-}
-async function commit_count_unpushed(branch_name) {
-  return await read_commit_count([branch_name, "--not", "--remotes"]);
-}
-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);
-}
-var NO_VERIFY_FLAG = "--no-verify";
-async function push_with_upstream(branch_name, verify_flags) {
-  await git_push_transport.push([...verify_flags, "--set-upstream", "origin", branch_name]);
-}
-async function push2() {
-  const verify_flags = await git_pre_push_hook.run() ? [NO_VERIFY_FLAG] : [];
-  try {
-    await git_push_transport.push([...verify_flags]);
-  } catch (error) {
-    if (is_upstream_not_set_error(error)) {
-      const current_branch = await branch();
-      await push_with_upstream(current_branch, verify_flags);
-      return;
-    }
-    throw error;
-  }
-}
-async function pull_fast_forward() {
-  await git_spawn.with_output_remote("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,
-  // The default branch, the change base and every reading against it are `git-diff-reads.ts`'s,
-  // re-exported here so no call site, mock or spy moved with them.
-  ...git_diff_reads,
-  fetch_branch,
-  merge_fast_forward,
-  fast_forward_local,
-  merge_branch,
-  checkout_b,
-  checkout,
-  commit,
-  commit_count_beyond,
-  commit_count_unpushed,
-  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/josh/process-identity.ts
-import { execFileSync, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { readFileSync, 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 LIVENESS_SIGNAL = 0;
-var NO_SUCH_PROCESS = "ESRCH";
-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 BEACON_LIVE_STATUS = 0;
-var BEACON_UNKNOWN_STATUS = 1;
-var BEACON_GONE_STATUS = 2;
-var SOCKET_PROBE_SOURCE = `const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(${String(BEACON_LIVE_STATUS)}));socket.once('error',(error)=>process.exit(['ECONNREFUSED','ENOENT'].includes(error.code)?${String(BEACON_GONE_STATUS)}:${String(BEACON_UNKNOWN_STATUS)}));socket.setTimeout(1000,()=>process.exit(${String(BEACON_UNKNOWN_STATUS)}));`;
-var beacons = /* @__PURE__ */ new Map();
-var exit_cleanup = { is_registered: false };
-function signal_refusal(pid) {
-  try {
-    process.kill(pid, LIVENESS_SIGNAL);
-    return void 0;
-  } catch (error) {
-    return error.code ?? NO_SUCH_PROCESS;
-  }
-}
-function is_live_pid(pid) {
-  return pid >= LOWEST_REAL_PID && signal_refusal(pid) === void 0;
-}
-function is_present_pid(pid) {
-  return pid >= LOWEST_REAL_PID && signal_refusal(pid) !== NO_SUCH_PROCESS;
-}
-function read_proc_start(pid) {
-  try {
-    const stat = readFileSync(`/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 = execFileSync(
-      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 run_socket_probe(target) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
-    stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS
-  }).status ?? void 0;
-}
-function is_live_beacon(target, probe = run_socket_probe) {
-  const status2 = probe(target);
-  if (status2 === BEACON_LIVE_STATUS) return true;
-  return status2 === BEACON_GONE_STATUS ? false : void 0;
-}
-function has_matching_start(pid, recorded_start, read3) {
-  const observed = read3(pid);
-  return observed === void 0 ? void 0 : observed === recorded_start;
-}
-function matches_recorded_start(pid, recorded_start, read3) {
-  const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read3) : is_live_beacon(target);
-}
-var own_probe = /* @__PURE__ */ new Map();
-function own_start() {
-  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
-  return own_probe.get(process.pid);
-}
-function own_fields() {
-  const start = own_start();
-  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
-}
-function is_same_process(pid, recorded_start, read3 = read_start) {
-  if (pid === void 0 || !is_live_pid(pid)) return false;
-  if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read3);
-}
-function is_present_process(pid, recorded_start, read3 = read_start) {
-  if (!is_present_pid(pid)) return false;
-  if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read3);
-}
-function is_own_process(pid, recorded_start) {
-  return pid === process.pid && recorded_start === own_start();
-}
-var process_identity = {
-  close_beacon,
-  is_live_beacon,
-  is_live_pid,
-  is_own_process,
-  is_present_pid,
-  is_present_process,
-  is_same_process,
-  open_beacon,
-  own_fields,
-  own_start,
-  read_start,
-  resolve_own_start
-};
-
-// scripts/backlog/backlog-budget-cli.ts
-import { fileURLToPath } from "node:url";
-
-// scripts/git/changed-paths.ts
-function to_paths(raw) {
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
-}
-async function 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,
-  parse_options,
-  print_decision,
-  run_path_decision
-};
-
-// scripts/lib/cli-flags.ts
-import { parseArgs } from "node:util";
-var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
-function usage_line(known_flags, command) {
-  if (known_flags.length === 0) return `Usage: josh ${command}`;
-  return `Usage: josh ${command} [${known_flags.join("] [")}]`;
-}
-function refuse_unknown_flags(argv, known_flags, command) {
-  const unknown = argv.filter((argument) => !known_flags.includes(argument));
-  if (unknown.length === 0) return void 0;
-  return `Unknown argument(s): ${unknown.join(" ")}
-${usage_line(known_flags, command)}`;
-}
-function answer_help_or_unknown(argv, known_flags, command) {
-  if (argv.some((argument) => HELP_FLAGS.has(argument))) {
-    console.info(usage_line(known_flags, command));
-    return 0;
-  }
-  const refusal = refuse_unknown_flags(argv, known_flags, command);
-  if (refusal === void 0) return void 0;
-  console.error(refusal);
-  return 1;
-}
-function parse_or_undefined2(config) {
-  try {
-    return parseArgs(config);
-  } catch {
-    return void 0;
-  }
-}
-function values_of(argv, options) {
-  return parse_or_undefined2({ args: [...argv], options })?.values;
-}
-function arguments_of(argv, options) {
-  return parse_or_undefined2({ args: [...argv], options, allowPositionals: true });
-}
-function string_of(value) {
-  return typeof value === "string" ? value : void 0;
-}
-var LONG_FLAG_PREFIX = "--";
-var SHORT_FLAG_PREFIX = "-";
-function option_name(flag) {
-  return flag.slice(LONG_FLAG_PREFIX.length);
-}
-function is_unusable_value(value) {
-  if (typeof value === "boolean" || value.length === 0) return true;
-  return value !== SHORT_FLAG_PREFIX && value.startsWith(SHORT_FLAG_PREFIX);
-}
-function given_values(argv, flag) {
-  const name = option_name(flag);
-  const given = parse_or_undefined2({
-    args: [...argv],
-    options: { [name]: { type: "string", multiple: true } },
-    strict: false,
-    allowPositionals: true
-  })?.values[name];
-  return Array.isArray(given) ? given : [];
-}
-function is_value_unusable(argv, flag) {
-  return given_values(argv, flag).some((value) => is_unusable_value(value));
-}
-function attach_one(attached, argument, flags) {
-  const previous = attached.at(-1);
-  if (previous !== void 0 && flags.includes(previous)) {
-    attached[attached.length - 1] = `${previous}=${argument}`;
-  } else attached.push(argument);
-}
-function attach_values(argv, flags) {
-  const attached = [];
-  for (const argument of argv) attach_one(attached, argument, flags);
-  return attached;
-}
-var cli_flags = {
-  attach_values,
-  usage_line,
-  refuse_unknown_flags,
-  answer_help_or_unknown,
-  parse_or_undefined: parse_or_undefined2,
-  values_of,
-  arguments_of,
-  string_of,
-  option_name,
-  given_values,
-  is_value_unusable
-};
-
-// scripts/backlog/backlog-budget.ts
-var MS_PER_MINUTE = 6e4;
-var MINUTES_PER_HOUR = 60;
-var IDLE_WAIT_HOURS = 8;
-var DEFAULT_IDLE_MINUTES = IDLE_WAIT_HOURS * MINUTES_PER_HOUR;
-var DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE;
-var OFFER_INTERVAL_SECONDS = 60;
-var MS_PER_SECOND3 = 1e3;
-var OFFER_INTERVAL_MS = OFFER_INTERVAL_SECONDS * MS_PER_SECOND3;
-var RUN_VERDICT = "run";
-var WATCH_VERDICT = "watch";
-var STOP_VERDICT = "stop";
-var TRIAGE_VERDICT = "triage";
-var ANSWERS = ["blocked", "candidates", "exhausted", "parked", "unreadable", "untriaged"];
-var BLOCKED_REASON = "Everything opted in is blocked or already running, so waiting can still change the answer. Ask again at the re-ask floor (60 s).";
-var TRIAGE_REASON = "An opted-in candidate carries neither `run:solo` nor `run:lane`, so nothing starts until it is judged. Read each issue named above, record its order and one of the two labels with a comment, then ask again.";
-var EMPTY_BACKLOG = "The backlog is empty";
-var WAITING_ON = {
-  exhausted: EMPTY_BACKLOG,
-  parked: "Nothing opted in can proceed without a person",
-  unreadable: "The backlog listing could not be read"
-};
-function waiting_on(answer) {
-  return WAITING_ON[answer] ?? EMPTY_BACKLOG;
-}
-function no_idle_watch_reason(answer) {
-  return `${waiting_on(answer)} 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 wait on \`pnpm josh lane:await\` until the running children merge (running: ${String(running)}). Then report and finish \u2014 ${reason}`;
-}
-function idle_expired_reason(answer, idle_budget_ms) {
-  return `${waiting_on(answer)}, and stayed so 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 idle_watch_reason(answer, left_ms) {
-  return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left. Release the working tree, ask again in ${String(OFFER_INTERVAL_SECONDS)} seconds, and restart the watch the moment a candidate appears.`;
-}
-function running_watch_reason(answer, running, left_ms) {
-  return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree and wait on \`pnpm josh lane:await\` until they merge \u2014 the watch is running down meanwhile.`;
-}
-function watching_reason(input, left_ms) {
-  if (input.running === 0) return idle_watch_reason(input.answer, left_ms);
-  return running_watch_reason(input.answer, 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.`;
-}
-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(input.answer));
-  const left_ms = idle_budget_ms - (input.now_ms - input.active_at_ms);
-  if (left_ms > 0) return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) };
-  return stopping(input, idle_expired_reason(input.answer, idle_budget_ms));
-}
-function is_finish(input) {
-  return input.answer === "exhausted" && max_decision(input) === void 0;
-}
-var FIXED_DECISIONS = {
-  blocked: { verdict: WATCH_VERDICT, reason: BLOCKED_REASON },
-  untriaged: { verdict: TRIAGE_VERDICT, reason: TRIAGE_REASON }
-};
-function answer_decision(input) {
-  if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
-  return FIXED_DECISIONS[input.answer] ?? idle_decision(input);
-}
-function decide(input) {
-  return max_decision(input) ?? answer_decision(input);
-}
-var backlog_budget = {
-  ANSWERS,
-  BLOCKED_REASON,
-  DEFAULT_IDLE_MINUTES,
-  DEFAULT_IDLE_MS,
-  IDLE_WAIT_HOURS,
-  MS_PER_MINUTE,
-  OFFER_INTERVAL_MS,
-  RUN_VERDICT,
-  STOP_VERDICT,
-  TRIAGE_REASON,
-  TRIAGE_VERDICT,
-  WAITING_ON,
-  WATCH_VERDICT,
-  decide,
-  draining_reason,
-  idle_expired_reason,
-  idle_watch_reason,
-  is_finish,
-  max_reached_reason,
-  no_idle_watch_reason,
-  run_reason,
-  running_watch_reason,
-  taken_by
-};
-
-// scripts/backlog/backlog-budget-cli.ts
-var ARGV_OFFSET = 2;
-var SUCCESS_EXIT_CODE2 = 0;
-var FAILURE_EXIT_CODE2 = 1;
-var JSON_KEY = "budget";
-var USAGE = `Usage: josh backlog:budget --answer <${backlog_budget.ANSWERS.join("|")}> --started <ISO-8601> [--active <ISO-8601>, required unless the watch is off] [--merged <count>] [--running <count>] [--max <count>] [--idle <minutes>, 0 to turn the watch off] [--json]`;
-var OPTIONS = {
-  active: { type: "string" },
-  answer: { type: "string" },
-  idle: { type: "string" },
-  json: { type: "boolean" },
-  max: { type: "string" },
-  merged: { type: "string" },
-  running: { type: "string" },
-  started: { type: "string" }
-};
-function read_arguments(argv) {
-  return cli_flags.values_of(argv, OPTIONS);
-}
-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(cli_flags.string_of(values.idle)),
-    max: to_count(cli_flags.string_of(values.max)),
-    merged: to_count(cli_flags.string_of(values.merged)),
-    running: to_count(cli_flags.string_of(values.running))
-  };
-}
-function are_counts_readable(values, counts) {
-  return COUNT_NAMES.every((name) => is_readable(cli_flags.string_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(cli_flags.string_of(values.idle))) === void 0) return true;
-  return cli_flags.string_of(values.active) !== void 0;
-}
-function are_values_readable(values) {
-  return is_readable(
-    cli_flags.string_of(values.active),
-    to_time_ms(cli_flags.string_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(cli_flags.string_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(cli_flags.string_of(values.answer));
-  if (answer === void 0) return void 0;
-  const started_at_ms = to_time_ms(cli_flags.string_of(values.started));
-  if (started_at_ms === void 0 || !are_values_readable(values)) return void 0;
-  return input_of(values, { answer, now_ms, started_at_ms });
-}
-function print_json(input, decision) {
-  const { verdict, reason } = decision;
-  const is_finish2 = backlog_budget.is_finish(input);
-  console.info(JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: is_finish2 }));
-}
-function refuse() {
-  console.error(USAGE);
-  return FAILURE_EXIT_CODE2;
-}
-function run3(argv, now_ms = Date.now()) {
-  const values = read_arguments(argv);
-  if (values === void 0) return refuse();
-  const input = build_input(values, now_ms);
-  if (input === void 0) return refuse();
-  const decision = backlog_budget.decide(input);
-  if (values.json === true) {
-    print_json(input, decision);
-    return SUCCESS_EXIT_CODE2;
-  }
-  path_decision.print_decision(JSON_KEY, decision.verdict, decision.reason, false);
-  return SUCCESS_EXIT_CODE2;
-}
-function main(argv) {
-  process.exitCode = run3(argv);
-}
-var backlog_budget_cli = {
-  JSON_KEY,
-  OPTIONS,
-  SUCCESS_EXIT_CODE: SUCCESS_EXIT_CODE2,
-  USAGE,
-  build_input,
-  main,
-  read_arguments,
-  run: run3,
-  to_answer,
-  to_count,
-  to_time_ms
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
-
-// scripts/issue/issue-number-shape.ts
-var ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u;
-var BAD_ISSUE_MESSAGE = "Not an issue number: ";
-function is_issue_number(value) {
-  return ISSUE_NUMBER_PATTERN.test(value);
-}
-function require_issue_number(issue) {
-  if (!is_issue_number(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`);
-}
-var issue_number_shape = { ISSUE_NUMBER_PATTERN, is_issue_number, require_issue_number };
-
-// scripts/run/run-invocation.ts
-var BACKLOG_COMMAND = "backlogrun";
-var KNOWN_FLAGS2 = ["--max", "--idle"];
-var ONLY_FLAG = "--only";
-var OPTIONS2 = {
-  max: { type: "string" },
-  idle: { type: "string" },
-  only: { type: "boolean" }
-};
-var ISSUE_PREFIX = "#";
-var FLAG_PREFIX = "-";
-var TOKEN_SEPARATOR = " ";
-var FIRST_TOKEN = 0;
-var FIRST_ARGUMENT_INDEX = 1;
-var EMPTY_LENGTH = 0;
-var NOT_FOUND = -1;
-function tokens_of(invocation) {
-  return invocation.split(TOKEN_SEPARATOR).filter((token) => token.length > EMPTY_LENGTH);
-}
-function render_option(token) {
-  if (token.name === cli_flags.option_name(ONLY_FLAG)) return ONLY_FLAG;
-  const flag = KNOWN_FLAGS2.find((known) => cli_flags.option_name(known) === token.name);
-  const value = backlog_budget_cli.to_count(token.value);
-  if (flag === void 0 || value === void 0) return void 0;
-  return `${flag} ${String(value)}`;
-}
-function rendered_options(tokens) {
-  const rendered = [];
-  for (const token of tokens) {
-    const part = render_option(token);
-    if (part === void 0) return void 0;
-    rendered.push(part);
-  }
-  return rendered;
-}
-function issue_of(token) {
-  if (!token.startsWith(ISSUE_PREFIX)) return void 0;
-  const digits = token.slice(ISSUE_PREFIX.length);
-  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(digits)) return void 0;
-  const issue = Number(digits);
-  return Number.isSafeInteger(issue) ? issue : void 0;
-}
-function issues_of(tokens) {
-  const issues = [];
-  for (const token of tokens) {
-    const issue = issue_of(token.value ?? "");
-    if (issue === void 0) return void 0;
-    issues.push(issue);
-  }
-  return issues;
-}
-function argument_tokens(invocation) {
-  const tokens = tokens_of(invocation);
-  if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
-  return cli_flags.parse_or_undefined({
-    args: tokens.slice(FIRST_ARGUMENT_INDEX),
-    options: OPTIONS2,
-    allowPositionals: true,
-    tokens: true
-  })?.tokens;
-}
-function parse(invocation) {
-  const tokens = argument_tokens(invocation);
-  if (tokens === void 0) return void 0;
-  const stop = tokens.findIndex((token) => token.kind !== "positional");
-  const split_at = stop === NOT_FOUND ? tokens.length : stop;
-  const issues = issues_of(tokens.slice(FIRST_TOKEN, split_at));
-  const flags = rendered_options(tokens.slice(split_at));
-  if (issues === void 0 || flags === void 0) return void 0;
-  return { issues, flags };
-}
-function issue_token(issue) {
-  return `${ISSUE_PREFIX}${String(issue)}`;
-}
-function joined(command, rendered) {
-  return [command, ...rendered].join(TOKEN_SEPARATOR);
-}
-function rebuild(invocation) {
-  const parsed = parse(invocation);
-  if (parsed === void 0) return void 0;
-  return joined(BACKLOG_COMMAND, [
-    ...parsed.issues.map((issue) => issue_token(issue)),
-    ...parsed.flags
-  ]);
-}
-function issue_numbers(invocation) {
-  const tokens = tokens_of(invocation);
-  const stop = tokens.findIndex((token) => token.startsWith(FLAG_PREFIX));
-  const leading = stop === NOT_FOUND ? tokens : tokens.slice(FIRST_TOKEN, stop);
-  const issues = parse(leading.join(TOKEN_SEPARATOR))?.issues;
-  if (issues === void 0 || issues.length === EMPTY_LENGTH) return void 0;
-  return issues;
-}
-function has_only(invocation) {
-  return parse(invocation)?.flags.includes(ONLY_FLAG) === true;
-}
-var run_invocation = {
-  has_only,
-  issue_numbers,
-  rebuild
-};
-
-// scripts/run/carry/run-carry.ts
-import { z as z2 } from "zod";
-
-// scripts/run/carry/run-carry-added.ts
-function issues_of2(added, is_priority) {
-  return added.filter((entry) => entry.is_priority === is_priority).map((entry) => entry.issue);
-}
-function ordered(declared, added = []) {
-  const sequence = [...issues_of2(added, true), ...declared, ...issues_of2(added, false)];
-  return sequence.filter((issue, index) => sequence.indexOf(issue) === index);
-}
-function next_added(carry, additions) {
-  const next = [...carry.added ?? []];
-  for (const addition of additions) {
-    if (next.every((entry) => entry.issue !== addition.issue)) next.push(addition);
-  }
-  return next;
-}
-function add_issues(target, carry, additions) {
-  const next = { ...carry, added: next_added(carry, additions) };
-  stamp_file.replace_stamp(target, next);
-  return next;
-}
-var run_carry_added = { add_issues, ordered };
-
-// scripts/run/carry/run-carry-streak.ts
-var NO_INCREMENT = 0;
-var OUTAGE_FOLD_WINDOW_MS = 12e4;
-function has_increment(value) {
-  return (value ?? NO_INCREMENT) > NO_INCREMENT;
-}
-function next_failures(carry, change) {
-  if (has_increment(change.merged)) return NO_INCREMENT;
-  return carry.failures + (change.failures ?? NO_INCREMENT);
-}
-function is_within_fold_window(last_outage_at, now) {
-  if (last_outage_at === void 0) return false;
-  const last = Date.parse(last_outage_at);
-  if (Number.isNaN(last)) return false;
-  return now.getTime() - last <= OUTAGE_FOLD_WINDOW_MS;
-}
-function folded_outage(carry) {
-  return { outages: carry.outages, last_outage_at: carry.last_outage_at };
-}
-function counted_outage(carry, change, now) {
-  const outages = carry.outages + (change.outages ?? NO_INCREMENT);
-  return { outages, last_outage_at: now.toISOString() };
-}
-function next_outage(carry, change, now) {
-  if (has_increment(change.outages)) {
-    return is_within_fold_window(carry.last_outage_at, now) ? folded_outage(carry) : counted_outage(carry, change, now);
-  }
-  const is_reachable = has_increment(change.merged) || has_increment(change.failures);
-  return is_reachable ? { outages: NO_INCREMENT, last_outage_at: void 0 } : folded_outage(carry);
-}
-function next_state(carry, change, now) {
-  const outage = next_outage(carry, change, now);
-  return {
-    failures: next_failures(carry, change),
-    outages: outage.outages,
-    last_outage_at: outage.last_outage_at
-  };
-}
-var run_carry_streak = { next_state };
-
-// scripts/run/carry/run-carry-change.ts
-var NO_INCREMENT2 = 0;
-function next_done(carry, done) {
-  if (done === void 0) return carry.done;
-  const current = carry.done ?? [];
-  return current.includes(done) ? current : [...current, done];
-}
-function next_merged_issues(carry, issue) {
-  if (issue === void 0) return carry.merged_issues;
-  const current = carry.merged_issues ?? [];
-  return current.includes(issue) ? current : [...current, issue];
-}
-function is_duplicate_merge(carry, change) {
-  const issue = change.merged_issue;
-  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
-}
-function has_other_change(change) {
-  const amounts = [change.filed, change.cuts, change.failures, change.outages];
-  const has_amount = amounts.some((amount) => (amount ?? NO_INCREMENT2) > NO_INCREMENT2);
-  return has_amount || change.done !== void 0 || change.retrospective === true;
-}
-function effective_change(carry, change) {
-  if (!is_duplicate_merge(carry, change)) return change;
-  return has_other_change(change) ? { ...change, merged: NO_INCREMENT2 } : void 0;
-}
-function next_counts(carry, change) {
-  const cuts = change.cuts ?? NO_INCREMENT2;
-  return {
-    merged: carry.merged + (change.merged ?? NO_INCREMENT2),
-    filed: carry.filed + (change.filed ?? NO_INCREMENT2),
-    cuts: carry.cuts + cuts,
-    is_handed_off: cuts > NO_INCREMENT2
-  };
-}
-function apply_change(target, carry, change, now = /* @__PURE__ */ new Date()) {
-  const effective = effective_change(carry, change);
-  if (effective === void 0) return carry;
-  const streak = run_carry_streak.next_state(carry, effective, now);
-  const next = {
-    ...carry,
-    ...next_counts(carry, effective),
-    merged_issues: next_merged_issues(carry, effective.merged_issue),
-    failures: streak.failures,
-    outages: streak.outages,
-    last_outage_at: streak.last_outage_at,
-    done: next_done(carry, effective.done),
-    retrospective: effective.retrospective === true || carry.retrospective
-  };
-  stamp_file.replace_stamp(target, next);
-  return next;
-}
-var run_carry_change = { apply_change };
-
-// scripts/run/carry/run-carry-conversation.ts
-import { existsSync, statSync as statSync2 } from "node:fs";
-import path5 from "node:path";
-
-// scripts/cost-runtime/cost-transcript.ts
-import { readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
-import { homedir } from "node:os";
-import path4 from "node:path";
-
-// scripts/lane/lane-paths.ts
-import path3 from "node:path";
-var LANE_ROOT_KEY = "JOSH_LANE_ROOT";
-var LANE_DIRECTORY_SUFFIX = "-lanes";
-var LANE_BRANCH_SUFFIX = "-lane";
-function default_lane_root(repository_root2) {
-  const name = path3.basename(repository_root2);
-  return path3.join(path3.dirname(repository_root2), `.${name}${LANE_DIRECTORY_SUFFIX}`);
-}
-function lane_root(repository_root2, environment = process.env) {
-  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  return configured.length === 0 ? default_lane_root(repository_root2) : path3.resolve(configured);
-}
-function lane_directory(root, issue) {
-  return path3.join(root, issue);
-}
-var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
-function is_lane_root(directory, environment) {
-  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
-  if (configured.length > 0) return path3.resolve(configured) === directory;
-  return DEFAULT_LANE_ROOT_PATTERN.test(path3.basename(directory));
-}
-function lane_issue_of(directory, environment = process.env) {
-  const resolved = path3.resolve(directory);
-  const issue = path3.basename(resolved);
-  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) return void 0;
-  return is_lane_root(path3.dirname(resolved), environment) ? issue : void 0;
-}
-function lane_branch(issue) {
-  return `${issue}${LANE_BRANCH_SUFFIX}`;
-}
-var SEAT_LOCK_DIR = ".seat-locks";
-function is_lane_entry(name) {
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(name) || DEFAULT_LANE_ROOT_PATTERN.test(name);
-}
-var lane_paths = {
-  LANE_BRANCH_SUFFIX,
-  LANE_ROOT_KEY,
-  SEAT_LOCK_DIR,
-  default_lane_root,
-  is_lane_entry,
-  lane_branch,
-  lane_directory,
-  lane_issue_of,
-  lane_root
-};
-
-// scripts/lib/read-file.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-var ABSENT_CODE = "ENOENT";
-function is_absent(error) {
-  return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
-}
-function read_optional(path7) {
-  try {
-    return readFileSync2(path7, "utf8");
-  } catch (error) {
-    if (is_absent(error)) return void 0;
-    throw error;
-  }
-}
-function read_file_or_empty(path7) {
-  return read_optional(path7) ?? "";
-}
-function read_if_readable(path7) {
-  try {
-    return readFileSync2(path7, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-var file_reader = { read_optional, read_file_or_empty, read_if_readable };
-
-// scripts/time-runtime/time-instant.ts
-function parse_instant(raw) {
-  if (raw === null || raw === void 0) return void 0;
-  const parsed = Date.parse(raw);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-var time_instant = { parse_instant };
-
-// scripts/cost-runtime/cost-usage.ts
-import { z } from "zod";
-var CACHE_CREATION_SCHEMA = z.object({
-  ephemeral_1h_input_tokens: z.number().nullish(),
-  ephemeral_5m_input_tokens: z.number().nullish()
-});
-var USAGE_SCHEMA = z.object({
-  input_tokens: z.number(),
-  cache_creation_input_tokens: z.number().nullish(),
-  cache_read_input_tokens: z.number().nullish(),
-  output_tokens: z.number(),
-  output_tokens_details: z.object({ thinking_tokens: z.number().nullish() }).nullish(),
-  cache_creation: CACHE_CREATION_SCHEMA.nullish()
-});
-var MESSAGE_SCHEMA = z.object({
-  id: z.string().nullish(),
-  model: z.string().nullish(),
-  usage: USAGE_SCHEMA.nullish()
-});
-var LINE_SCHEMA = z.object({
-  type: z.string(),
-  requestId: z.string().nullish(),
-  uuid: z.string().nullish(),
-  gitBranch: z.string().nullish(),
-  timestamp: z.string().nullish(),
-  message: MESSAGE_SCHEMA.nullish()
-});
-var SYNTHETIC_MODEL = "<synthetic>";
-var EMPTY_TOTALS = {
-  input_tokens: 0,
-  cache_write_5m_tokens: 0,
-  cache_write_1h_tokens: 0,
-  cache_read_tokens: 0,
-  output_tokens: 0,
-  thinking_tokens: 0,
-  thinking_measured: false
-};
-var UNKNOWN_MODEL = "unknown";
-var UNKNOWN_BRANCH = "";
-function split_cache_write(usage) {
-  const total = usage.cache_creation_input_tokens ?? 0;
-  const detail = usage.cache_creation;
-  if (!detail) return { write_5m: total, write_1h: 0 };
-  const write_1h = detail.ephemeral_1h_input_tokens ?? 0;
-  return { write_5m: detail.ephemeral_5m_input_tokens ?? total - write_1h, write_1h };
-}
-function thinking_usage(usage) {
-  const raw = usage.output_tokens_details?.thinking_tokens;
-  return { tokens: raw ?? 0, measured: raw !== null && raw !== void 0 };
-}
-function to_totals(usage) {
-  const { write_5m, write_1h } = split_cache_write(usage);
-  const thinking = thinking_usage(usage);
-  return {
-    input_tokens: usage.input_tokens,
-    cache_write_5m_tokens: write_5m,
-    cache_write_1h_tokens: write_1h,
-    cache_read_tokens: usage.cache_read_input_tokens ?? 0,
-    output_tokens: usage.output_tokens,
-    thinking_tokens: thinking.tokens,
-    thinking_measured: thinking.measured
-  };
-}
-function declared_id(data) {
-  return data.requestId ?? data.message?.id ?? data.uuid ?? void 0;
-}
-function request_id_of(data, usage) {
-  const fallback = `${data.timestamp ?? ""}-${String(usage.output_tokens)}`;
-  return declared_id(data) ?? fallback;
-}
-function to_record(data, usage) {
-  return {
-    request_id: request_id_of(data, usage),
-    model: data.message?.model ?? UNKNOWN_MODEL,
-    branch: data.gitBranch ?? UNKNOWN_BRANCH,
-    at_ms: time_instant.parse_instant(data.timestamp),
-    totals: to_totals(usage)
-  };
-}
-var ASSISTANT_TYPE = "assistant";
-function is_priced_line(data) {
-  return data.type === ASSISTANT_TYPE && data.message?.model !== SYNTHETIC_MODEL;
-}
-function classify(data) {
-  if (!is_priced_line(data)) return { kind: "skipped" };
-  const usage = data.message?.usage;
-  return usage ? { kind: "record", record: to_record(data, usage) } : { kind: "no_usage" };
-}
-function parse_line(line) {
-  if (line.trim() === "") return { kind: "skipped" };
-  const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
-  return parsed.success ? classify(parsed.data) : { kind: "malformed" };
-}
-function later_instant(left, right) {
-  if (left === void 0) return right;
-  if (right === void 0) return left;
-  return Math.max(left, right);
-}
-function dedupe(records) {
-  const by_id = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const seen = by_id.get(record.request_id);
-    const at_ms = later_instant(seen?.at_ms, record.at_ms);
-    by_id.set(record.request_id, { ...seen ?? record, at_ms });
-  }
-  return [...by_id.values()];
-}
-function add_totals(left, right) {
-  return {
-    input_tokens: left.input_tokens + right.input_tokens,
-    cache_write_5m_tokens: left.cache_write_5m_tokens + right.cache_write_5m_tokens,
-    cache_write_1h_tokens: left.cache_write_1h_tokens + right.cache_write_1h_tokens,
-    cache_read_tokens: left.cache_read_tokens + right.cache_read_tokens,
-    output_tokens: left.output_tokens + right.output_tokens,
-    thinking_tokens: left.thinking_tokens + right.thinking_tokens,
-    thinking_measured: left.thinking_measured || right.thinking_measured
-  };
-}
-function sum_totals(records) {
-  let total = EMPTY_TOTALS;
-  for (const record of records) total = add_totals(total, record.totals);
-  return total;
-}
-function billed_input(totals) {
-  return totals.input_tokens + totals.cache_write_5m_tokens + totals.cache_write_1h_tokens + totals.cache_read_tokens;
-}
-var cost_usage = {
-  EMPTY_TOTALS,
-  UNKNOWN_MODEL,
-  SYNTHETIC_MODEL,
-  parse_line,
-  dedupe,
-  add_totals,
-  sum_totals,
-  billed_input
-};
-
-// scripts/cost-runtime/cost-transcript.ts
-var TRANSCRIPT_ROOT = path4.join(".claude", "projects");
-var TRANSCRIPT_EXTENSION = ".jsonl";
-var SLUG_PATTERN = /[^a-zA-Z0-9-]/gu;
-var UNIT_DIRECTORY = "subagents";
-var UNIT_ID_SEPARATOR = "/";
-function project_slug(cwd) {
-  return cwd.replaceAll(SLUG_PATTERN, "-");
-}
-function transcript_directory(cwd, home = homedir()) {
-  return path4.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
-}
-var GIT_ENTRY = ".git";
-var GITDIR_PREFIX = "gitdir:";
-var WORKTREE_SEGMENT = `/${GIT_ENTRY}/worktrees/`;
-var NOT_FOUND2 = -1;
-function linked_worktree_gitdir(cwd) {
-  try {
-    const contents = readFileSync3(path4.join(cwd, GIT_ENTRY), "utf8").trim();
-    return contents.startsWith(GITDIR_PREFIX) ? contents.slice(GITDIR_PREFIX.length).trim() : "";
-  } catch {
-    return "";
-  }
-}
-function session_cwd(cwd) {
-  const gitdir = linked_worktree_gitdir(cwd);
-  const absolute = gitdir === "" ? "" : path4.resolve(cwd, gitdir);
-  const segment = absolute.indexOf(WORKTREE_SEGMENT);
-  return segment === NOT_FOUND2 ? cwd : absolute.slice(0, segment);
-}
-function read_directory(directory) {
-  try {
-    return readdirSync(directory);
-  } catch {
-    return [];
-  }
-}
-function lane_transcript_directories(main_cwd, home) {
-  const projects = path4.join(home, TRANSCRIPT_ROOT);
-  const prefix = `${project_slug(lane_paths.lane_root(main_cwd))}-`;
-  return read_directory(projects).filter(
-    (name) => name.startsWith(prefix) && issue_number_shape.ISSUE_NUMBER_PATTERN.test(name.slice(prefix.length))
-  ).map((name) => path4.join(projects, name));
-}
-function transcript_directories(cwd, home = homedir()) {
-  const own = transcript_directory(cwd, home);
-  const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
-  return [.../* @__PURE__ */ new Set([own, ...lanes])];
-}
-var OWN_DEPTH = 0;
-function home_directory() {
-  return homedir();
-}
-function to_session_file(full_path, session_id, depth) {
-  try {
-    return {
-      session_id,
-      path: full_path,
-      modified_ms: statSync(full_path).mtimeMs,
-      is_delegated: depth > OWN_DEPTH,
-      depth
-    };
-  } catch {
-    return void 0;
-  }
-}
-function is_transcript(name) {
-  return name.endsWith(TRANSCRIPT_EXTENSION);
-}
-function without_extension(name) {
-  return name.slice(0, -TRANSCRIPT_EXTENSION.length);
-}
-function own_files(directory, names) {
-  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path4.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
-}
-function unit_directory(directory, session_id) {
-  return path4.join(directory, session_id, UNIT_DIRECTORY);
-}
-var UNIT_DEPTH = 1;
-function level_units(subagents_directory, prefix, depth) {
-  return read_directory(subagents_directory).filter((name) => is_transcript(name)).map(
-    (name) => to_session_file(
-      path4.join(subagents_directory, name),
-      `${prefix}${UNIT_ID_SEPARATOR}${without_extension(name)}`,
-      depth
-    )
-  ).filter((file) => file !== void 0);
-}
-function collect_units(subagents_directory, prefix, depth) {
-  const nested = read_directory(subagents_directory).filter((name) => !is_transcript(name)).flatMap(
-    (name) => collect_units(
-      unit_directory(subagents_directory, name),
-      `${prefix}${UNIT_ID_SEPARATOR}${name}`,
-      depth + 1
-    )
-  );
-  return [...level_units(subagents_directory, prefix, depth), ...nested];
-}
-function unit_files(directory, session_name) {
-  return collect_units(unit_directory(directory, session_name), session_name, UNIT_DEPTH);
-}
-function list_sessions(directory) {
-  const names = read_directory(directory);
-  const units = names.filter((name) => !is_transcript(name)).flatMap((name) => unit_files(directory, name));
-  return [...own_files(directory, names), ...units].toSorted(
-    (left, right) => right.modified_ms - left.modified_ms
-  );
-}
-function list_sessions_across(directories) {
-  const seen = /* @__PURE__ */ new Set();
-  const merged = directories.flatMap((directory) => list_sessions(directory));
-  const newest_first = merged.toSorted((left, right) => right.modified_ms - left.modified_ms);
-  const kept = [];
-  for (const file of newest_first) {
-    if (seen.has(file.session_id)) continue;
-    seen.add(file.session_id);
-    kept.push(file);
-  }
-  return kept;
-}
-function owning_session_id(file) {
-  const [owner] = file.session_id.split(UNIT_ID_SEPARATOR);
-  return owner ?? file.session_id;
-}
-function parent_session_id(file) {
-  const separator = file.session_id.lastIndexOf(UNIT_ID_SEPARATOR);
-  return separator === NOT_FOUND2 ? file.session_id : file.session_id.slice(0, separator);
-}
-function latest_own_index(files) {
-  const index = files.findIndex((file) => !file.is_delegated);
-  return index === -1 ? 0 : index;
-}
-function empty_session() {
-  return {
-    records: [],
-    no_usage_lines: 0,
-    malformed_lines: 0,
-    is_readable: false,
-    baseline_tokens: 0
-  };
-}
-function tally(content) {
-  const outcomes = content.split("\n").map((line) => cost_usage.parse_line(line));
-  const records = outcomes.flatMap(
-    (outcome) => outcome.kind === "record" ? [outcome.record] : []
-  );
-  const unique = cost_usage.dedupe(records);
-  const [first] = unique;
-  return {
-    records: unique,
-    no_usage_lines: outcomes.filter((outcome) => outcome.kind === "no_usage").length,
-    malformed_lines: outcomes.filter((outcome) => outcome.kind === "malformed").length,
-    is_readable: true,
-    baseline_tokens: first === void 0 ? 0 : cost_usage.billed_input(first.totals)
-  };
-}
-function read_session(file) {
-  const content = file_reader.read_if_readable(file.path);
-  if (content === void 0) return { session_id: file.session_id, ...empty_session() };
-  return { session_id: file.session_id, ...tally(content) };
-}
-function read_raw(file) {
-  return file_reader.read_if_readable(file.path) ?? "";
-}
-function read_optional2(file) {
-  return file_reader.read_if_readable(file.path);
-}
-function directory_exists(directory) {
-  try {
-    return statSync(directory).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function searched_directories(directories) {
-  return directories.map((directory) => ({
-    path: directory,
-    exists: directory_exists(directory)
-  }));
-}
-function describe_searched(directory) {
-  return `  ${directory.path} \u2014 ${directory.exists ? "no transcripts here" : "no such directory"}`;
-}
-function missing_message(searched, session_id) {
-  const lead = session_id === void 0 ? "No transcripts found. Searched:" : `No transcript named ${session_id}. Searched:`;
-  const listed = searched.map((directory) => describe_searched(directory));
-  if (session_id !== void 0) return [lead, ...listed];
-  return [
-    lead,
-    ...listed,
-    "Claude Code writes them per project; run this from the project it ran in."
-  ];
-}
-var cost_transcript = {
-  TRANSCRIPT_EXTENSION,
-  TRANSCRIPT_ROOT,
-  UNIT_DIRECTORY,
-  project_slug,
-  transcript_directory,
-  transcript_directories,
-  session_cwd,
-  unit_directory,
-  list_sessions,
-  list_sessions_across,
-  searched_directories,
-  owning_session_id,
-  parent_session_id,
-  latest_own_index,
-  tally,
-  read_session,
-  read_raw,
-  read_optional: read_optional2,
-  missing_message,
-  home_directory
-};
-
-// scripts/josh/agent-session-environment.ts
-var SESSION_ID_KEY = "CLAUDE_CODE_SESSION_ID";
-var AGENT_PID_KEY = "CLAUDE_PID";
-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 = {
-  AGENT_PID_KEY,
-  LOOPBACK_HOSTS,
-  PARENT_SESSION_KEYS,
-  PROXY_CERTIFICATE_KEY,
-  PROXY_KEYS,
-  SESSION_ID_KEY,
-  removed_environment,
-  removed_proxy_environment
-};
-
-// scripts/cost-runtime/own-session.ts
-var NOT_FOUND3 = -1;
-function session_id_of(environment) {
-  const value = environment[agent_session_environment.SESSION_ID_KEY];
-  return value === void 0 || value === "" ? void 0 : value;
-}
-function select_own_session(files, environment) {
-  const session_id = session_id_of(environment);
-  if (session_id === void 0) {
-    return { kind: "own", index: cost_transcript.latest_own_index(files) };
-  }
-  const index = files.findIndex((file) => file.session_id === session_id);
-  return index === NOT_FOUND3 ? { kind: "absent", session_id } : { kind: "own", index };
-}
-var own_session = {
-  session_id_of,
-  select_own_session
-};
-
-// scripts/run/carry/run-carry-conversation.ts
-var CONVERSATION_QUIET_MS = 6e5;
-function own_transcript(environment = process.env, directories = cost_transcript.transcript_directories(process.cwd())) {
-  const session_id = own_session.session_id_of(environment);
-  if (session_id === void 0) return void 0;
-  const name = `${session_id}${cost_transcript.TRANSCRIPT_EXTENSION}`;
-  return directories.map((directory) => path5.join(directory, name)).find((file) => existsSync(file));
-}
-function modified_ms(transcript) {
-  try {
-    return statSync2(transcript).mtimeMs;
-  } catch {
-    return void 0;
-  }
-}
-function is_recent(modified, now) {
-  return modified !== void 0 && now.getTime() - modified <= CONVERSATION_QUIET_MS;
-}
-function is_conversation_live(carry, now = /* @__PURE__ */ new Date(), read_modified = modified_ms) {
-  if (carry.is_handed_off === true || carry.owner_transcript === void 0) return false;
-  return is_recent(read_modified(carry.owner_transcript), now);
-}
-function is_same_conversation(carry, owner) {
-  return owner.transcript !== void 0 && owner.transcript === carry.owner_transcript;
-}
-function reclaim_owner(carry, owner) {
-  if (carry.is_handed_off === true || !is_same_conversation(carry, owner) || owner.pid === carry.owner_pid) {
-    return carry;
-  }
-  return { ...carry, owner_pid: owner.pid, owner_start: owner.start };
-}
-var run_carry_conversation = {
-  CONVERSATION_QUIET_MS,
-  own_transcript,
-  is_conversation_live,
-  is_same_conversation,
-  reclaim_owner
-};
-
-// scripts/run/carry/run-carry.ts
-var CARRY_PREFIX = "josh-run-carry-";
-var REPOSITORY_DIRECTORY_INDEX = 1;
-var NO_INCREMENT3 = 0;
-var MAX_CUTS = 6;
-var END_COMMAND = "pnpm josh run:carry --end";
-var RESUME_COMMAND = "pnpm josh run:carry --resume";
-var READ_COMMAND = "pnpm josh run:carry --json";
-var OWNER_ARGUMENT = '--owner "$PPID"';
-var NO_OWNER = {};
-var carry_addition_schema = z2.object({ issue: z2.number(), is_priority: z2.boolean() });
-var run_carry_schema = z2.object({
-  invocation: z2.string(),
-  started_at: z2.string(),
-  merged: z2.number(),
-  merged_issues: z2.array(z2.number()).optional(),
-  filed: z2.number(),
-  cuts: z2.number(),
-  // Defaulted, so a record that lacks the streak parses with a zero streak rather than failing to read.
-  failures: z2.number().default(0),
-  outages: z2.number().default(0),
-  last_outage_at: z2.string().optional(),
-  // An absent owner reads as "no owner declared", which is the not-provably-live answer rather than a
-  // live one.
-  owner_pid: z2.number().optional(),
-  owner_start: z2.string().optional(),
-  owner_transcript: z2.string().optional(),
-  is_owner_headless: z2.boolean().optional(),
-  is_handed_off: z2.boolean().optional(),
-  done: z2.array(z2.number()).optional(),
-  retrospective: z2.boolean().optional(),
-  added: z2.array(carry_addition_schema).optional(),
-  lane_limit: z2.number().int().positive().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) {
-  return json_value.parse_with(raw, run_carry_schema);
-}
-function classify2(raw) {
-  if (raw === void 0) return { kind: "none" };
-  const carry = parse_carry(raw);
-  if (carry === void 0 || Number.isNaN(Date.parse(carry.started_at))) {
-    return { kind: "unreadable" };
-  }
-  return { kind: "carried", carry };
-}
-function read_carry(target) {
-  return classify2(stamp_file.read_stamp_text(target));
-}
-function owner_of(pid, read3 = process_identity.read_start, transcript = run_carry_conversation.own_transcript()) {
-  return { pid, start: read3(pid), transcript };
-}
-function fresh_carry(invocation, owner, now) {
-  return {
-    invocation,
-    started_at: now.toISOString(),
-    merged: NO_INCREMENT3,
-    filed: NO_INCREMENT3,
-    cuts: NO_INCREMENT3,
-    failures: NO_INCREMENT3,
-    outages: NO_INCREMENT3,
-    owner_pid: owner.pid,
-    owner_start: owner.start,
-    owner_transcript: owner.transcript,
-    is_owner_headless: owner.is_headless
-  };
-}
-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 adopt_carry(target, carry, owner = NO_OWNER) {
-  const next = {
-    ...carry,
-    owner_pid: owner.pid,
-    owner_start: owner.start,
-    owner_transcript: owner.transcript,
-    is_owner_headless: owner.is_headless,
-    is_handed_off: false
-  };
-  stamp_file.remove_stamp(target);
-  return stamp_file.create_stamp(target, next) ? next : void 0;
-}
-function is_owner_live(carry, now = /* @__PURE__ */ new Date()) {
-  if (process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false) return true;
-  return run_carry_conversation.is_conversation_live(carry, now);
-}
-function is_owned_by(carry, owner) {
-  if (run_carry_conversation.is_same_conversation(carry, owner)) return true;
-  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_held_by_another(carry, is_live = is_owner_live) {
-  const caller = owner_of(process.pid);
-  const is_own = carry.owner_pid === caller.pid && carry.owner_start === caller.start;
-  return !is_own && is_live(carry);
-}
-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(read3) {
-  return read3.kind === "carried" && read3.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 run_carry_added.ordered(declared, carry.added).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 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_COMMAND}\` once you know its run is over, then begin again.`;
-}
-function busy_message(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_COMMAND}\` once you know it is over.`;
-}
-function claim_command(invocation) {
-  return `${RESUME_COMMAND} "${invocation}" ${OWNER_ARGUMENT}`;
-}
-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 \`${claim_command(carry.invocation)}\`, or discard it with \`${END_COMMAND}\` 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_COMMAND}\`.`;
-}
-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_message() {
-  return `A run record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it.`;
-}
-function unknown_message() {
-  return "This repository\u2019s git directory could not be read, so no run record was established.";
-}
-var run_carry = {
-  END_COMMAND,
-  MAX_CUTS,
-  NO_OWNER,
-  RESUME_COMMAND,
-  adopt_carry,
-  apply_change: run_carry_change.apply_change,
-  begin_carry,
-  busy_message,
-  carry_path,
-  claim_command,
-  classify: classify2,
-  classify_claim,
-  count_refused_message,
-  is_at_cut_cap,
-  describe_carry,
-  end_carry,
-  mismatch_message,
-  fresh_carry,
-  is_count_refused,
-  is_foreign_live_owner,
-  is_held_by_another,
-  is_owner_live,
-  lost_message,
-  nothing_to_resume_message,
-  owner_of,
-  parse_carry,
-  read_carry,
-  remaining_of,
-  repository_directory,
-  retrospective_done_of,
-  standing_message,
-  unknown_message,
-  unreadable_message
-};
-
-// ports/index.js
-import { existsSync as existsSync2 } from "node:fs";
-import path6 from "node:path";
-var PORT_SEED_KEY = "PORT_SEED";
-var LANE_SEAT_KEY = "JOSH_LANE_SEAT";
-var ENV_FILE_NAME = ".env";
-var PACKAGE_FILE_NAME = "package.json";
-var PROJECT_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([PORT_SEED_KEY, LANE_SEAT_KEY, "PLAYWRIGHT_REUSE_SERVER"]);
-var DEV_PORT_BASE = 5173;
-var PREVIEW_PORT_BASE = 4173;
-var MIN_SEED = 0;
-var SEED_LANE_MULTIPLIER = 10;
-var MAX_LANE = 9;
-var MAX_SEED = 99;
-var INTEGER_PATTERN = /^\d+$/u;
-function fail_invalid(key, raw, max) {
-  throw new Error(
-    `${key} must be an integer between ${MIN_SEED} and ${max}, got ${JSON.stringify(raw)}. Unset it to use the default ports (dev ${DEV_PORT_BASE}, preview ${PREVIEW_PORT_BASE}).`
-  );
-}
-function read_trimmed(environment, key) {
-  const raw = environment[key];
-  return raw === void 0 ? "" : raw.trim();
-}
-function resolve_bounded(environment, key, max) {
-  const trimmed = read_trimmed(environment, key);
-  if (trimmed.length === 0) return MIN_SEED;
-  if (!INTEGER_PATTERN.test(trimmed)) fail_invalid(key, trimmed, max);
-  const value = Number(trimmed);
-  if (value > max) fail_invalid(key, trimmed, max);
-  return value;
-}
-function resolve_seed(environment = process.env) {
-  return resolve_bounded(environment, PORT_SEED_KEY, MAX_SEED);
-}
-function resolve_lane(environment = process.env) {
-  return resolve_bounded(environment, LANE_SEAT_KEY, MAX_LANE);
-}
-function resolve_offset(environment = process.env) {
-  return resolve_seed(environment) * SEED_LANE_MULTIPLIER + resolve_lane(environment);
-}
-function offset_from(base, environment) {
-  return base + resolve_offset(environment);
-}
-function resolve_development_port(environment = process.env) {
-  return offset_from(DEV_PORT_BASE, environment);
-}
-function resolve_preview_port(environment = process.env) {
-  return offset_from(PREVIEW_PORT_BASE, environment);
-}
-function resolve_project_directory(directory) {
-  const start = path6.resolve(directory);
-  let current = start;
-  while (!existsSync2(path6.join(current, PACKAGE_FILE_NAME))) {
-    const parent = path6.dirname(current);
-    if (parent === current) return start;
-    current = parent;
-  }
-  return current;
-}
-function discard_loaded_keys(snapshot) {
-  for (const key of Object.keys(process.env)) {
-    if (!PROJECT_ENVIRONMENT_KEYS.has(key) && !Object.hasOwn(snapshot, key)) {
-      Reflect.deleteProperty(process.env, key);
-    }
-  }
-}
-function load_environment_file(directory = process.cwd()) {
-  const file = path6.join(resolve_project_directory(directory), ENV_FILE_NAME);
-  if (!existsSync2(file)) return false;
-  const snapshot = { ...process.env };
-  process.loadEnvFile(file);
-  discard_loaded_keys(snapshot);
-  return true;
-}
-var ports = {
-  load_environment_file,
-  resolve_project_directory,
-  resolve_seed,
-  resolve_lane,
-  resolve_development_port,
-  resolve_preview_port
-};
-
-// scripts/josh/process-owner.ts
-import { z as z3 } from "zod";
-var process_owner_schema = z3.object({ pid: z3.number(), process_start: z3.string().optional() });
-
-// scripts/git/git-schemas.ts
-import { z as z4 } from "zod";
-var package_name_schema = z4.object({ name: z4.string().min(1) });
-var rollup_item_schema = z4.looseObject({
-  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
-  __typename: z4.string().optional(),
-  state: z4.string().optional(),
-  status: z4.string().optional(),
-  conclusion: z4.string().optional(),
-  name: z4.string().optional(),
-  context: z4.string().optional(),
-  description: z4.string().nullish()
-});
-var pr_raw_schema = z4.object({
-  statusCheckRollup: z4.array(rollup_item_schema).optional(),
-  mergeStateStatus: z4.string().optional(),
-  reviewDecision: z4.string().optional()
-});
-var pull_comment_schema = z4.object({
-  body: z4.string().optional(),
-  html_url: z4.string().optional(),
-  user: z4.object({ login: z4.string().optional() }).optional()
-});
-var ai_review_pull_comment_schema = z4.object({
-  body: z4.string().optional(),
-  url: z4.string().optional(),
-  author: z4.object({ login: z4.string().optional() }).optional()
-});
-var pr_info_schema = z4.object({
-  mergeable: z4.union([z4.boolean(), z4.string()]).nullable().optional(),
-  mergeStateStatus: z4.string().nullable().optional(),
-  state: z4.string().optional()
-});
-var epic_issue_schema = z4.object({
-  number: z4.number(),
-  body: z4.string().optional()
-});
-var blocking_issue_schema = z4.object({
-  number: z4.number(),
-  state: z4.string().optional(),
-  repository_url: z4.string().optional()
-});
-var blocked_by_schema = z4.object({
-  nodes: z4.array(blocking_issue_schema).default([]),
-  totalCount: z4.number().optional()
-}).optional();
-var epic_child_schema = z4.object({
-  state: z4.string().optional(),
-  blockedBy: blocked_by_schema
-});
-var rest_comment_schema = z4.looseObject({
-  body: z4.string().nullish(),
-  html_url: z4.string().optional(),
-  user: z4.looseObject({ login: z4.string().optional() }).nullish()
-});
-var issue_label_schema = z4.object({ name: z4.string() });
-var epic_subject_schema = z4.object({
-  number: z4.number(),
-  state: z4.string().optional(),
-  labels: z4.array(issue_label_schema).optional(),
-  body: z4.string().optional()
-});
-var open_issue_schema = z4.object({
-  number: z4.number(),
-  title: z4.string(),
-  labels: z4.array(issue_label_schema).optional(),
-  createdAt: z4.string(),
-  blockedBy: blocked_by_schema,
-  // Present only on the pickup listing, which reads it for the paths each issue declares.
-  body: z4.string().optional()
-});
-
-export {
-  json_value,
-  process_identity,
-  process_owner_schema,
-  issue_number_shape,
-  lane_paths,
-  PORT_SEED_KEY,
-  LANE_SEAT_KEY,
-  ENV_FILE_NAME,
-  ports,
-  pr_raw_schema,
-  blocking_issue_schema,
-  rest_comment_schema,
-  issue_label_schema,
-  open_issue_schema,
-  PORCELAIN_FLAG,
-  UNTRACKED_FILES_FLAG,
-  git_utilities,
-  has_timed_out,
-  git_spawn,
-  git_diff_reads,
-  GIT_LOCATION_VARIABLES,
-  git_location_environment,
-  git_spawn_sync,
-  git_command,
-  changed_paths,
-  cli_flags,
-  backlog_budget,
-  run_invocation,
-  file_reader,
-  time_instant,
-  cost_usage,
-  cost_transcript,
-  agent_session_environment,
-  own_session,
-  run_carry
-};