@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/hooks/chunk-7SIUNQXK.js

@@ -0,0 +1,3591 @@
+import {
+  MS_PER_MINUTE,
+  PLATFORM_TEMP_ROOT,
+  PROBE_TIMEOUT_MS,
+  error_text,
+  git_command,
+  git_common_directory,
+  platform_temporary,
+  repo_discovery,
+  repo_origin,
+  stamp_file
+} from "./chunk-45CJJOO7.js";
+
+// scripts/lib/json-value.ts
+function parse_or_undefined(text2) {
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return void 0;
+  }
+}
+function parse_with(text2, schema) {
+  const value = parse_or_undefined(text2);
+  if (value === void 0) return void 0;
+  const parsed = schema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function parse_array(text2) {
+  const value = parse_or_undefined(text2);
+  return Array.isArray(value) ? value : void 0;
+}
+function is_record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var json_value = { parse_or_undefined, parse_with, parse_array, is_record };
+
+// scripts/josh/durable-state.ts
+import { mkdirSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/josh/durable-state-migrate.ts
+import { constants, copyFileSync, lstatSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var COPIED_MARKER = ".legacy-copied";
+var MARKER_MODE = 384;
+var LOG_RETENTION_DAYS = 14;
+var DAY_MS = 864e5;
+var LOG_SUFFIX = ".log";
+var RECORD_SUFFIXES = [".json", ".jsonl", LOG_SUFFIX];
+function is_record_name(name, prefixes) {
+  const has_prefix = prefixes.some((prefix) => name.startsWith(prefix));
+  return has_prefix && RECORD_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+function list_names(directory) {
+  try {
+    return readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+function copy_record(from, to) {
+  try {
+    if (!stamp_file.is_own_regular_file(from)) return;
+    copyFileSync(from, to, constants.COPYFILE_EXCL);
+  } catch {
+  }
+}
+function copy_legacy(from, to, prefixes) {
+  if (from === to) return;
+  for (const name of list_names(from)) {
+    if (is_record_name(name, prefixes)) copy_record(path.join(from, name), path.join(to, name));
+  }
+}
+function claim_copy(directory) {
+  try {
+    writeFileSync(path.join(directory, COPIED_MARKER), "", { flag: "wx", mode: MARKER_MODE });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function copy_once(from, to, prefixes) {
+  if (claim_copy(to)) copy_legacy(from, to, prefixes);
+}
+function is_stale(target2, now_ms) {
+  const age_ms = now_ms - lstatSync(target2).mtimeMs;
+  return age_ms > LOG_RETENTION_DAYS * DAY_MS && stamp_file.is_own_regular_file(target2);
+}
+function prune_log(target2, now_ms) {
+  try {
+    if (is_stale(target2, now_ms)) rmSync(target2, { force: true });
+  } catch {
+  }
+}
+function prune_stale_logs(directory, prefixes, now_ms) {
+  for (const name of list_names(directory)) {
+    if (name.endsWith(LOG_SUFFIX) && is_record_name(name, prefixes)) {
+      prune_log(path.join(directory, name), now_ms);
+    }
+  }
+}
+var durable_state_migrate = { LOG_RETENTION_DAYS, copy_once, is_record_name, prune_stale_logs };
+
+// scripts/josh/durable-state.ts
+var RUN_STATE_DIRECTORY = "run-state";
+var OVERRIDE_STATE_DIRECTORY = "josh-state";
+var STATE_DIRECTORY_MODE = 448;
+function state_root(override, common) {
+  if (override !== void 0 && override !== "") {
+    return path2.join(override, OVERRIDE_STATE_DIRECTORY);
+  }
+  if (common === void 0) return PLATFORM_TEMP_ROOT;
+  return path2.join(common, git_common_directory.STATE_DIRECTORY, RUN_STATE_DIRECTORY);
+}
+var STATE_ROOT_OVERRIDE = process.env[platform_temporary.TEMP_ROOT_KEY];
+function root_for(common) {
+  return state_root(STATE_ROOT_OVERRIDE, common);
+}
+function root() {
+  return root_for(git_common_directory.repository());
+}
+var PREFIX = {
+  CARRY: "josh-run-carry-",
+  ENDED: "josh-run-ended-",
+  EVENTS: "josh-run-events-",
+  LANE_STATE: "josh-lane-state-",
+  LANE_LEDGER: "josh-lane-ledger-",
+  WAKE_LOG: "josh-run-wake-log-",
+  BACKLOGRUN_LAUNCH: "josh-backlogrun-launch-",
+  BACKLOGRUN_LOG: "josh-backlogrun-log-",
+  SHIP_LOG: "josh-ship-log-",
+  SHIP_RESULT: "josh-ship-result-",
+  LANE_DISPATCH: "josh-lane-dispatch-",
+  LANE_PLAN: "josh-lane-plan-"
+};
+var PREFIXES = Object.values(PREFIX);
+var ensured = /* @__PURE__ */ new Set();
+function prepare(directory) {
+  mkdirSync(directory, { recursive: true, mode: STATE_DIRECTORY_MODE });
+  durable_state_migrate.copy_once(PLATFORM_TEMP_ROOT, directory, PREFIXES);
+  durable_state_migrate.prune_stale_logs(directory, PREFIXES, Date.now());
+}
+function ensure(directory) {
+  if (ensured.has(directory)) return directory;
+  try {
+    prepare(directory);
+  } catch {
+    return PLATFORM_TEMP_ROOT;
+  }
+  ensured.add(directory);
+  return directory;
+}
+function durable_path(prefix, key_root, suffix) {
+  return path2.join(ensure(root()), stamp_file.stamp_name(prefix, key_root, suffix));
+}
+var durable_state = {
+  PREFIX,
+  STATE_DIRECTORY_MODE,
+  ensure,
+  path: durable_path,
+  root,
+  root_for,
+  state_root
+};
+
+// scripts/josh/process-identity.ts
+import { execFileSync, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync, rmSync as rmSync2 } from "node:fs";
+import { createServer } from "node:net";
+import path3 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();
+  rmSync2(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(target2) {
+  return createServer().on("error", ignore_beacon_error).listen(target2);
+}
+function try_bind_beacon(bind, target2) {
+  try {
+    const server = bind(target2);
+    return server.listening ? server : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function open_beacon(bind = bind_beacon) {
+  const target2 = path3.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
+  const token = `${BEACON_SCHEME}${target2}`;
+  const server = try_bind_beacon(bind, target2);
+  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, platform = process.platform) {
+  const start = read_start(process.pid, probes);
+  if (start !== void 0 || platform === 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 target2 = token.slice(BEACON_SCHEME.length);
+  if (path3.dirname(target2) !== PLATFORM_TEMP_ROOT) return void 0;
+  return is_valid_beacon_name(path3.basename(target2)) ? target2 : void 0;
+}
+function run_socket_probe(target2, kill_after_ms = PROBE_TIMEOUT_MS) {
+  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target2], {
+    stdio: "ignore",
+    timeout: kill_after_ms
+  }).status ?? void 0;
+}
+function is_live_beacon(target2, probe = run_socket_probe) {
+  const status = probe(target2);
+  if (status === BEACON_LIVE_STATUS) return true;
+  return status === BEACON_GONE_STATUS ? false : void 0;
+}
+function has_matching_start(pid, recorded_start, read) {
+  const observed = read(pid);
+  return observed === void 0 ? void 0 : observed === recorded_start;
+}
+function matches_recorded_start(pid, recorded_start, read) {
+  const target2 = beacon_target(recorded_start);
+  return target2 === void 0 ? has_matching_start(pid, recorded_start, read) : is_live_beacon(target2);
+}
+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, read = 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, read);
+}
+function is_present_process(pid, recorded_start, read = read_start) {
+  if (!is_present_pid(pid)) return false;
+  if (recorded_start === void 0) return void 0;
+  return matches_recorded_start(pid, recorded_start, read);
+}
+function is_own_process(pid, recorded_start) {
+  return pid === process.pid && recorded_start === own_start();
+}
+var process_identity = {
+  PROBE_ENVIRONMENT,
+  START_PROBES,
+  START_TIME_FORMAT,
+  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,
+  run_socket_probe
+};
+
+// 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(issue2) {
+  if (!is_issue_number(issue2)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue2}`);
+}
+function single_of(positionals) {
+  const [issue_number, ...rest] = positionals;
+  const is_single = rest.length === 0 && issue_number !== void 0;
+  return is_single && ISSUE_NUMBER_PATTERN.test(issue_number) ? issue_number : void 0;
+}
+var issue_number_shape = {
+  ISSUE_NUMBER_PATTERN,
+  is_issue_number,
+  require_issue_number,
+  single_of
+};
+
+// 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 COUNT_PATTERN = /^\d+$/u;
+var POSITIVE_PATTERN = /^[1-9]\d*$/u;
+function to_integer(raw, pattern) {
+  if (raw === void 0 || !pattern.test(raw)) return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+function to_count(raw) {
+  return to_integer(raw, COUNT_PATTERN);
+}
+function to_positive(raw) {
+  return to_integer(raw, POSITIVE_PATTERN);
+}
+function read_positive_setting(raw, name, fallback) {
+  const trimmed = raw?.trim() ?? "";
+  if (trimmed === "") return { kind: "limit", limit: fallback };
+  const limit = to_positive(trimmed);
+  if (limit !== void 0) return { kind: "limit", limit };
+  return { kind: "problem", problem: `${name} must be a positive integer, not "${trimmed}"` };
+}
+var cli_flags = {
+  to_count,
+  to_positive,
+  read_positive_setting,
+  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/run/run-invocation.ts
+var BACKLOG_COMMAND = "backlogrun";
+var KNOWN_FLAGS = ["--max", "--idle"];
+var ONLY_FLAG = "--only";
+var OPTIONS = {
+  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_FLAGS.find((known) => cli_flags.option_name(known) === token.name);
+  const value = cli_flags.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 issue2 = Number(digits);
+  return Number.isSafeInteger(issue2) ? issue2 : void 0;
+}
+function issues_of(tokens) {
+  const issues = [];
+  for (const token of tokens) {
+    const issue2 = issue_of(token.value ?? "");
+    if (issue2 === void 0) return void 0;
+    issues.push(issue2);
+  }
+  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: OPTIONS,
+    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(issue2) {
+  return `${ISSUE_PREFIX}${String(issue2)}`;
+}
+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((issue2) => issue_token(issue2)),
+    ...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((issue2, index) => sequence.indexOf(issue2) === 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(target2, carry, additions) {
+  const next = { ...carry, added: next_added(carry, additions) };
+  stamp_file.replace_stamp(target2, 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, issue2) {
+  if (issue2 === void 0) return carry.merged_issues;
+  const current = carry.merged_issues ?? [];
+  return current.includes(issue2) ? current : [...current, issue2];
+}
+function is_duplicate_merge(carry, change) {
+  const issue2 = change.merged_issue;
+  return issue2 !== void 0 && carry.merged_issues?.includes(issue2) === 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(target2, 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(target2, 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 path6 from "node:path";
+
+// scripts/cost-runtime/cost-transcript.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path5 from "node:path";
+
+// scripts/lane/lane-paths.ts
+import path4 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_root) {
+  const name = path4.basename(repository_root);
+  return path4.join(path4.dirname(repository_root), `.${name}${LANE_DIRECTORY_SUFFIX}`);
+}
+function lane_root(repository_root, environment = process.env) {
+  const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
+  return configured.length === 0 ? default_lane_root(repository_root) : path4.resolve(configured);
+}
+function lane_directory(root2, issue2) {
+  return path4.join(root2, issue2);
+}
+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 path4.resolve(configured) === directory;
+  return DEFAULT_LANE_ROOT_PATTERN.test(path4.basename(directory));
+}
+var CLAUDE_WORKTREES_PATTERN = /[/\\]\.claude[/\\]worktrees[/\\][^/\\]+(?:[/\\].*)?$/u;
+function checkout_of(directory) {
+  return directory.replace(CLAUDE_WORKTREES_PATTERN, "");
+}
+function lane_issue_of(directory, environment = process.env) {
+  const resolved = checkout_of(path4.resolve(directory));
+  const issue2 = path4.basename(resolved);
+  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue2)) return void 0;
+  return is_lane_root(path4.dirname(resolved), environment) ? issue2 : void 0;
+}
+function issue_here(directory = process.cwd(), environment = process.env) {
+  const lane = lane_issue_of(directory, environment);
+  return lane === void 0 ? void 0 : Number(lane);
+}
+function lane_branch(issue2) {
+  return `${issue2}${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,
+  checkout_of,
+  default_lane_root,
+  is_lane_entry,
+  issue_here,
+  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(path12) {
+  try {
+    return readFileSync2(path12, "utf8");
+  } catch (error) {
+    if (is_absent(error)) return void 0;
+    throw error;
+  }
+}
+function read_file_or_empty(path12) {
+  return read_optional(path12) ?? "";
+}
+function read_if_readable(path12) {
+  try {
+    return readFileSync2(path12, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var file_reader = { is_absent, 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 record2 of records) {
+    const seen = by_id.get(record2.request_id);
+    const at_ms = later_instant(seen?.at_ms, record2.at_ms);
+    by_id.set(record2.request_id, { ...seen ?? record2, 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 record2 of records) total = add_totals(total, record2.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 = path5.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 path5.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(path5.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 === "" ? "" : path5.resolve(cwd, gitdir);
+  const segment = absolute.indexOf(WORKTREE_SEGMENT);
+  return segment === NOT_FOUND2 ? cwd : absolute.slice(0, segment);
+}
+function read_directory(directory) {
+  try {
+    return readdirSync2(directory);
+  } catch {
+    return [];
+  }
+}
+function lane_transcript_directories(main_cwd, home) {
+  const projects = path5.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) => path5.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(path5.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
+}
+function unit_directory(directory, session_id) {
+  return path5.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(
+      path5.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,
+  lane_transcript_directories,
+  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) => path6.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 = durable_state.PREFIX.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 durable_state.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(target2) {
+  return classify2(stamp_file.read_stamp_text(target2));
+}
+function owner_of(pid, read = process_identity.read_start, transcript = run_carry_conversation.own_transcript()) {
+  return { pid, start: read(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(target2, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
+  const carry = fresh_carry(invocation, owner, now);
+  return stamp_file.create_stamp(target2, carry) ? carry : void 0;
+}
+function adopt_carry(target2, 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(target2);
+  return stamp_file.create_stamp(target2, next) ? next : void 0;
+}
+function is_owner_live(carry, now = /* @__PURE__ */ new Date(), same_process = process_identity.is_same_process) {
+  if (same_process(carry.owner_pid, carry.owner_start) !== false) return true;
+  return carry.is_owner_headless !== true && 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(target2) {
+  stamp_file.remove_stamp(target2);
+}
+function retrospective_done_of(read) {
+  return read.kind === "carried" && read.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((issue2) => !done.includes(issue2));
+}
+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
+};
+
+// scripts/lane/lane-ledger-write.ts
+import { closeSync, constants as constants2, openSync, writeSync } from "node:fs";
+
+// scripts/lane/lane-ledger-schema.ts
+import { z as z4 } from "zod";
+
+// scripts/lane/lane-ledger-kind.ts
+var KIND = {
+  MERGE: "merge",
+  GATE: "gate",
+  LOAD: "load",
+  DISPATCH: "dispatch",
+  STAGE: "stage",
+  STOP: "stop",
+  OVERLAP: "overlap",
+  HELD: "held",
+  RELEASED: "released",
+  ROUND_ONE: "round-one",
+  ROUND_TWO: "round-two",
+  OFFERABLE: "offerable",
+  CORE_WAIT: "core-wait",
+  UNIT_FILES: "unit-files",
+  TEST_RELATED: "test-related",
+  TEST_PINNED: "test-pinned",
+  SPLIT_NOTICE: "split-notice",
+  SPLIT_FILED: "split-filed",
+  UNPLANNED_NOTICE: "unplanned-notice",
+  LANE_STATE: "lane-state",
+  PUSH_MISS: "push-miss",
+  SHIP_LAP: "ship-lap"
+};
+var lane_ledger_kind = { KIND };
+
+// scripts/lane/lane-ledger-schema-ship.ts
+import { z as z3 } from "zod";
+var { KIND: KIND2 } = lane_ledger_kind;
+var stop_schema = z3.object({
+  kind: z3.literal(KIND2.STOP),
+  at: z3.string(),
+  issue: z3.number(),
+  reason: z3.string(),
+  cause: z3.string().optional(),
+  preconditions: z3.array(z3.string()).optional(),
+  findings: z3.array(z3.string()).optional()
+});
+var unplanned_notice_schema = z3.object({
+  kind: z3.literal(KIND2.UNPLANNED_NOTICE),
+  at: z3.string(),
+  issue: z3.number(),
+  files: z3.array(z3.string())
+});
+var ship_lap_schema = z3.object({
+  kind: z3.literal(KIND2.SHIP_LAP),
+  at: z3.string(),
+  issue: z3.number(),
+  stage: z3.string(),
+  step: z3.string(),
+  elapsed_ms: z3.number()
+});
+var lane_ledger_schema_ship = { ship_lap_schema, stop_schema, unplanned_notice_schema };
+
+// scripts/lane/lane-ledger-schema.ts
+var { KIND: KIND3 } = lane_ledger_kind;
+var { ship_lap_schema: ship_lap_schema2, stop_schema: stop_schema2, unplanned_notice_schema: unplanned_notice_schema2 } = lane_ledger_schema_ship;
+var merge_schema = z4.object({ kind: z4.literal(KIND3.MERGE), at: z4.string(), issue: z4.number() });
+var check_schema = z4.object({
+  label: z4.string(),
+  elapsed_ms: z4.number(),
+  is_passed: z4.boolean(),
+  is_reused: z4.boolean().optional(),
+  // The CPU milliseconds the check's process tree spent, so a core weight can be re-measured from
+  // the ledger (joshuafolkken/kit#4362). Absent where the gate could not read it (off macOS).
+  cpu_ms: z4.number().optional(),
+  // Why the unit leg ran the whole suite instead of the related tests — a stable kind, never the
+  // file it names (joshuafolkken/kit#4397). Absent when it narrowed, and on every other check.
+  fallback: z4.string().optional(),
+  // The unit leg's since-green no-op: nothing moved, so it ran no test (joshuafolkken/kit#4457).
+  is_unmoved: z4.boolean().optional(),
+  // The width the check asked the core budget for, the width it ran at and how long it waited, so a
+  // unit claim's wait for room is read per run (joshuafolkken/kit#4451). Absent on a check that
+  // claimed none — a reused one, or one inside another gate's claim.
+  claim: z4.object({ requested: z4.number(), granted: z4.number(), waited_ms: z4.number() }).optional()
+});
+var gate_schema = z4.object({
+  kind: z4.literal(KIND3.GATE),
+  at: z4.string(),
+  elapsed_ms: z4.number(),
+  is_passed: z4.boolean(),
+  // The unit suite's own duration, present when this gate ran it — the one
+  // record of a full vitest run `josh metrics` reads, so the suite is never timed twice.
+  unit_ms: z4.number().optional(),
+  // The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
+  // whichever was higher. Absent when the machine could not be read.
+  external_cores: z4.number().optional(),
+  // Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
+  // on. A reused check started no process: its row says so, and its zero is no timing.
+  checks: z4.array(check_schema).optional(),
+  // A gate that reused a green record for this tree and base and started no check: counted, never
+  // timed (joshuafolkken/kit#4397).
+  is_reused: z4.boolean().optional(),
+  // The lane the gate ran in, so `josh lane:breakdown` puts its checks under the lane's ship gate;
+  // absent outside a lane and on a row written before it (joshuafolkken/kit#5319).
+  issue: z4.number().optional()
+});
+var process_kind_schema = z4.object({
+  kind: z4.string(),
+  cpu_percent: z4.number(),
+  rss_mb: z4.number(),
+  count: z4.number()
+});
+var load_schema = z4.object({
+  kind: z4.literal(KIND3.LOAD),
+  at: z4.string(),
+  load: z4.number(),
+  available_mb: z4.number().optional(),
+  swapped_mb: z4.number().optional(),
+  lanes: z4.number().optional(),
+  // The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
+  // core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
+  processes: z4.array(process_kind_schema).optional()
+});
+var dispatch_schema = z4.object({
+  kind: z4.literal(KIND3.DISPATCH),
+  at: z4.string(),
+  issue: z4.number()
+});
+var stage_schema = z4.object({
+  kind: z4.literal(KIND3.STAGE),
+  at: z4.string(),
+  stage: z4.string(),
+  elapsed_ms: z4.number(),
+  issue: z4.number().optional(),
+  last_check: z4.string().optional(),
+  check_ms: z4.record(z4.string(), z4.number()).optional()
+});
+var overlap_schema = z4.object({
+  kind: z4.literal(KIND3.OVERLAP),
+  at: z4.string(),
+  issue: z4.number(),
+  lanes: z4.array(z4.number()),
+  paths: z4.array(z4.string()),
+  waited_ms: z4.number(),
+  is_cleared: z4.boolean()
+});
+var held_schema = z4.object({
+  kind: z4.literal(KIND3.HELD),
+  at: z4.string(),
+  reason: z4.string(),
+  waiting: z4.array(z4.number()).optional()
+});
+var released_schema = z4.object({ kind: z4.literal(KIND3.RELEASED), at: z4.string() });
+var lane_state_schema = z4.object({
+  kind: z4.literal(KIND3.LANE_STATE),
+  at: z4.string(),
+  issue: z4.number(),
+  state: z4.enum(["paused", "running"])
+});
+var round_one_schema = z4.object({
+  kind: z4.literal(KIND3.ROUND_ONE),
+  at: z4.string(),
+  issue: z4.number(),
+  verdict: z4.string()
+});
+var round_two_schema = z4.object({
+  kind: z4.literal(KIND3.ROUND_TWO),
+  at: z4.string(),
+  issue: z4.number(),
+  verdict: z4.string(),
+  code: z4.string()
+});
+var offerable_schema = z4.object({
+  kind: z4.literal(KIND3.OFFERABLE),
+  at: z4.string(),
+  is_offerable: z4.boolean()
+});
+var core_wait_schema = z4.object({
+  kind: z4.literal(KIND3.CORE_WAIT),
+  at: z4.string(),
+  command: z4.string(),
+  waited_ms: z4.number(),
+  issue: z4.number().optional()
+});
+var unit_file_schema = z4.object({ file: z4.string(), elapsed_ms: z4.number() });
+var unit_files_schema = z4.object({
+  kind: z4.literal(KIND3.UNIT_FILES),
+  at: z4.string(),
+  files: z4.array(unit_file_schema)
+});
+var test_related_schema = z4.object({
+  kind: z4.literal(KIND3.TEST_RELATED),
+  at: z4.string(),
+  scope: z4.string(),
+  changed: z4.number(),
+  synced: z4.number(),
+  since_map: z4.number(),
+  readers: z4.number(),
+  test_files: z4.number().optional(),
+  trigger_files: z4.array(z4.string()).optional(),
+  elapsed_ms: z4.number()
+});
+var pinned_origin_schema = z4.enum(["run-review", "pre-detach", "manual"]);
+var test_pinned_probe_schema = z4.object({
+  file: z4.string(),
+  tests: z4.number().optional(),
+  elapsed_ms: z4.number()
+});
+var test_pinned_schema = z4.object({
+  kind: z4.literal(KIND3.TEST_PINNED),
+  at: z4.string(),
+  issue: z4.number().optional(),
+  held: z4.number(),
+  rewired: z4.number().optional(),
+  probes: z4.array(test_pinned_probe_schema),
+  elapsed_ms: z4.number(),
+  origin: pinned_origin_schema.optional(),
+  discarded: z4.boolean().optional()
+});
+var split_notice_schema = z4.object({
+  kind: z4.literal(KIND3.SPLIT_NOTICE),
+  at: z4.string(),
+  issue: z4.number(),
+  files: z4.number(),
+  lines: z4.number()
+});
+var split_filed_schema = z4.object({
+  kind: z4.literal(KIND3.SPLIT_FILED),
+  at: z4.string(),
+  issue: z4.number(),
+  child: z4.string()
+});
+var push_miss_schema = z4.object({
+  kind: z4.literal(KIND3.PUSH_MISS),
+  at: z4.string(),
+  scope: z4.enum(["whole", "related"]),
+  reason: z4.string()
+});
+var entry_schema = z4.discriminatedUnion("kind", [
+  merge_schema,
+  gate_schema,
+  load_schema,
+  dispatch_schema,
+  stage_schema,
+  stop_schema2,
+  overlap_schema,
+  held_schema,
+  released_schema,
+  round_one_schema,
+  round_two_schema,
+  offerable_schema,
+  core_wait_schema,
+  unit_files_schema,
+  test_related_schema,
+  test_pinned_schema,
+  split_notice_schema,
+  split_filed_schema,
+  unplanned_notice_schema2,
+  lane_state_schema,
+  push_miss_schema,
+  ship_lap_schema2
+]);
+var lane_ledger_schema = { KIND: KIND3, entry_schema, pinned_origin_schema };
+
+// scripts/lane/lane-ledger-write.ts
+var LEDGER_PREFIX = durable_state.PREFIX.LANE_LEDGER;
+var LEDGER_SUFFIX = ".jsonl";
+var LINE_SEPARATOR = "\n";
+var CI_WAIT_STAGE = "ci-wait";
+var CODERABBIT_WAIT_STAGE = "coderabbit-wait";
+var CODERABBIT_RATE_LIMIT_STAGE = "coderabbit-rate-limit";
+var CODERABBIT_RETRIGGER_STAGE = "coderabbit-retriggered";
+var PRE_DETACH_STAGE = "pre-detach";
+var ROUND_ONE_REUSED = "reused";
+var LEDGER_FILE_MODE = 384;
+var { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants2;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var { KIND: KIND4 } = lane_ledger_schema;
+function target_of(repository) {
+  return durable_state.path(LEDGER_PREFIX, repository, LEDGER_SUFFIX);
+}
+async function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? void 0 : target_of(repository);
+  } catch {
+    return void 0;
+  }
+}
+function append(path12, entry) {
+  const descriptor = openSync(path12, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (stamp_file.is_own_regular_file(path12)) {
+      writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
+    }
+  } finally {
+    closeSync(descriptor);
+  }
+}
+async function record(entry, path12) {
+  try {
+    const destination = path12 ?? await target();
+    if (destination !== void 0) append(destination, entry);
+  } catch {
+  }
+}
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function record_gate(path12, gate) {
+  await record({ kind: KIND4.GATE, at: now_iso(), ...gate }, path12);
+}
+async function record_merge(issue2, at = /* @__PURE__ */ new Date()) {
+  await record({ kind: KIND4.MERGE, at: at.toISOString(), issue: issue2 });
+}
+async function record_dispatch(issue2, path12) {
+  await record({ kind: KIND4.DISPATCH, at: now_iso(), issue: issue2 }, path12);
+}
+async function record_stage(stage, path12) {
+  await record({ kind: KIND4.STAGE, at: now_iso(), ...stage }, path12);
+}
+async function record_stop(stop, path12) {
+  await record({ kind: KIND4.STOP, at: now_iso(), ...stop }, path12);
+}
+async function record_overlap(overlap, path12) {
+  await record({ kind: KIND4.OVERLAP, at: now_iso(), ...overlap }, path12);
+}
+async function record_held(held, path12) {
+  const waiting = held.waiting ?? [];
+  const named = waiting.length > 0 ? { waiting: [...waiting] } : {};
+  await record({ kind: KIND4.HELD, at: now_iso(), reason: held.reason, ...named }, path12);
+}
+async function record_released(path12) {
+  await record({ kind: KIND4.RELEASED, at: now_iso() }, path12);
+}
+async function record_lane_state(change, path12) {
+  await record({ kind: KIND4.LANE_STATE, at: now_iso(), ...change }, path12);
+}
+async function record_offerable(is_offerable, path12) {
+  await record({ kind: KIND4.OFFERABLE, at: now_iso(), is_offerable }, path12);
+}
+async function record_round_one(round_one, path12) {
+  await record({ kind: KIND4.ROUND_ONE, at: now_iso(), ...round_one }, path12);
+}
+async function record_round_two(round_two, path12) {
+  await record({ kind: KIND4.ROUND_TWO, at: now_iso(), ...round_two }, path12);
+}
+async function record_core_wait(wait, path12) {
+  await record({ kind: KIND4.CORE_WAIT, at: now_iso(), ...wait }, path12);
+}
+async function record_unit_files(files, path12) {
+  await record({ kind: KIND4.UNIT_FILES, at: now_iso(), files: [...files] }, path12);
+}
+async function record_test_related(run, path12) {
+  await record({ kind: KIND4.TEST_RELATED, at: now_iso(), ...run }, path12);
+}
+async function record_test_pinned(run, path12) {
+  await record({ kind: KIND4.TEST_PINNED, at: now_iso(), ...run }, path12);
+}
+async function record_split_notice(notice, path12) {
+  await record({ kind: KIND4.SPLIT_NOTICE, at: now_iso(), ...notice }, path12);
+}
+async function record_split_filed(filed, path12) {
+  await record({ kind: KIND4.SPLIT_FILED, at: now_iso(), ...filed }, path12);
+}
+async function record_push_miss(miss, path12) {
+  await record({ kind: KIND4.PUSH_MISS, at: now_iso(), ...miss }, path12);
+}
+async function record_ship_lap(lap, path12) {
+  await record({ kind: KIND4.SHIP_LAP, at: now_iso(), ...lap }, path12);
+}
+async function record_unplanned_notice(notice, path12) {
+  await record({ kind: KIND4.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path12);
+}
+var lane_ledger_write = {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND4,
+  LINE_SEPARATOR,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  append,
+  record,
+  record_core_wait,
+  record_dispatch,
+  record_gate,
+  record_held,
+  record_lane_state,
+  record_released,
+  record_merge,
+  record_overlap,
+  record_offerable,
+  record_push_miss,
+  record_round_one,
+  record_round_two,
+  record_ship_lap,
+  record_split_filed,
+  record_split_notice,
+  record_stage,
+  record_stop,
+  record_test_pinned,
+  record_test_related,
+  record_unit_files,
+  record_unplanned_notice,
+  target,
+  target_of
+};
+
+// scripts/issue/issue-cite.ts
+var GITHUB_URL_PREFIX = "https://github.com/";
+var ISSUE_PATH = "/issues/";
+var SUMMARY_SEPARATOR = " \u2014 ";
+var REPO_QUALIFIED = /^([^\s/#]+\/[^\s/#]+)#(\d+)$/u;
+var BARE_NUMBER = /^#?(\d+)$/u;
+function plain(number, repo = "") {
+  return `${repo}#${String(number)}`;
+}
+function issue_url(slug, number) {
+  return `${GITHUB_URL_PREFIX}${slug}${ISSUE_PATH}${number}`;
+}
+function citation_line(slug, number, summary) {
+  return `[${plain(number)}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`;
+}
+function reference(slug, number, title) {
+  if (slug === void 0) return plain(number);
+  return title === void 0 ? `[${plain(number)}](${issue_url(slug, number)})` : citation_line(slug, number, title);
+}
+function citer(slug, titles) {
+  return function cite(number) {
+    return reference(slug, number, titles.get(number));
+  };
+}
+function qualified_target(token) {
+  const match = REPO_QUALIFIED.exec(token);
+  if (match === null) return void 0;
+  const [, repo = "", number = ""] = match;
+  return { number, repo };
+}
+function bare_target(token, default_repo) {
+  const match = BARE_NUMBER.exec(token);
+  if (match === null) return void 0;
+  const [, number = ""] = match;
+  return { number, repo: default_repo };
+}
+function parse_target(token, default_repo) {
+  return qualified_target(token) ?? bare_target(token, default_repo);
+}
+function label(target2) {
+  return plain(target2.number, target2.repo);
+}
+function missing_line(target2) {
+  return `\u2716 ${label(target2)}: issue does not resolve \u2014 check the number and the repository`;
+}
+function unreadable_line(target2) {
+  return `\u2716 ${label(target2)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
+}
+function no_repo_line(target2) {
+  return `\u2716 ${label(target2)}: could not read this repository \u2014 check gh auth and the origin remote`;
+}
+var issue_cite = {
+  citation_line,
+  citer,
+  issue_url,
+  missing_line,
+  no_repo_line,
+  parse_target,
+  plain,
+  reference,
+  unreadable_line
+};
+
+// scripts/run/ship/run-ship-stage.ts
+import { z as z5 } from "zod";
+var STAGE = {
+  PREFLIGHT: "preflight",
+  REVIEW: "review",
+  GATE: "gate",
+  SYNC: "sync",
+  COMMIT: "commit",
+  ROUND_TWO: "round-2",
+  FOLLOWUP: "followup",
+  REPORT: "report"
+};
+var PHASE = {
+  START: "start",
+  DONE: "done",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var RECORD_PREFIX = "josh-ship-stages-";
+var RECORD_SEPARATOR = "-";
+var SKIP_COMMIT_FLAG = "--skip-commit";
+var SKIP_PUSH_FLAG = "--skip-push";
+var WORD_SEPARATOR = " ";
+var STARTED_SEPARATOR = ",";
+var STARTED_INDEX = 3;
+var WORD_COUNT = STARTED_INDEX + 1;
+var REASON_SEPARATOR = " | ";
+var record_schema = z5.object({
+  done: z5.array(z5.string()),
+  started: z5.array(z5.string()).default([]),
+  is_merge_waiting: z5.boolean().default(false),
+  is_place_waiting: z5.boolean().default(false)
+});
+var EMPTY_RECORD = {
+  done: [],
+  started: [],
+  is_merge_waiting: false,
+  is_place_waiting: false
+};
+function record_path(repository, issue2) {
+  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue2}${RECORD_SEPARATOR}`, repository);
+}
+function parse_record(raw) {
+  return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
+}
+function read_record(target2) {
+  const raw = stamp_file.read_stamp_text(target2);
+  return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
+}
+function read_done(target2) {
+  return new Set(read_record(target2).done);
+}
+function mark_done(target2, stage) {
+  const record2 = read_record(target2);
+  stamp_file.replace_stamp(target2, { ...record2, done: [.../* @__PURE__ */ new Set([...record2.done, stage])] });
+}
+function read_started(target2) {
+  return read_record(target2).started;
+}
+function mark_started(target2, stage) {
+  const record2 = read_record(target2);
+  stamp_file.replace_stamp(target2, { ...record2, started: [.../* @__PURE__ */ new Set([...record2.started, stage])] });
+}
+function end_attempt(target2) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), started: [], is_merge_waiting: false });
+}
+function read_merge_waiting(target2) {
+  return read_record(target2).is_merge_waiting;
+}
+function mark_merge_waiting(target2, is_merge_waiting) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), is_merge_waiting });
+}
+function read_place_waiting(target2) {
+  return read_record(target2).is_place_waiting;
+}
+function mark_place_waiting(target2, is_place_waiting) {
+  stamp_file.replace_stamp(target2, { ...read_record(target2), is_place_waiting });
+}
+function clear_waits(target2) {
+  stamp_file.replace_stamp(target2, {
+    ...read_record(target2),
+    is_merge_waiting: false,
+    is_place_waiting: false
+  });
+}
+function clear(target2) {
+  stamp_file.remove_stamp(target2);
+}
+function is_shipped(state) {
+  return state.is_committed && state.is_pushed;
+}
+var DONE_BY = {
+  // The preflight asks what the commit stage would refuse on, so a commit is
+  // its output; a resumed commit stage still asks `git -y`'s own preflight.
+  [STAGE.PREFLIGHT]: (done, state) => state.is_merged || done.has(STAGE.PREFLIGHT) && state.is_committed,
+  // The sync stage commits locally before the review round and the gate, without pushing
+  // (`run-ship-sync.ts`), so a commit is neither's output: a pushed one on a clean tree is, as only the
+  // commit stage after the gate pushes — unless the issue changed since.
+  [STAGE.REVIEW]: (done, state) => state.is_merged || done.has(STAGE.REVIEW) && is_shipped(state) && state.is_review_stale !== true,
+  [STAGE.GATE]: (done, state) => state.is_merged || done.has(STAGE.GATE) && is_shipped(state),
+  // The merge of the default branch before the gate: once pushed, a default branch that
+  // moved is the followup's to merge again.
+  [STAGE.SYNC]: (done, state) => state.is_merged || done.has(STAGE.SYNC) && is_shipped(state),
+  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
+  // The round-2 pass reads the pushed fix delta, so its record is honored only
+  // while that push still stands — new work pushed on top reruns it.
+  [STAGE.ROUND_TWO]: (done, state) => state.is_merged || done.has(STAGE.ROUND_TWO) && is_shipped(state),
+  // A recorded followup still needs the shipped state: a record left by a merged ship whose report
+  // failed must not pass over the followup of new, not-yet-pushed work on the same issue.
+  [STAGE.FOLLOWUP]: (done, state) => state.is_merged || done.has(STAGE.FOLLOWUP) && is_shipped(state),
+  [STAGE.REPORT]: (done) => done.has(STAGE.REPORT)
+};
+function is_done(stage, done, state, has_body = false) {
+  if (has_body && stage === STAGE.COMMIT && !state.is_merged) return false;
+  return DONE_BY[stage](done, state);
+}
+function commit_flags(state) {
+  if (!state.is_committed) return [];
+  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
+}
+function event_text(issue2, stage, phase, started = []) {
+  const words = [issue_cite.plain(issue2), stage, phase];
+  const listed = [...new Set(started)].join(STARTED_SEPARATOR);
+  const full = started.length > 0 ? [...words, listed] : words;
+  return full.join(WORD_SEPARATOR);
+}
+function with_reason(text2, reason) {
+  return reason === void 0 ? text2 : `${text2}${REASON_SEPARATOR}${reason}`;
+}
+function words_part(text2) {
+  return text2.split(REASON_SEPARATOR, 1)[0] ?? "";
+}
+function started_of(text2) {
+  return words_part(text2).split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
+}
+function words_of(text2) {
+  const [, stage = "", phase = ""] = words_part(text2).split(WORD_SEPARATOR, WORD_COUNT);
+  return { stage, phase };
+}
+function reason_of(text2) {
+  const at = text2.indexOf(REASON_SEPARATOR);
+  return at === -1 ? void 0 : text2.slice(at + REASON_SEPARATOR.length);
+}
+var CONFLICT = "conflict";
+function stop_reason(stage, conflicts = []) {
+  return conflicts.length > 0 ? CONFLICT : stage;
+}
+var run_ship_stage = {
+  CONFLICT,
+  PHASE,
+  STAGE,
+  clear,
+  clear_waits,
+  commit_flags,
+  end_attempt,
+  event_text,
+  is_done,
+  is_shipped,
+  mark_done,
+  mark_merge_waiting,
+  mark_place_waiting,
+  mark_started,
+  read_done,
+  read_merge_waiting,
+  read_place_waiting,
+  read_started,
+  reason_of,
+  record_path,
+  started_of,
+  with_reason,
+  words_of,
+  stop_reason
+};
+
+// scripts/git/repository-lock.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { linkSync, renameSync, rmSync as rmSync3 } from "node:fs";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// scripts/josh/process-owner.ts
+import { z as z6 } from "zod";
+var process_owner_schema = z6.object({ pid: z6.number(), process_start: z6.string().optional() });
+
+// scripts/git/repository-lock.ts
+var POLL_INTERVAL_MS = 200;
+var SYNC_POLL_INTERVAL_MS = 10;
+var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function lock_path(prefix, cwd) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
+}
+function parse_owner(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
+}
+function read_owner(target2) {
+  return parse_owner(stamp_file.read_stamp_text(target2));
+}
+function is_owner_gone(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
+}
+function restore(aside, target2) {
+  try {
+    linkSync(aside, target2);
+  } catch {
+  }
+}
+function stale_record(target2, is_gone) {
+  const raw = stamp_file.read_stamp_text(target2);
+  const owner = parse_owner(raw);
+  return owner !== void 0 && is_gone(owner) ? raw : void 0;
+}
+function move_aside(target2) {
+  const aside = `${target2}.${String(process.pid)}.${randomUUID2()}`;
+  try {
+    renameSync(target2, aside);
+    return aside;
+  } catch {
+    return void 0;
+  }
+}
+function clear_stale(target2, is_gone = is_owner_gone) {
+  const raw = stale_record(target2, is_gone);
+  if (raw === void 0) return;
+  const aside = move_aside(target2);
+  if (aside === void 0) return;
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target2);
+  rmSync3(aside, { force: true });
+}
+function claim(target2) {
+  clear_stale(target2);
+  return stamp_file.create_stamp(target2, process_identity.own_fields());
+}
+function release(target2) {
+  const owner = read_owner(target2);
+  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
+    stamp_file.remove_stamp(target2);
+  }
+}
+async function acquire(target2, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target2)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(POLL_INTERVAL_MS);
+  }
+  return true;
+}
+function sleep_sync(ms) {
+  Atomics.wait(SLEEP_CELL, 0, 0, ms);
+}
+function acquire_sync(target2, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target2)) {
+    if (Date.now() >= deadline) return false;
+    sleep_sync(SYNC_POLL_INTERVAL_MS);
+  }
+  return true;
+}
+async function with_lock(work, target2, max_wait_ms) {
+  if (!await acquire(target2, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target2);
+  }
+}
+function with_lock_sync(work, target2, max_wait_ms) {
+  if (!acquire_sync(target2, max_wait_ms)) return void 0;
+  try {
+    return work();
+  } finally {
+    release(target2);
+  }
+}
+var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
+
+// scripts/run/event/run-event-stream.ts
+import { z as z7 } from "zod";
+var EVENT_PREFIX = durable_state.PREFIX.EVENTS;
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 15e3;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR2 = "\n";
+var WORD_SEPARATOR2 = " ";
+var STAGE_PHASE_INDEX = 2;
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var EVENT_KIND = {
+  PLAN: "plan",
+  CHILD_LAUNCH: "child-launch",
+  MERGE: "merge",
+  PARK: "park",
+  SPLIT: "split",
+  OUTAGE: "outage",
+  // A Claude usage limit stopped a lane child (joshuafolkken/kit#4745). Its text names the reset time,
+  // which `backlog:drive` reads to hold launches until then; it counts against no streak, so it is not an
+  // `OUTAGE`.
+  USAGE_LIMIT: "usage-limit",
+  CUT: "cut",
+  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
+  // resume clears the cut record, so without this the `cut` would stay the newest position and
+  // `run:step` would keep answering the resume command it had just run.
+  RESUME: "resume",
+  // A person stopped a running lane child and re-dispatched its issue in a fresh session
+  // (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
+  // the board, and — like that launch — a batch record a lane child never reads as its own position.
+  RESTART: "restart",
+  // A person withdrew a lane child — stopped it and left its issue open for the next run (`lane:withdraw`).
+  // It is written before the stop, so `run:merge` settles the child as withdrawn whatever GitHub says
+  // by the time the parent collects it, and counts it as neither a merge, a failure nor an outage.
+  WITHDRAW: "withdraw",
+  // The backlog emptied while nothing of the run's own was in flight — the drain. 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. 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. Emitted once per stall episode by the stop-time detector, it is both the dedup marker —
+  // `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes — 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. Emitted once per strand episode by the stop-time detector — or by the `run:wake`
+  // supervisor as it fails, leaves that state behind and has warned of it —
+  // 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. 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. Printed only to
+  // the watcher's own output, a headless successor's heartbeat would be 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. 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
+  // 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",
+  // The relaunch meant to answer a `SHIP_STOP` started nothing — the broker refused it, or the direct
+  // spawn failed (joshuafolkken/kit#4765). `run:merge` reads it, not the transcript's mtime, to tell the
+  // stop went unanswered, and a re-dispatch cap's park names its reason. A trace: the stop stays the
+  // position `run:step` answers.
+  RELAUNCH_FAILED: "relaunch-failed",
+  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
+  // still surfaces what it found — `run:board`'s findings section reads it.
+  FILED: "filed",
+  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
+  // same section.
+  NOTE: "note",
+  // A lane child reached a phase no other event marks — its first implementation edit, written by the
+  // PreToolUse hook — so `run:board` draws how far the child has got. A trace,
+  // like `SHIP_STAGE`: it says where the child's work is, not where the run is.
+  LANE_PHASE: "lane-phase",
+  // An issue `run:add` put into the live run. The parent's `--wait` watcher
+  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
+  // trace: it says what the run was handed, not where the run is.
+  ADD: "add",
+  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
+  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
+  // already holds. A trace: it says the run gained room, not where the run is.
+  LANE_LIMIT: "lane-limit",
+  // One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
+  // lane opening (`run-event-setup.ts`). `run:board` draws it while the run stands at it, so the
+  // minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
+  // getting ready, not where the run is.
+  SETUP: "setup",
+  // A child's pull request checks as `josh followup` last polled them — the CI counts and CodeRabbit's
+  // state (`run-event-checks.ts`), written only when they change, so `run:board` draws a child waiting
+  // in followup without asking GitHub (joshuafolkken/kit#3770). A trace: it says how the checks stand,
+  // not where the run is.
+  PR_CHECKS: "pr-checks",
+  // `backlog:drive` reached a watch with no child running and nothing to dispatch — the point a person's
+  // hand is wanted. Emitted once per idle episode (`emit_once_since_with`, reset by `CHILD_LAUNCH`), it
+  // is the dedup marker for the one idle Telegram. A trace: a drain's retrospective is read off the
+  // position beneath it, so the marker must not stand over it.
+  IDLE_NOTICE: "idle-notice",
+  // A person paused or resumed a lane child (`lane:pause` / `lane:resume`), so who halted a lane and
+  // when is on the stream rather than only in a shell history (joshuafolkken/kit#4268). A trace: it
+  // says what a lane's processes were told, not where the run is.
+  LANE_STATE: "lane-state",
+  // `backlog:drive` found nothing of the run in flight and only paused lanes left, paused past the
+  // silent window (joshuafolkken/kit#4270). Emitted once per pause episode (`emit_once_since_with`,
+  // reset by `LANE_STATE`), it is the dedup marker for the one paused-lane Telegram. A trace.
+  PAUSED_NOTICE: "paused-notice",
+  // `backlog:drive` ran a due issue's measurement declaration itself, found it within its bound and
+  // closed the issue through `issue:measured` — no lane was launched for it (joshuafolkken/kit#4621).
+  // `run:board` draws it merged. A trace: the parent's position is the drive's, not this close.
+  MEASURED: "measured",
+  // The host slept while `backlog:drive` sampled its load (joshuafolkken/kit#5032): the sampler's timer
+  // ran late by more than a few intervals. `at` is the wake and `elapsed_ms` how long the sleep
+  // lasted; every lane's net time takes it out (`lane-sleep.ts`). A trace.
+  SLEEP: "sleep"
+};
+var EVENT_KINDS = Object.values(EVENT_KIND);
+var TRACE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.FILED,
+  EVENT_KIND.NOTE,
+  EVENT_KIND.LANE_PHASE,
+  EVENT_KIND.ADD,
+  EVENT_KIND.LANE_LIMIT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS,
+  EVENT_KIND.IDLE_NOTICE,
+  EVENT_KIND.LANE_STATE,
+  EVENT_KIND.PAUSED_NOTICE,
+  EVENT_KIND.MEASURED,
+  EVENT_KIND.RELAUNCH_FAILED,
+  EVENT_KIND.SLEEP
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS
+]);
+var event_schema = z7.object({
+  pos: z7.number(),
+  at: z7.string(),
+  kind: z7.string(),
+  text: z7.string(),
+  // The child's time on a lane, recorded once by the writer of an ending (joshuafolkken/kit#4481), so a
+  // reader never has to find its launch again. An event written before it has none. A `sleep` event
+  // carries the sleep's length here.
+  elapsed_ms: z7.number().optional()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of2(repository) {
+  return durable_state.path(EVENT_PREFIX, repository, EVENT_SUFFIX);
+}
+function is_present(event) {
+  return event !== void 0;
+}
+function parse_line2(line) {
+  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function read_lines(target2) {
+  const raw = stamp_file.read_stamp_text(target2);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR2).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line2(line)).filter(is_present);
+}
+function read_events(target2) {
+  return read_lines(target2).filter((event) => is_event_kind(event.kind));
+}
+function last_position(events) {
+  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
+}
+function issue_of2(event) {
+  return event.text.split(WORD_SEPARATOR2)[FIRST_POSITION] ?? "";
+}
+function newest_by_issue(events, kind) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind === kind) newest.set(issue_of2(event), event);
+  }
+  return new Set(newest.values());
+}
+function is_stage_start(event) {
+  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
+  return event.text.split(WORD_SEPARATOR2)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
+}
+function drawn_lines(events) {
+  const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP);
+  return /* @__PURE__ */ new Set([
+    ...newest_by_issue(events, EVENT_KIND.SHIP_STAGE),
+    ...newest_by_issue(events, EVENT_KIND.PR_CHECKS),
+    ...setup === void 0 ? [] : [setup]
+  ]);
+}
+function droppable(events) {
+  const kept = drawn_lines(events);
+  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
+  return [
+    ...disposable.filter((event) => !is_stage_start(event)),
+    ...disposable.filter((event) => is_stage_start(event))
+  ];
+}
+function bounded(events) {
+  const excess = events.length - EVENT_CAP;
+  if (excess <= 0) return events;
+  const dropped = new Set(droppable(events).slice(0, excess));
+  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
+}
+function serialize(events) {
+  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR2)}${LINE_SEPARATOR2}`;
+}
+function append_held(target2, event) {
+  const position = last_position(read_lines(target2)) + POSITION_INCREMENT;
+  const events = bounded([...read_events(target2), { pos: position, ...event }]);
+  stamp_file.replace_text_stamp(target2, serialize(events));
+  return position;
+}
+function append_event(target2, event) {
+  if (!is_event_kind(event.kind)) return { appended: false, position: FIRST_POSITION };
+  const lock = `${target2}${LOCK_SUFFIX}`;
+  const position = repository_lock.with_lock_sync(
+    () => append_held(target2, event),
+    lock,
+    LOCK_WAIT_MS
+  );
+  if (position === void 0) {
+    const message = `run event stream: gave up waiting for the lock at ${lock}`;
+    process.stderr.write(`${message}
+`);
+    throw new Error(message);
+  }
+  return { appended: true, position };
+}
+function append2(target2, kind, text2, at) {
+  return append_event(target2, { at, kind, text: text2 });
+}
+function read_from(target2, position) {
+  const events = read_events(target2);
+  return {
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
+  };
+}
+function read_last(target2) {
+  return read_events(target2).findLast((event) => !TRACE_KINDS.has(event.kind));
+}
+function has_since(events, kind, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT).some((event) => event.kind === kind);
+}
+var FIELD_SEPARATOR = " \xB7 ";
+function format_event(event) {
+  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
+}
+var run_event_stream = {
+  EVENT_CAP,
+  EVENT_KIND,
+  EVENT_KINDS,
+  TRACE_KINDS,
+  append: append2,
+  append_event,
+  format_event,
+  has_since,
+  is_stage_start,
+  read_events,
+  read_from,
+  read_last,
+  target_of: target_of2
+};
+
+// scripts/rules/issue-citation.ts
+var ISSUE_NUMBER = /#\d+/gu;
+var REFERENCE_BOUNDARY = /[\s#()[\]<>|]/u;
+var OWNER_REPO = /^[^\s/#]+\/[^\s/#]+$/u;
+var MARKDOWN_LINK = /\[[^[\]]*\]\([^()]*\)/gu;
+var NUMBER_CONTINUATION = /^(?:\w|-[a-z])/iu;
+var CONTINUATION_WIDTH = 2;
+var GLUED_LEAD = /[&./]/u;
+var FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u;
+var QUOTE_LINE = /^\s*>/u;
+var PR_PREFIX = /\b(?:pr|pull request)\s*$/iu;
+var BACKTICK_PAIR = 2;
+function link_covers(link, index) {
+  const start = link.index ?? 0;
+  return index >= start && index < start + link[0].length;
+}
+function is_linked_at(line, index) {
+  for (const link of line.matchAll(MARKDOWN_LINK)) {
+    if (link_covers(link, index)) return true;
+  }
+  return false;
+}
+function lead_token(message, hash_index) {
+  let start = hash_index;
+  while (start > 0 && !REFERENCE_BOUNDARY.test(message.charAt(start - 1))) start -= 1;
+  return message.slice(start, hash_index);
+}
+function repo_prefix(message, hash_index) {
+  const token = lead_token(message, hash_index);
+  return OWNER_REPO.test(token) ? token : "";
+}
+function is_inline_code_at(line, index) {
+  const backticks = line.slice(0, index).split("`").length - 1;
+  return backticks % BACKTICK_PAIR === 1;
+}
+function is_bare_at(line, index) {
+  if (is_linked_at(line, index) || is_inline_code_at(line, index)) return false;
+  return !PR_PREFIX.test(line.slice(0, index));
+}
+function is_glued(line, reference2) {
+  const end = reference2.index + reference2.text.length;
+  if (NUMBER_CONTINUATION.test(line.slice(end, end + CONTINUATION_WIDTH))) return true;
+  return reference2.prefix === "" && GLUED_LEAD.test(lead_token(line, reference2.index));
+}
+function line_references(line) {
+  const references = [];
+  for (const match of line.matchAll(ISSUE_NUMBER)) {
+    const reference2 = { index: match.index, prefix: repo_prefix(line, match.index), text: match[0] };
+    if (!is_glued(line, reference2) && is_bare_at(line, match.index)) references.push(reference2);
+  }
+  return references;
+}
+function collect_line_references(line, found) {
+  for (const reference2 of line_references(line)) found.push(`${reference2.prefix}${reference2.text}`);
+}
+function lines_outside_fences(message) {
+  const lines = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    else if (!is_in_fence) lines.push(line);
+  }
+  return lines;
+}
+function prose_lines(message) {
+  return lines_outside_fences(message).filter((line) => !QUOTE_LINE.test(line));
+}
+function bare_references(message) {
+  const found = [];
+  for (const line of prose_lines(message)) collect_line_references(line, found);
+  return [...new Set(found)];
+}
+function has_bare_reference(message) {
+  return bare_references(message).length > 0;
+}
+function reference_link(reference2, default_slug) {
+  const slug = reference2.prefix === "" ? default_slug : reference2.prefix;
+  const number = reference2.text.slice(1);
+  return `[${reference2.prefix}${reference2.text}](${issue_cite.issue_url(slug, number)})`;
+}
+function linkify_line(line, slug) {
+  let result = "";
+  let cursor = 0;
+  for (const reference2 of line_references(line)) {
+    const start = reference2.index - reference2.prefix.length;
+    result += line.slice(cursor, start) + reference_link(reference2, slug);
+    cursor = reference2.index + reference2.text.length;
+  }
+  return result + line.slice(cursor);
+}
+function rewrite_line(line, slug, is_in_fence) {
+  if (is_in_fence || FENCE_MARKER.test(line) || QUOTE_LINE.test(line)) return line;
+  return linkify_line(line, slug);
+}
+function linkify(message, slug) {
+  const out = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    out.push(rewrite_line(line, slug, is_in_fence));
+  }
+  return out.join("\n");
+}
+var issue_citation = {
+  bare_references,
+  has_bare_reference,
+  linkify,
+  prose_lines
+};
+
+// scripts/issue/session-cite.ts
+function session_repo() {
+  const url = repo_discovery.read_origin_url(process.cwd());
+  const identity = url === void 0 ? void 0 : repo_origin.parse_origin_url(url);
+  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
+}
+function issue(number, title, repo = session_repo()) {
+  return issue_cite.reference(repo, String(number), title);
+}
+function text(message) {
+  const repo = session_repo();
+  return repo === void 0 ? message : issue_citation.linkify(message, repo);
+}
+var session_cite = {
+  issue,
+  session_repo,
+  text
+};
+
+// scripts/lane/lane-state.ts
+import { readdirSync as readdirSync3 } from "node:fs";
+import path7 from "node:path";
+
+// scripts/lib/figure-format.ts
+var USD_DECIMALS = 4;
+var PERCENT_SCALE = 100;
+var PERCENT_DECIMALS = 1;
+var MINUTE_DECIMALS = 1;
+var CLOCK_WIDTH = 2;
+var CLOCK_PAD = "0";
+function format_usd(usd, decimals = USD_DECIMALS) {
+  return `$${usd.toFixed(decimals)}`;
+}
+function format_tokens(count) {
+  return count.toLocaleString("en-US");
+}
+function format_share(part, whole) {
+  if (whole === 0) return "n/a";
+  return `${(part / whole * PERCENT_SCALE).toFixed(PERCENT_DECIMALS)}%`;
+}
+function format_minutes(duration_ms) {
+  return `${(duration_ms / MS_PER_MINUTE).toFixed(MINUTE_DECIMALS)} min`;
+}
+function two_digits(value) {
+  return String(value).padStart(CLOCK_WIDTH, CLOCK_PAD);
+}
+function clock_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((value) => two_digits(value)).join(":");
+}
+function minute_of(ms) {
+  const date = new Date(ms);
+  return [date.getHours(), date.getMinutes()].map((value) => two_digits(value)).join(":");
+}
+var figure_format = {
+  format_usd,
+  format_tokens,
+  format_share,
+  format_minutes,
+  two_digits,
+  clock_of,
+  minute_of
+};
+
+// scripts/lane/lane-state.ts
+import { z as z8 } from "zod";
+var STATE_PREFIX = durable_state.PREFIX.LANE_STATE;
+var STATE_SUFFIX = ".json";
+var LOCK_SUFFIX2 = ".lock";
+var LOCK_WAIT_MS2 = 5e3;
+var LANE_STATES = ["open", "running", "paused", "ended"];
+var NO_STATE_HINT = "no lane state \u2014 counted in use";
+var lane_run_schema = z8.object({ started_at: z8.string(), owner_pid: z8.number().optional() });
+var stuck_schema = z8.object({ pid: z8.number(), reason: z8.string() });
+var lane_state_schema2 = z8.object({
+  issue: z8.string(),
+  run: lane_run_schema.optional(),
+  state: z8.enum(LANE_STATES),
+  launched_at: z8.string().optional(),
+  changed_at: z8.string(),
+  changed_by: z8.string(),
+  stuck: z8.array(stuck_schema).optional()
+});
+var TRANSITIONS = {
+  open: ["open", "running", "ended"],
+  running: ["running", "paused", "ended"],
+  paused: ["paused", "running", "ended"],
+  ended: ["ended", "open"]
+};
+function state_path(directory, issue2) {
+  return durable_state.path(STATE_PREFIX, directory, `-${issue2}${STATE_SUFFIX}`);
+}
+function is_allowed(from, to) {
+  return from === void 0 || TRANSITIONS[from].includes(to);
+}
+function read_record2(directory, issue2) {
+  const raw = stamp_file.read_stamp_text(state_path(directory, issue2));
+  return raw === void 0 ? void 0 : json_value.parse_with(raw, lane_state_schema2);
+}
+function write_record(directory, record2) {
+  stamp_file.replace_stamp(state_path(directory, record2.issue), record2);
+}
+function current_run(directory) {
+  const carried = run_carry.read_carry(run_carry.carry_path(directory));
+  if (carried.kind !== "carried") return void 0;
+  return { started_at: carried.carry.started_at, owner_pid: carried.carry.owner_pid };
+}
+function launch_fields(change, directory, now) {
+  if (change.is_launch !== true) return {};
+  return { run: current_run(directory), launched_at: now.toISOString() };
+}
+function next_record(change, previous, directory, now) {
+  return {
+    // An open starts a fresh life: a reopened lane keeps nothing of the run that launched it before.
+    ...change.state !== "open" && previous,
+    issue: change.issue,
+    state: change.state,
+    changed_at: now.toISOString(),
+    changed_by: change.command,
+    ...launch_fields(change, directory, now)
+  };
+}
+function apply_held(change, directory, now) {
+  const previous = read_record2(directory, change.issue);
+  if (!is_allowed(previous?.state, change.state)) {
+    return { kind: "skipped", reason: `no ${previous?.state ?? ""} \u2192 ${change.state} transition` };
+  }
+  const record2 = next_record(change, previous, directory, now);
+  write_record(directory, record2);
+  return { kind: "written", record: record2 };
+}
+var NO_DIRECTORY = { kind: "skipped", reason: "no git directory" };
+function locked(directory, issue2, held) {
+  const lock = `${state_path(directory, issue2)}${LOCK_SUFFIX2}`;
+  const outcome = repository_lock.with_lock_sync(held, lock, LOCK_WAIT_MS2);
+  return outcome ?? { kind: "skipped", reason: `gave up waiting for the lock at ${lock}` };
+}
+function apply(change, directory, now) {
+  return locked(directory, change.issue, () => apply_held(change, directory, now));
+}
+function warn(change, reason) {
+  console.warn(
+    `${change.command} ${session_cite.issue(change.issue)}: lane state not recorded \u2014 ${reason}`
+  );
+}
+async function resolve_directory(directory) {
+  return directory ?? await run_carry.repository_directory();
+}
+async function outcome_of(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  return apply(change, directory, options.now ?? /* @__PURE__ */ new Date());
+}
+async function settled(write) {
+  try {
+    return await write();
+  } catch (error) {
+    return { kind: "skipped", reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function record_change(change, options = {}) {
+  const outcome = await settled(async () => await outcome_of(change, options));
+  if (outcome.kind === "skipped") warn(change, outcome.reason);
+  return outcome;
+}
+async function read_state(issue2, directory) {
+  const root2 = await resolve_directory(directory);
+  return root2 === void 0 ? void 0 : read_record2(root2, issue2);
+}
+function recorded_issues(directory) {
+  const empty = state_path(directory, "");
+  const head = path7.basename(empty).slice(0, -STATE_SUFFIX.length);
+  return readdirSync3(path7.dirname(empty)).filter((name) => name.startsWith(head) && name.endsWith(STATE_SUFFIX)).map((name) => name.slice(head.length, -STATE_SUFFIX.length)).filter((issue2) => issue2.length > 0);
+}
+async function read_records(directory) {
+  const root2 = await resolve_directory(directory);
+  if (root2 === void 0) return [];
+  const records = recorded_issues(root2).map((issue2) => read_record2(root2, issue2));
+  return records.filter((record2) => record2 !== void 0);
+}
+function stuck_held(issue2, stuck, directory) {
+  const previous = read_record2(directory, issue2);
+  if (previous === void 0) return { kind: "skipped", reason: "no record" };
+  const record2 = { ...previous, stuck };
+  write_record(directory, record2);
+  return { kind: "written", record: record2 };
+}
+async function record_stuck(issue2, stuck, directory) {
+  const root2 = await resolve_directory(directory);
+  if (root2 === void 0) return NO_DIRECTORY;
+  return locked(root2, issue2, () => stuck_held(issue2, stuck, root2));
+}
+function adopted_held(change, directory, now) {
+  if (read_record2(directory, change.issue) !== void 0) {
+    return { kind: "skipped", reason: "a record exists" };
+  }
+  return apply_held(change, directory, now);
+}
+async function adopted_outcome(change, options) {
+  const directory = await resolve_directory(options.directory);
+  if (directory === void 0) return NO_DIRECTORY;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  return locked(directory, change.issue, () => adopted_held(change, directory, now));
+}
+async function record_adopted(change, options = {}) {
+  return await settled(async () => await adopted_outcome(change, options));
+}
+async function read_states(issues, directory) {
+  const root2 = await resolve_directory(directory);
+  if (root2 === void 0) return /* @__PURE__ */ new Map();
+  const read = issues.map((issue2) => [
+    issue2,
+    read_record2(root2, issue2)
+  ]);
+  return new Map(read.filter((entry) => entry[1] !== void 0));
+}
+function paused_text(since_ms, changed_by) {
+  return `paused since ${figure_format.minute_of(since_ms)} by ${changed_by}`;
+}
+function paused_note(record2) {
+  if (record2?.state !== "paused") return void 0;
+  return paused_text(Date.parse(record2.changed_at), record2.changed_by);
+}
+var lane_state = {
+  LANE_STATES,
+  NO_STATE_HINT,
+  is_allowed,
+  paused_note,
+  paused_text,
+  read_records,
+  read_state,
+  read_states,
+  record_adopted,
+  record_change,
+  record_stuck,
+  state_path
+};
+
+// scripts/run/event/run-event-scope.ts
+var SINCE_SCOPE = "since";
+var UNKNOWN_SCOPE = "unknown";
+var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
+function moment_of(at) {
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
+}
+function scoped_events(events, scope) {
+  if (scope.kind === UNKNOWN_SCOPE) return void 0;
+  const floor = moment_of(scope.started_at);
+  if (floor === void 0) return void 0;
+  return events.filter((event) => is_within(event, floor));
+}
+function scope_of(read) {
+  if (read.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
+  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
+}
+function last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
+}
+var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+  run_event_stream.EVENT_KIND.SHIP_STOP
+]);
+var KIND5 = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND5.CHILD_LAUNCH,
+  KIND5.RESTART,
+  KIND5.WITHDRAW,
+  KIND5.PARK,
+  KIND5.SPLIT,
+  KIND5.RETROSPECTIVE,
+  KIND5.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue2) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue2)} `);
+}
+function is_own_ship_event(event, issue2) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue2);
+}
+function issue_named(event) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1];
+}
+function names_issue(event, issue2) {
+  return issue_named(event) === issue2;
+}
+function is_lane_position(event, issue2) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue2);
+}
+function since_own_launch(events, issue2) {
+  const launch = events.findLastIndex(
+    (event) => event.kind === KIND5.CHILD_LAUNCH && names_issue(event, issue2)
+  );
+  return events.slice(launch + 1);
+}
+function is_foreign_event(event, issue2, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue2);
+  return is_foreign_ship_event(event, issue2);
+}
+function last_issue_event(events, scope, issue2, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue2) : events;
+  const own = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
+  return own.findLast((event) => is_own_ship_event(event, issue2));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND5.CHILD_LAUNCH,
+  KIND5.MERGE,
+  KIND5.PARK,
+  KIND5.SPLIT,
+  KIND5.WITHDRAW
+]);
+function is_merge_owed(events, scope, issue2) {
+  const newest = (scoped_events(events, scope) ?? []).findLast(
+    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue2)
+  );
+  return newest?.kind === KIND5.CHILD_LAUNCH;
+}
+function is_launch_or_withdrawal(event, issue2) {
+  const is_kind = event.kind === KIND5.CHILD_LAUNCH || event.kind === KIND5.WITHDRAW;
+  return is_kind && names_issue(event, issue2);
+}
+function is_withdrawn(events, issue2) {
+  const newest = events.findLast((event) => is_launch_or_withdrawal(event, issue2));
+  return newest?.kind === KIND5.WITHDRAW;
+}
+var run_event_scope = {
+  UNKNOWN_EVENT_SCOPE,
+  is_merge_owed,
+  is_withdrawn,
+  issue_named,
+  last_issue_event,
+  last_scoped_event,
+  moment_of,
+  scope_of,
+  scoped_events,
+  since_own_launch
+};
+
+// scripts/lane/lane-spans.ts
+function next_start_ms(starts, issue2, from_ms) {
+  const later = starts.filter((other) => other.issue === issue2 && other.at_ms > from_ms);
+  return Math.min(...later.map((other) => other.at_ms));
+}
+function issue_spans(pair) {
+  return pair.starts.map((start) => {
+    const until_ms = next_start_ms(pair.bounds, start.issue, start.at_ms);
+    return {
+      from_ms: start.at_ms,
+      end_ms: pair.ends.find(
+        (end) => end.issue === start.issue && end.at_ms >= start.at_ms && end.at_ms < until_ms
+      )?.at_ms
+    };
+  });
+}
+var lane_spans = { issue_spans };
+
+// scripts/run/board/run-board-lane-time.ts
+var KIND6 = run_event_stream.EVENT_KIND;
+var LAUNCH_KINDS = /* @__PURE__ */ new Set([KIND6.CHILD_LAUNCH, KIND6.RESTART]);
+var OFF_LANE_KINDS = /* @__PURE__ */ new Set([
+  KIND6.MERGE,
+  KIND6.PARK,
+  KIND6.WITHDRAW,
+  KIND6.OUTAGE,
+  KIND6.USAGE_LIMIT,
+  KIND6.SPLIT,
+  KIND6.STOP
+]);
+function moments_of(events, kinds) {
+  return events.filter((event) => kinds.has(event.kind)).map((event) => ({
+    issue: Number(run_event_scope.issue_named(event)),
+    at_ms: Date.parse(event.at)
+  }));
+}
+function spans_of(events) {
+  const launches = moments_of(events, LAUNCH_KINDS);
+  const ends = moments_of(events, OFF_LANE_KINDS);
+  const issues = new Set(launches.map((launch) => launch.issue));
+  return new Map(
+    [...issues].map((issue2) => {
+      const starts = launches.filter((launch) => launch.issue === issue2);
+      return [issue2, lane_spans.issue_spans({ starts, bounds: starts, ends })];
+    })
+  );
+}
+function span_ms(span, until_ms, end_ms) {
+  return Math.max(0, Math.min(span.end_ms ?? until_ms, end_ms) - span.from_ms);
+}
+function in_lane_ms(spans, end_ms) {
+  return spans.reduce(
+    (total, span, index) => total + span_ms(span, spans[index + 1]?.from_ms ?? end_ms, end_ms),
+    0
+  );
+}
+function elapsed_of(spans, started_ms, ended_ms) {
+  return spans.length === 0 ? ended_ms - started_ms : in_lane_ms(spans, ended_ms);
+}
+function launched_ms(record2) {
+  const launched_at = record2?.launched_at;
+  return launched_at === void 0 ? void 0 : Date.parse(launched_at);
+}
+function counted_from(run, started_ms) {
+  return run === void 0 ? started_ms : Date.parse(run.started_at);
+}
+function is_ended(spans) {
+  return spans.at(-1)?.end_ms !== void 0;
+}
+function ending_elapsed(read) {
+  const started_ms = launched_ms(read.record);
+  if (started_ms === void 0) return void 0;
+  const from_ms = counted_from(read.record?.run, started_ms);
+  const spans = (spans_of(read.events).get(read.issue) ?? []).filter(
+    (span) => span.from_ms >= from_ms
+  );
+  return is_ended(spans) ? void 0 : elapsed_of(spans, started_ms, read.ended_ms);
+}
+var run_board_lane_time = {
+  LAUNCH_KINDS,
+  OFF_LANE_KINDS,
+  elapsed_of,
+  ending_elapsed,
+  in_lane_ms,
+  spans_of
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+function now_iso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function stream_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
+}
+async function lane_record(issue2) {
+  try {
+    return await lane_state.read_state(issue2);
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.lane_record", error);
+    return void 0;
+  }
+}
+async function ending_fields(target2, event) {
+  const issue2 = run_event_scope.issue_named(event);
+  if (issue2 === void 0 || !run_board_lane_time.OFF_LANE_KINDS.has(event.kind)) return {};
+  const elapsed_ms = run_board_lane_time.ending_elapsed({
+    events: run_event_stream.read_events(target2),
+    issue: Number(issue2),
+    record: await lane_record(issue2),
+    ended_ms: Date.parse(event.at)
+  });
+  return elapsed_ms === void 0 ? {} : { elapsed_ms };
+}
+async function append_at(target2, kind, text2, at) {
+  const event = { kind, text: text2, at: at.toISOString() };
+  return run_event_stream.append_event(target2, {
+    ...event,
+    ...await ending_fields(target2, event)
+  });
+}
+async function emit(kind, text2, at = /* @__PURE__ */ new Date()) {
+  try {
+    const target2 = await stream_target();
+    if (target2 === void 0) return;
+    await append_at(target2, kind, text2, at);
+  } catch {
+  }
+}
+async function emit_once(kind, text2) {
+  try {
+    const target2 = await stream_target();
+    if (target2 === void 0 || run_event_stream.read_last(target2)?.kind === kind) return false;
+    return run_event_stream.append(target2, kind, text2, now_iso2()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+function invocation_events(repository, target2) {
+  const events = run_event_stream.read_events(target2);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since_with(kind, reset_kind, compose) {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return void 0;
+    const target2 = run_event_stream.target_of(repository);
+    if (run_event_stream.has_since(invocation_events(repository, target2), kind, reset_kind)) {
+      return void 0;
+    }
+    const text2 = await compose();
+    return run_event_stream.append(target2, kind, text2, now_iso2()).appended ? text2 : void 0;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
+    return void 0;
+  }
+}
+async function emit_once_since(kind, text2, reset_kind) {
+  const appended = await emit_once_since_with(kind, reset_kind, async () => text2);
+  return appended !== void 0;
+}
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
+}
+async function current_events() {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return [];
+    const read = run_carry.read_carry(run_carry.carry_path(repository));
+    const scope = run_event_scope.scope_of(read);
+    const events = run_event_stream.read_events(run_event_stream.target_of(repository));
+    return run_event_scope.scoped_events(events, scope) ?? [];
+  } catch {
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
+  } catch {
+    return [];
+  }
+}
+async function all_events() {
+  try {
+    const target2 = await stream_target();
+    return target2 === void 0 ? [] : run_event_stream.read_events(target2);
+  } catch {
+    return [];
+  }
+}
+var run_event_stream_emit = {
+  all_events,
+  append_at,
+  current_events,
+  emit,
+  emit_heartbeat,
+  emit_once,
+  emit_once_since,
+  emit_once_since_with,
+  invocation_or_all_events,
+  stream_target
+};
+
+// ports/index.js
+import { existsSync as existsSync2 } from "node:fs";
+import path8 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 = path8.resolve(directory);
+  let current = start;
+  while (!existsSync2(path8.join(current, PACKAGE_FILE_NAME))) {
+    const parent = path8.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 = path8.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/josh-command-types.ts
+var OPTIONAL_ENV_FILE_FLAGS = [`--env-file-if-exists=${ENV_FILE_NAME}`];
+var ESLINT_CACHE_FILE = ".eslintcache";
+var TS_BUILD_INFO_FILE = ".tsbuildinfo";
+var CSPELL_CACHE_FILE = ".cspellcache";
+var ESLINT_EDIT_CACHE_FILE = ".eslintcache.edit";
+var ESLINT_RELATED_CACHE_FILE = ".eslintcache.related";
+var PRETTIER_CACHE_FILE = ".prettiercache";
+var PRETTIER_RELATED_CACHE_FILE = ".prettiercache.related";
+var CSPELL_COMMIT_CACHE_FILE = ".cspellcache.commit";
+var ESLINT_COMMIT_CACHE_FILE = ".eslintcache.commit";
+var ROOTED_JSON_PORTABILITY = "rooted-json";
+var ESLINT_CACHE_SPEC = {
+  cache_file: ESLINT_CACHE_FILE,
+  portability: ROOTED_JSON_PORTABILITY
+};
+var TS_CACHE_SPEC = {
+  cache_file: TS_BUILD_INFO_FILE,
+  portability: "raw"
+};
+var CSPELL_CACHE_SPEC = {
+  cache_file: CSPELL_CACHE_FILE,
+  portability: "raw"
+};
+var GATE_CACHE_SPECS = [
+  ESLINT_CACHE_SPEC,
+  TS_CACHE_SPEC,
+  CSPELL_CACHE_SPEC
+];
+var GATE_CACHE_FILES = GATE_CACHE_SPECS.map((spec) => spec.cache_file);
+var IGNORED_CACHE_FILES = [
+  ...GATE_CACHE_FILES,
+  ESLINT_EDIT_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FILE,
+  PRETTIER_CACHE_FILE,
+  PRETTIER_RELATED_CACHE_FILE,
+  CSPELL_COMMIT_CACHE_FILE,
+  ESLINT_COMMIT_CACHE_FILE
+];
+var CONTENT_CACHE_FLAGS = ["--cache", "--cache-strategy", "content"];
+var CACHE_LOCATION_FLAG = "--cache-location";
+function content_cache_flags(cache_file) {
+  return [...CONTENT_CACHE_FLAGS, CACHE_LOCATION_FLAG, cache_file];
+}
+var ESLINT_CACHE_FLAGS = content_cache_flags(ESLINT_CACHE_FILE);
+var ESLINT_EDIT_CACHE_FLAGS = content_cache_flags(ESLINT_EDIT_CACHE_FILE);
+var ESLINT_RELATED_CACHE_FLAGS = content_cache_flags(ESLINT_RELATED_CACHE_FILE);
+var CSPELL_CACHE_FLAGS = content_cache_flags(CSPELL_CACHE_FILE);
+var PRETTIER_CACHE_FLAGS = content_cache_flags(PRETTIER_CACHE_FILE);
+var PRETTIER_RELATED_CACHE_FLAGS = content_cache_flags(PRETTIER_RELATED_CACHE_FILE);
+var CSPELL_COMMIT_CACHE_FLAGS = content_cache_flags(CSPELL_COMMIT_CACHE_FILE);
+var ESLINT_COMMIT_CACHE_FLAGS = content_cache_flags(ESLINT_COMMIT_CACHE_FILE);
+
+// scripts/lib/ancestor-directories.ts
+import path9 from "node:path";
+var MAX_DEPTH = 64;
+function list(start_directory) {
+  const directories = [];
+  let current = path9.resolve(start_directory);
+  while (directories.length < MAX_DEPTH && !directories.includes(current)) {
+    directories.push(current);
+    current = path9.dirname(current);
+  }
+  return directories;
+}
+function nearest(start_directory, is_match) {
+  return list(start_directory).find((directory) => is_match(directory));
+}
+var ancestor_directories = { list, nearest };
+
+// scripts/lib/package-manifest.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import path10 from "node:path";
+var PACKAGE_JSON = "package.json";
+function manifest_path(directory) {
+  return path10.join(directory, PACKAGE_JSON);
+}
+function read_manifest(directory, schema) {
+  const text2 = readFileSync4(manifest_path(directory), "utf8");
+  return schema.parse(JSON.parse(text2));
+}
+function read_manifest_if_valid(directory, schema) {
+  const text2 = file_reader.read_if_readable(manifest_path(directory));
+  if (text2 === void 0) return void 0;
+  return json_value.parse_with(text2, schema);
+}
+var package_manifest = { manifest_path, read_manifest, read_manifest_if_valid };
+
+// scripts/gate/toolchain-inputs.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "node:fs";
+import path11 from "node:path";
+var PACKAGE_FILES = [
+  "package.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  ".npmrc",
+  "node_modules/.modules.yaml"
+];
+var CONFIG_ENTRIES = [
+  /^eslint\.config\.[cm]?[jt]s$/u,
+  /^tsconfig(?:\.[\w-]+)?\.json$/u
+];
+var CONFIG_DIRECTORIES = /* @__PURE__ */ new Set(["eslint", "tsconfig"]);
+var TEST_MARKER = ".test.";
+var SEPARATOR = "/";
+var DIGEST_ALGORITHM = "sha256";
+function by_code_unit(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function to_posix(relative) {
+  return relative.split(path11.sep).join(SEPARATOR);
+}
+function is_config_entry(name) {
+  return CONFIG_ENTRIES.some((entry) => entry.test(name));
+}
+function is_config_module(relative) {
+  const [top = ""] = relative.split(SEPARATOR, 1);
+  return CONFIG_DIRECTORIES.has(top) && !path11.basename(relative).includes(TEST_MARKER);
+}
+function is_input(relative) {
+  const posix = to_posix(relative);
+  if (PACKAGE_FILES.includes(posix)) return true;
+  return is_config_entry(posix) || is_config_module(posix);
+}
+function modules_under(root2, directory) {
+  const absolute = path11.join(root2, directory);
+  if (!existsSync3(absolute)) return [];
+  return readdirSync4(absolute, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => to_posix(path11.relative(root2, path11.join(entry.parentPath, entry.name)))).filter((relative) => is_config_module(relative));
+}
+function paths(root2) {
+  const present = PACKAGE_FILES.filter((relative) => existsSync3(path11.join(root2, relative)));
+  const entries = readdirSync4(root2).filter((name) => is_config_entry(name));
+  const modules = [...CONFIG_DIRECTORIES].flatMap((directory) => modules_under(root2, directory));
+  return [...present, ...entries, ...modules].toSorted(by_code_unit);
+}
+function read_or_empty(file) {
+  try {
+    return readFileSync5(file);
+  } catch {
+    return new Uint8Array();
+  }
+}
+function digest(root2) {
+  const hash = createHash(DIGEST_ALGORITHM);
+  for (const relative of paths(root2)) {
+    hash.update(`${relative}\0`).update(read_or_empty(path11.join(root2, relative))).update("\0");
+  }
+  return hash.digest("hex");
+}
+var toolchain_inputs = { digest, is_input, PACKAGE_FILES, paths };
+
+// scripts/git/git-schemas.ts
+import { z as z9 } from "zod";
+var package_name_schema = z9.object({ name: z9.string().min(1) });
+var rollup_item_schema = z9.looseObject({
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
+  __typename: z9.string().nullish(),
+  state: z9.string().nullish(),
+  status: z9.string().nullish(),
+  conclusion: z9.string().nullish(),
+  name: z9.string().nullish(),
+  context: z9.string().nullish(),
+  description: z9.string().nullish()
+});
+var pr_raw_schema = z9.object({
+  statusCheckRollup: z9.array(rollup_item_schema).optional(),
+  // The base branch's required status check contexts, read from its rules — empty where none are
+  // set or they could not be read (`git-gh-branch-rules.ts`).
+  requiredContexts: z9.array(z9.string()).optional(),
+  mergeStateStatus: z9.string().optional(),
+  reviewDecision: z9.string().optional(),
+  headRefOid: z9.string().optional()
+});
+var pull_comment_schema = z9.object({
+  body: z9.string().optional(),
+  html_url: z9.string().optional(),
+  user: z9.object({ login: z9.string().optional() }).optional()
+});
+var ai_review_pull_comment_schema = z9.object({
+  body: z9.string().optional(),
+  url: z9.string().optional(),
+  author: z9.object({ login: z9.string().optional() }).optional(),
+  updatedAt: z9.string().optional()
+});
+var pr_info_schema = z9.object({
+  mergeable: z9.union([z9.boolean(), z9.string()]).nullable().optional(),
+  mergeStateStatus: z9.string().nullable().optional(),
+  state: z9.string().optional()
+});
+var epic_issue_schema = z9.object({
+  number: z9.number(),
+  body: z9.string().optional(),
+  // REST answers null for an issue never closed and `reopened` for one a person reopened.
+  stateReason: z9.string().nullish()
+});
+var blocking_issue_schema = z9.object({
+  number: z9.number(),
+  state: z9.string().optional(),
+  repository_url: z9.string().optional()
+});
+var blocked_by_schema = z9.object({
+  nodes: z9.array(blocking_issue_schema).default([]),
+  totalCount: z9.number().optional()
+}).optional();
+var epic_child_schema = z9.object({
+  state: z9.string().optional(),
+  blockedBy: blocked_by_schema
+});
+var rest_comment_schema = z9.looseObject({
+  body: z9.string().nullish(),
+  html_url: z9.string().optional(),
+  user: z9.looseObject({ login: z9.string().optional() }).nullish(),
+  updated_at: z9.string().optional()
+});
+var issue_label_schema = z9.object({ name: z9.string() });
+var epic_subject_schema = z9.object({
+  number: z9.number(),
+  state: z9.string().optional(),
+  labels: z9.array(issue_label_schema).optional(),
+  body: z9.string().optional()
+});
+var author_fields_schema = {
+  author_association: z9.string().nullish(),
+  user: z9.looseObject({ login: z9.string() }).nullish()
+};
+var open_issue_schema = z9.object({
+  number: z9.number(),
+  title: z9.string(),
+  labels: z9.array(issue_label_schema).optional(),
+  createdAt: z9.string(),
+  blockedBy: blocked_by_schema,
+  // Present only on the pickup listing, which reads it for the paths each issue declares.
+  body: z9.string().optional(),
+  ...author_fields_schema,
+  // Assembled by the pickup from the author above, never read off the listing: whether the author
+  // has write access. Absent on every other listing.
+  author_trusted: z9.boolean().optional()
+});
+
+export {
+  json_value,
+  file_reader,
+  figure_format,
+  pr_raw_schema,
+  epic_issue_schema,
+  blocking_issue_schema,
+  blocked_by_schema,
+  rest_comment_schema,
+  issue_label_schema,
+  author_fields_schema,
+  open_issue_schema,
+  durable_state,
+  process_identity,
+  issue_number_shape,
+  cli_flags,
+  run_invocation,
+  lane_paths,
+  time_instant,
+  cost_usage,
+  cost_transcript,
+  agent_session_environment,
+  own_session,
+  run_carry,
+  lane_ledger_schema,
+  lane_ledger_write,
+  issue_cite,
+  process_owner_schema,
+  repository_lock,
+  run_ship_stage,
+  run_event_stream,
+  issue_citation,
+  session_cite,
+  lane_state,
+  run_event_scope,
+  run_event_stream_emit,
+  PORT_SEED_KEY,
+  LANE_SEAT_KEY,
+  ENV_FILE_NAME,
+  ports,
+  OPTIONAL_ENV_FILE_FLAGS,
+  ESLINT_RELATED_CACHE_FILE,
+  ESLINT_EDIT_CACHE_FLAGS,
+  ESLINT_RELATED_CACHE_FLAGS,
+  PRETTIER_RELATED_CACHE_FLAGS,
+  ancestor_directories,
+  PACKAGE_JSON,
+  package_manifest,
+  toolchain_inputs
+};