@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/dist/hooks/{chunk-E7OIKX5Z.js → chunk-WR2KQAYZ.js}

@@ -1,29 +1,36 @@
 import {
   GIT_TIMEOUT_MS,
+  MS_PER_MINUTE,
+  MS_PER_SECOND,
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
   SUITE_TIMEOUT_MS,
+  error_text,
   stamp_file
-} from "./chunk-DGT54IH5.js";
+} from "./chunk-AZX4FGQ3.js";
 
 // scripts/lib/json-value.ts
-function parse_or_undefined(text) {
+function parse_or_undefined(text2) {
   try {
-    return JSON.parse(text);
+    return JSON.parse(text2);
   } catch {
     return void 0;
   }
 }
-function parse_with(text, schema) {
-  const value = parse_or_undefined(text);
+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, is_record };
+var json_value = { parse_or_undefined, parse_with, parse_array, is_record };
 
 // scripts/git/constants.ts
 import { platform } from "node:os";
@@ -104,7 +111,6 @@ var git_ssh_keepalive = {
 };
 
 // scripts/git/git-push-transport.ts
-var MS_PER_SECOND = 1e3;
 var PUSH_TIMEOUT_SECONDS = 120;
 var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
 var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
@@ -155,10 +161,9 @@ async function read(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
   return stdout.trimEnd();
 }
 var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
-var MS_PER_SECOND2 = 1e3;
 function to_budget_error(command, error, timeout_ms) {
   if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
-  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND2));
+  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND));
   return new Error(`git ${command} timed out after ${seconds}s`, {
     cause: { exit_code: TIMEOUT_EXIT_CODE }
   });
@@ -220,9 +225,9 @@ async function get_default_branch() {
   }
 }
 var MERGE_BASE_COMMAND = "merge-base";
-async function reference_exists(reference) {
+async function reference_exists(reference2) {
   try {
-    await git_spawn.read(["rev-parse", "--verify", "--quiet", reference]);
+    await git_spawn.read(["rev-parse", "--verify", "--quiet", reference2]);
     return true;
   } catch {
     return false;
@@ -250,17 +255,32 @@ var NO_RENAME_DETECTION = "--no-renames";
 async function change_base_commit() {
   return await git_spawn.read(["rev-parse", await change_base()]);
 }
-async function diff_main_names() {
+async function diff_names_since(commit2) {
   return await git_spawn.read([
     ...NO_PATH_QUOTING,
     "diff",
     NAME_ONLY_FLAG,
     NO_RELATIVE_PATHS,
     NO_RENAME_DETECTION,
-    await change_base(),
+    commit2,
     "--"
   ]);
 }
+async function tree_names_at(commit2, paths) {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "ls-tree",
+    "-r",
+    NAME_ONLY_FLAG,
+    "--full-tree",
+    commit2,
+    "--",
+    ...paths
+  ]);
+}
+async function diff_main_names() {
+  return await diff_names_since(await change_base());
+}
 async function diff_cached_names() {
   return await git_spawn.read([
     ...NO_PATH_QUOTING,
@@ -303,7 +323,9 @@ var git_diff_reads = {
   diff_main,
   diff_main_names,
   diff_main_numstat,
+  diff_names_since,
   get_default_branch,
+  tree_names_at,
   untracked_names
 };
 
@@ -339,9 +361,9 @@ async function read_push_references() {
   return { branch: branch2, local_oid, remote_oid: await read_remote_oid(branch2) };
 }
 function to_stdin_line(references) {
-  const reference = `refs/heads/${references.branch}`;
+  const reference2 = `refs/heads/${references.branch}`;
   const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
-  return `${reference} ${references.local_oid} ${reference} ${remote_oid}
+  return `${reference2} ${references.local_oid} ${reference2} ${remote_oid}
 `;
 }
 function to_hook_run_arguments(stdin_path, hook_name) {
@@ -792,10 +814,10 @@ function beacon_target(token) {
   if (path2.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
   return is_valid_beacon_name(path2.basename(target)) ? target : void 0;
 }
-function run_socket_probe(target) {
+function run_socket_probe(target, kill_after_ms = PROBE_TIMEOUT_MS) {
   return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
     stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS
+    timeout: kill_after_ms
   }).status ?? void 0;
 }
 function is_live_beacon(target, probe = run_socket_probe) {
@@ -834,6 +856,9 @@ 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,
@@ -845,68 +870,29 @@ var process_identity = {
   own_fields,
   own_start,
   read_start,
-  resolve_own_start
+  resolve_own_start,
+  run_socket_probe
 };
 
-// scripts/backlog/backlog-budget-cli.ts
-import { fileURLToPath } from "node:url";
-
-// scripts/git/changed-paths.ts
-function to_paths(raw) {
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+// 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);
 }
-async function read_changed_paths(is_staged) {
-  if (is_staged) return to_paths(await git_command.diff_cached_names());
-  const tracked = to_paths(await git_command.diff_main_names());
-  const untracked = to_paths(await git_command.untracked_names());
-  return [...tracked, ...untracked];
+function require_issue_number(issue2) {
+  if (!is_issue_number(issue2)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue2}`);
 }
-var changed_paths = { read_changed_paths, to_paths };
-
-// scripts/josh/path-decision.ts
-var STAGED_FLAG = "--staged";
-var JSON_FLAG = "--json";
-var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
-var FAILURE_EXIT_CODE = 1;
-var MAX_LISTED_PATHS = 5;
-function has_unknown_flag(argv, known) {
-  return argv.some((argument) => !known.includes(argument));
-}
-function parse_options(argv) {
-  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
-  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
-}
-function format_path_list(paths) {
-  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
-  if (paths.length <= MAX_LISTED_PATHS) return listed;
-  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
-}
-function print_decision(key, answer, reason, is_json) {
-  if (is_json) {
-    console.info(JSON.stringify({ [key]: answer, reason }));
-    return;
-  }
-  console.info(answer);
-  console.error(reason);
-}
-async function run_path_decision(argv, command) {
-  const options = parse_options(argv);
-  if (options === void 0) {
-    console.error(command.usage);
-    return FAILURE_EXIT_CODE;
-  }
-  const paths = await changed_paths.read_changed_paths(options.is_staged);
-  const answer = command.decide(paths);
-  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
-  return 0;
-}
-var path_decision = {
-  format_path_list,
-  has_unknown_flag,
-  JSON_FLAG,
-  parse_options,
-  print_decision,
-  run_path_decision
+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
@@ -981,7 +967,30 @@ function attach_values(argv, flags) {
   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,
@@ -995,258 +1004,11 @@ var cli_flags = {
   is_value_unusable
 };
 
-// scripts/backlog/backlog-budget.ts
-var MS_PER_MINUTE = 6e4;
-var MINUTES_PER_HOUR = 60;
-var IDLE_WAIT_HOURS = 8;
-var DEFAULT_IDLE_MINUTES = IDLE_WAIT_HOURS * MINUTES_PER_HOUR;
-var DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE;
-var OFFER_INTERVAL_SECONDS = 60;
-var MS_PER_SECOND3 = 1e3;
-var OFFER_INTERVAL_MS = OFFER_INTERVAL_SECONDS * MS_PER_SECOND3;
-var RUN_VERDICT = "run";
-var WATCH_VERDICT = "watch";
-var STOP_VERDICT = "stop";
-var TRIAGE_VERDICT = "triage";
-var ANSWERS = ["blocked", "candidates", "exhausted", "parked", "unreadable", "untriaged"];
-var BLOCKED_REASON = "Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.";
-var TRIAGE_REASON = "An opted-in candidate carries neither `run:solo` nor `run:lane`, so nothing starts until it is judged. Read each issue named above, record its order and one of the two labels with a comment, then ask again.";
-var EMPTY_BACKLOG = "The backlog is empty";
-var WAITING_ON = {
-  exhausted: EMPTY_BACKLOG,
-  parked: "Nothing opted in can proceed without a person",
-  unreadable: "The backlog listing could not be read"
-};
-function waiting_on(answer) {
-  return WAITING_ON[answer] ?? EMPTY_BACKLOG;
-}
-function no_idle_watch_reason(answer) {
-  return `${waiting_on(answer)} and the idle watch was turned off with \`--idle 0\`, so the run finishes here.`;
-}
-function to_minutes(duration_ms) {
-  return String(Math.ceil(duration_ms / MS_PER_MINUTE));
-}
-function max_reached_reason(merged, max_issues) {
-  return `This run's maximum of ${String(max_issues)} is reached, with ${String(merged)} merged. Report what was done, including how many were picked up during an idle watch, and finish.`;
-}
-function draining_reason(running, reason) {
-  return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish \u2014 ${reason}`;
-}
-function idle_expired_reason(answer, idle_budget_ms) {
-  return `${waiting_on(answer)}, and stayed so for the whole ${to_minutes(idle_budget_ms)}-minute idle watch. Report what was done, including how many were picked up during the watch, and finish.`;
-}
-function idle_watch_reason(answer, left_ms) {
-  return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left. Release the working tree, ask again in ${String(OFFER_INTERVAL_SECONDS)} seconds, and restart the watch the moment a candidate appears.`;
-}
-function running_watch_reason(answer, running, left_ms) {
-  return `${waiting_on(answer)} and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree until they merge and poll at the polling interval \u2014 the watch is running down meanwhile.`;
-}
-function watching_reason(input, left_ms) {
-  if (input.running === 0) return idle_watch_reason(input.answer, left_ms);
-  return running_watch_reason(input.answer, input.running, left_ms);
-}
-function taken_by(input) {
-  return input.merged + input.running;
-}
-function run_reason(input) {
-  const { max_issues } = input;
-  if (max_issues === void 0) return "No maximum was given, so start every issue offered.";
-  return `Start at most ${String(max_issues - taken_by(input))} more: this run's maximum is ${String(max_issues)}, with ${String(input.merged)} merged and ${String(input.running)} running.`;
-}
-function stopping(input, reason) {
-  if (input.running === 0) return { verdict: STOP_VERDICT, reason };
-  return { verdict: WATCH_VERDICT, reason: draining_reason(input.running, reason) };
-}
-function max_decision(input) {
-  const { max_issues } = input;
-  if (max_issues === void 0 || taken_by(input) < max_issues) return void 0;
-  return stopping(input, max_reached_reason(input.merged, max_issues));
-}
-function idle_decision(input) {
-  const { idle_budget_ms } = input;
-  if (idle_budget_ms === void 0) return stopping(input, no_idle_watch_reason(input.answer));
-  const left_ms = idle_budget_ms - (input.now_ms - input.active_at_ms);
-  if (left_ms > 0) return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) };
-  return stopping(input, idle_expired_reason(input.answer, idle_budget_ms));
-}
-function is_finish(input) {
-  return input.answer === "exhausted" && max_decision(input) === void 0;
-}
-var FIXED_DECISIONS = {
-  blocked: { verdict: WATCH_VERDICT, reason: BLOCKED_REASON },
-  untriaged: { verdict: TRIAGE_VERDICT, reason: TRIAGE_REASON }
-};
-function answer_decision(input) {
-  if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
-  return FIXED_DECISIONS[input.answer] ?? idle_decision(input);
-}
-function decide(input) {
-  return max_decision(input) ?? answer_decision(input);
-}
-var backlog_budget = {
-  ANSWERS,
-  BLOCKED_REASON,
-  DEFAULT_IDLE_MINUTES,
-  DEFAULT_IDLE_MS,
-  IDLE_WAIT_HOURS,
-  MS_PER_MINUTE,
-  OFFER_INTERVAL_MS,
-  RUN_VERDICT,
-  STOP_VERDICT,
-  TRIAGE_REASON,
-  TRIAGE_VERDICT,
-  WAITING_ON,
-  WATCH_VERDICT,
-  decide,
-  draining_reason,
-  idle_expired_reason,
-  idle_watch_reason,
-  is_finish,
-  max_reached_reason,
-  no_idle_watch_reason,
-  run_reason,
-  running_watch_reason,
-  taken_by
-};
-
-// scripts/backlog/backlog-budget-cli.ts
-var ARGV_OFFSET = 2;
-var SUCCESS_EXIT_CODE2 = 0;
-var FAILURE_EXIT_CODE2 = 1;
-var JSON_KEY = "budget";
-var USAGE = `Usage: josh backlog:budget --answer <${backlog_budget.ANSWERS.join("|")}> --started <ISO-8601> [--active <ISO-8601>, required unless the watch is off] [--merged <count>] [--running <count>] [--max <count>] [--idle <minutes>, 0 to turn the watch off] [--json]`;
-var OPTIONS = {
-  active: { type: "string" },
-  answer: { type: "string" },
-  idle: { type: "string" },
-  json: { type: "boolean" },
-  max: { type: "string" },
-  merged: { type: "string" },
-  running: { type: "string" },
-  started: { type: "string" }
-};
-function read_arguments(argv) {
-  return cli_flags.values_of(argv, OPTIONS);
-}
-function to_answer(raw) {
-  return backlog_budget.ANSWERS.find((answer) => answer === raw);
-}
-function to_time_ms(raw) {
-  if (raw === void 0) return void 0;
-  const parsed = Date.parse(raw);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-var COUNT_PATTERN = /^\d+$/u;
-function to_count(raw) {
-  if (raw === void 0 || !COUNT_PATTERN.test(raw)) return void 0;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) ? parsed : void 0;
-}
-function is_readable(raw, parsed) {
-  return raw === void 0 || parsed !== void 0;
-}
-var COUNT_NAMES = ["idle", "max", "merged", "running"];
-function counts_of(values) {
-  return {
-    idle: to_count(cli_flags.string_of(values.idle)),
-    max: to_count(cli_flags.string_of(values.max)),
-    merged: to_count(cli_flags.string_of(values.merged)),
-    running: to_count(cli_flags.string_of(values.running))
-  };
-}
-function are_counts_readable(values, counts) {
-  return COUNT_NAMES.every((name) => is_readable(cli_flags.string_of(values[name]), counts[name]));
-}
-var NO_IDLE_MINUTES = 0;
-function to_idle_ms(idle_minutes) {
-  if (idle_minutes === void 0) return backlog_budget.DEFAULT_IDLE_MS;
-  if (idle_minutes === NO_IDLE_MINUTES) return void 0;
-  return idle_minutes * backlog_budget.MS_PER_MINUTE;
-}
-function is_watch_readable(values) {
-  if (to_idle_ms(to_count(cli_flags.string_of(values.idle))) === void 0) return true;
-  return cli_flags.string_of(values.active) !== void 0;
-}
-function are_values_readable(values) {
-  return is_readable(
-    cli_flags.string_of(values.active),
-    to_time_ms(cli_flags.string_of(values.active))
-  ) && is_watch_readable(values) && are_counts_readable(values, counts_of(values));
-}
-function input_of(values, base) {
-  const counts = counts_of(values);
-  return {
-    ...base,
-    active_at_ms: to_time_ms(cli_flags.string_of(values.active)) ?? base.started_at_ms,
-    merged: counts.merged ?? 0,
-    running: counts.running ?? 0,
-    max_issues: counts.max,
-    idle_budget_ms: to_idle_ms(counts.idle)
-  };
-}
-function build_input(values, now_ms) {
-  const answer = to_answer(cli_flags.string_of(values.answer));
-  if (answer === void 0) return void 0;
-  const started_at_ms = to_time_ms(cli_flags.string_of(values.started));
-  if (started_at_ms === void 0 || !are_values_readable(values)) return void 0;
-  return input_of(values, { answer, now_ms, started_at_ms });
-}
-function print_json(input, decision) {
-  const { verdict, reason } = decision;
-  const is_finish2 = backlog_budget.is_finish(input);
-  console.info(JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: is_finish2 }));
-}
-function refuse() {
-  console.error(USAGE);
-  return FAILURE_EXIT_CODE2;
-}
-function run3(argv, now_ms = Date.now()) {
-  const values = read_arguments(argv);
-  if (values === void 0) return refuse();
-  const input = build_input(values, now_ms);
-  if (input === void 0) return refuse();
-  const decision = backlog_budget.decide(input);
-  if (values.json === true) {
-    print_json(input, decision);
-    return SUCCESS_EXIT_CODE2;
-  }
-  path_decision.print_decision(JSON_KEY, decision.verdict, decision.reason, false);
-  return SUCCESS_EXIT_CODE2;
-}
-function main(argv) {
-  process.exitCode = run3(argv);
-}
-var backlog_budget_cli = {
-  JSON_KEY,
-  OPTIONS,
-  SUCCESS_EXIT_CODE: SUCCESS_EXIT_CODE2,
-  USAGE,
-  build_input,
-  main,
-  read_arguments,
-  run: run3,
-  to_answer,
-  to_count,
-  to_time_ms
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
-
-// scripts/issue/issue-number-shape.ts
-var ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u;
-var BAD_ISSUE_MESSAGE = "Not an issue number: ";
-function is_issue_number(value) {
-  return ISSUE_NUMBER_PATTERN.test(value);
-}
-function require_issue_number(issue) {
-  if (!is_issue_number(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`);
-}
-var issue_number_shape = { ISSUE_NUMBER_PATTERN, is_issue_number, require_issue_number };
-
 // scripts/run/run-invocation.ts
 var BACKLOG_COMMAND = "backlogrun";
-var KNOWN_FLAGS2 = ["--max", "--idle"];
+var KNOWN_FLAGS = ["--max", "--idle"];
 var ONLY_FLAG = "--only";
-var OPTIONS2 = {
+var OPTIONS = {
   max: { type: "string" },
   idle: { type: "string" },
   only: { type: "boolean" }
@@ -1263,8 +1025,8 @@ function tokens_of(invocation) {
 }
 function render_option(token) {
   if (token.name === cli_flags.option_name(ONLY_FLAG)) return ONLY_FLAG;
-  const flag = KNOWN_FLAGS2.find((known) => cli_flags.option_name(known) === token.name);
-  const value = backlog_budget_cli.to_count(token.value);
+  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)}`;
 }
@@ -1281,15 +1043,15 @@ function issue_of(token) {
   if (!token.startsWith(ISSUE_PREFIX)) return void 0;
   const digits = token.slice(ISSUE_PREFIX.length);
   if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(digits)) return void 0;
-  const issue = Number(digits);
-  return Number.isSafeInteger(issue) ? issue : void 0;
+  const issue2 = Number(digits);
+  return Number.isSafeInteger(issue2) ? issue2 : void 0;
 }
 function issues_of(tokens) {
   const issues = [];
   for (const token of tokens) {
-    const issue = issue_of(token.value ?? "");
-    if (issue === void 0) return void 0;
-    issues.push(issue);
+    const issue2 = issue_of(token.value ?? "");
+    if (issue2 === void 0) return void 0;
+    issues.push(issue2);
   }
   return issues;
 }
@@ -1298,7 +1060,7 @@ function argument_tokens(invocation) {
   if (tokens[FIRST_TOKEN] !== BACKLOG_COMMAND) return void 0;
   return cli_flags.parse_or_undefined({
     args: tokens.slice(FIRST_ARGUMENT_INDEX),
-    options: OPTIONS2,
+    options: OPTIONS,
     allowPositionals: true,
     tokens: true
   })?.tokens;
@@ -1313,8 +1075,8 @@ function parse(invocation) {
   if (issues === void 0 || flags === void 0) return void 0;
   return { issues, flags };
 }
-function issue_token(issue) {
-  return `${ISSUE_PREFIX}${String(issue)}`;
+function issue_token(issue2) {
+  return `${ISSUE_PREFIX}${String(issue2)}`;
 }
 function joined(command, rendered) {
   return [command, ...rendered].join(TOKEN_SEPARATOR);
@@ -1323,7 +1085,7 @@ function rebuild(invocation) {
   const parsed = parse(invocation);
   if (parsed === void 0) return void 0;
   return joined(BACKLOG_COMMAND, [
-    ...parsed.issues.map((issue) => issue_token(issue)),
+    ...parsed.issues.map((issue2) => issue_token(issue2)),
     ...parsed.flags
   ]);
 }
@@ -1353,7 +1115,7 @@ function issues_of2(added, is_priority) {
 }
 function ordered(declared, added = []) {
   const sequence = [...issues_of2(added, true), ...declared, ...issues_of2(added, false)];
-  return sequence.filter((issue, index) => sequence.indexOf(issue) === index);
+  return sequence.filter((issue2, index) => sequence.indexOf(issue2) === index);
 }
 function next_added(carry, additions) {
   const next = [...carry.added ?? []];
@@ -1416,14 +1178,14 @@ function next_done(carry, done) {
   const current = carry.done ?? [];
   return current.includes(done) ? current : [...current, done];
 }
-function next_merged_issues(carry, issue) {
-  if (issue === void 0) return carry.merged_issues;
+function next_merged_issues(carry, issue2) {
+  if (issue2 === void 0) return carry.merged_issues;
   const current = carry.merged_issues ?? [];
-  return current.includes(issue) ? current : [...current, issue];
+  return current.includes(issue2) ? current : [...current, issue2];
 }
 function is_duplicate_merge(carry, change) {
-  const issue = change.merged_issue;
-  return issue !== void 0 && carry.merged_issues?.includes(issue) === true;
+  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];
@@ -1484,8 +1246,8 @@ function lane_root(repository_root2, environment = process.env) {
   const configured = environment[LANE_ROOT_KEY]?.trim() ?? "";
   return configured.length === 0 ? default_lane_root(repository_root2) : path3.resolve(configured);
 }
-function lane_directory(root, issue) {
-  return path3.join(root, issue);
+function lane_directory(root, issue2) {
+  return path3.join(root, issue2);
 }
 var DEFAULT_LANE_ROOT_PATTERN = new RegExp(String.raw`^\..+${LANE_DIRECTORY_SUFFIX}$`, "u");
 function is_lane_root(directory, environment) {
@@ -1495,12 +1257,12 @@ function is_lane_root(directory, environment) {
 }
 function lane_issue_of(directory, environment = process.env) {
   const resolved = path3.resolve(directory);
-  const issue = path3.basename(resolved);
-  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) return void 0;
-  return is_lane_root(path3.dirname(resolved), environment) ? issue : void 0;
+  const issue2 = path3.basename(resolved);
+  if (!issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue2)) return void 0;
+  return is_lane_root(path3.dirname(resolved), environment) ? issue2 : void 0;
 }
-function lane_branch(issue) {
-  return `${issue}${LANE_BRANCH_SUFFIX}`;
+function lane_branch(issue2) {
+  return `${issue2}${LANE_BRANCH_SUFFIX}`;
 }
 var SEAT_LOCK_DIR = ".seat-locks";
 function is_lane_entry(name) {
@@ -1524,25 +1286,25 @@ var ABSENT_CODE = "ENOENT";
 function is_absent(error) {
   return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
 }
-function read_optional(path7) {
+function read_optional(path11) {
   try {
-    return readFileSync2(path7, "utf8");
+    return readFileSync2(path11, "utf8");
   } catch (error) {
     if (is_absent(error)) return void 0;
     throw error;
   }
 }
-function read_file_or_empty(path7) {
-  return read_optional(path7) ?? "";
+function read_file_or_empty(path11) {
+  return read_optional(path11) ?? "";
 }
-function read_if_readable(path7) {
+function read_if_readable(path11) {
   try {
-    return readFileSync2(path7, "utf8");
+    return readFileSync2(path11, "utf8");
   } catch {
     return void 0;
   }
 }
-var file_reader = { read_optional, read_file_or_empty, read_if_readable };
+var file_reader = { is_absent, read_optional, read_file_or_empty, read_if_readable };
 
 // scripts/time-runtime/time-instant.ts
 function parse_instant(raw) {
@@ -1734,9 +1496,9 @@ function lane_transcript_directories(main_cwd, home) {
   ).map((name) => path4.join(projects, name));
 }
 function transcript_directories(cwd, home = homedir()) {
-  const own = transcript_directory(cwd, home);
+  const own2 = transcript_directory(cwd, home);
   const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
-  return [.../* @__PURE__ */ new Set([own, ...lanes])];
+  return [.../* @__PURE__ */ new Set([own2, ...lanes])];
 }
 var OWN_DEPTH = 0;
 function home_directory() {
@@ -1797,9 +1559,9 @@ function list_sessions(directory) {
     (left, right) => right.modified_ms - left.modified_ms
   );
 }
-function list_sessions_across(directories) {
+function list_sessions_across(directories2) {
   const seen = /* @__PURE__ */ new Set();
-  const merged = directories.flatMap((directory) => list_sessions(directory));
+  const merged = directories2.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) {
@@ -1863,8 +1625,8 @@ function directory_exists(directory) {
     return false;
   }
 }
-function searched_directories(directories) {
-  return directories.map((directory) => ({
+function searched_directories(directories2) {
+  return directories2.map((directory) => ({
     path: directory,
     exists: directory_exists(directory)
   }));
@@ -1890,6 +1652,7 @@ var cost_transcript = {
   transcript_directory,
   transcript_directories,
   session_cwd,
+  lane_transcript_directories,
   unit_directory,
   list_sessions,
   list_sessions_across,
@@ -2009,11 +1772,11 @@ var 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())) {
+function own_transcript(environment = process.env, directories2 = cost_transcript.transcript_directories(process.cwd())) {
   const session_id = own_session.session_id_of(environment);
   if (session_id === void 0) return void 0;
   const name = `${session_id}${cost_transcript.TRANSCRIPT_EXTENSION}`;
-  return directories.map((directory) => path5.join(directory, name)).find((file) => existsSync(file));
+  return directories2.map((directory) => path5.join(directory, name)).find((file) => existsSync(file));
 }
 function modified_ms(transcript) {
   try {
@@ -2084,8 +1847,8 @@ function carry_path(git_directory) {
   return stamp_file.stamp_path(CARRY_PREFIX, git_directory);
 }
 async function repository_directory() {
-  const directories = await git_command.git_directories();
-  return directories[REPOSITORY_DIRECTORY_INDEX];
+  const directories2 = await git_command.git_directories();
+  return directories2[REPOSITORY_DIRECTORY_INDEX];
 }
 function parse_carry(raw) {
   return json_value.parse_with(raw, run_carry_schema);
@@ -2135,9 +1898,9 @@ function adopt_carry(target, carry, owner = NO_OWNER) {
   stamp_file.remove_stamp(target);
   return stamp_file.create_stamp(target, next) ? next : void 0;
 }
-function is_owner_live(carry, now = /* @__PURE__ */ new Date()) {
-  if (process_identity.is_same_process(carry.owner_pid, carry.owner_start) !== false) return true;
-  return run_carry_conversation.is_conversation_live(carry, now);
+function is_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;
@@ -2177,7 +1940,7 @@ function remaining_of(carry) {
   const declared = run_invocation.issue_numbers(carry.invocation);
   if (declared === void 0) return void 0;
   const done = carry.done ?? [];
-  return run_carry_added.ordered(declared, carry.added).filter((issue) => !done.includes(issue));
+  return run_carry_added.ordered(declared, carry.added).filter((issue2) => !done.includes(issue2));
 }
 function done_note(carry) {
   const done = carry.done ?? [];
@@ -2336,38 +2099,1756 @@ var ports = {
   resolve_preview_port
 };
 
-// scripts/josh/process-owner.ts
+// 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(target) {
+  return plain(target.number, target.repo);
+}
+function missing_line(target) {
+  return `\u2716 ${label(target)}: issue does not resolve \u2014 check the number and the repository`;
+}
+function unreadable_line(target) {
+  return `\u2716 ${label(target)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
+}
+function no_repo_line(target) {
+  return `\u2716 ${label(target)}: could not read this repository \u2014 check gh auth and the origin remote`;
+}
+var issue_cite = {
+  citation_line,
+  citer,
+  issue_url,
+  missing_line,
+  no_repo_line,
+  parse_target,
+  plain,
+  reference,
+  unreadable_line
+};
+
+// scripts/git/git-common-directory.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS2 = 5e3;
+var answers = /* @__PURE__ */ new Map();
+function probe_environment(cwd) {
+  if (cwd === void 0) return process.env;
+  return { ...process.env, ...git_location_environment.location_free_environment() };
+}
+function cache_key(cwd) {
+  if (cwd !== void 0) return `explicit\0${cwd}`;
+  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
+  return ["inherited", process.cwd(), ...locations].join("\0");
+}
+function read_directories(cwd) {
+  try {
+    const output = execFileSync2(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      {
+        cwd,
+        env: probe_environment(cwd),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: PROBE_TIMEOUT_MS2
+      }
+    );
+    return output.split("\n").filter((line) => line !== "");
+  } catch {
+    return [];
+  }
+}
+function directories(cwd) {
+  const key = cache_key(cwd);
+  const known = answers.get(key);
+  if (known !== void 0) return known;
+  const read3 = read_directories(cwd);
+  if (read3.length > 0) answers.set(key, read3);
+  return read3;
+}
+function own(cwd) {
+  return directories(cwd)[OWN_GIT_DIRECTORY];
+}
+function repository(cwd) {
+  return directories(cwd)[COMMON_GIT_DIRECTORY];
+}
+function select_linked(found) {
+  const own_directory = found[OWN_GIT_DIRECTORY];
+  const common = found[COMMON_GIT_DIRECTORY];
+  return own_directory === void 0 || common === void 0 || own_directory === common ? void 0 : common;
+}
+function resolve(cwd) {
+  return select_linked(directories(cwd));
+}
+var git_common_directory = { directories, own, repository, resolve, select_linked };
+
+// scripts/run/ship/run-ship-stage.ts
 import { z as z3 } from "zod";
-var process_owner_schema = z3.object({ pid: z3.number(), process_start: z3.string().optional() });
+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 record_schema = z3.object({
+  done: z3.array(z3.string()),
+  started: z3.array(z3.string()).default([]),
+  is_merge_waiting: z3.boolean().default(false),
+  is_place_waiting: z3.boolean().default(false)
+});
+var EMPTY_RECORD = {
+  done: [],
+  started: [],
+  is_merge_waiting: false,
+  is_place_waiting: false
+};
+function record_path(repository2, issue2) {
+  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue2}${RECORD_SEPARATOR}`, repository2);
+}
+function parse_record(raw) {
+  return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
+}
+function read_record(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
+}
+function read_done(target) {
+  return new Set(read_record(target).done);
+}
+function mark_done(target, stage) {
+  const record = read_record(target);
+  stamp_file.replace_stamp(target, { ...record, done: [.../* @__PURE__ */ new Set([...record.done, stage])] });
+}
+function read_started(target) {
+  return read_record(target).started;
+}
+function mark_started(target, stage) {
+  const record = read_record(target);
+  stamp_file.replace_stamp(target, { ...record, started: [.../* @__PURE__ */ new Set([...record.started, stage])] });
+}
+function end_attempt(target) {
+  stamp_file.replace_stamp(target, { ...read_record(target), started: [], is_merge_waiting: false });
+}
+function read_merge_waiting(target) {
+  return read_record(target).is_merge_waiting;
+}
+function mark_merge_waiting(target, is_merge_waiting) {
+  stamp_file.replace_stamp(target, { ...read_record(target), is_merge_waiting });
+}
+function read_place_waiting(target) {
+  return read_record(target).is_place_waiting;
+}
+function mark_place_waiting(target, is_place_waiting) {
+  stamp_file.replace_stamp(target, { ...read_record(target), is_place_waiting });
+}
+function clear_waits(target) {
+  stamp_file.replace_stamp(target, {
+    ...read_record(target),
+    is_merge_waiting: false,
+    is_place_waiting: false
+  });
+}
+function clear(target) {
+  stamp_file.remove_stamp(target);
+}
+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 as it is the gate's; a resumed commit stage still asks `git -y`'s own preflight.
+  [STAGE.PREFLIGHT]: (_done, state) => state.is_merged || state.is_committed,
+  // The `--review` round precedes the commit, so a commit is its output as it
+  // is the gate's. A record alone is not honored: before a commit the tree may have been edited since
+  // the recorded round, and only a commit pins the tree that round read — unless the issue changed since.
+  [STAGE.REVIEW]: (_done, state) => state.is_merged || state.is_committed && state.is_review_stale !== true,
+  [STAGE.GATE]: (_done, state) => state.is_merged || state.is_committed,
+  // The merge of the default branch before the commit: once committed, a
+  // conflicting pull request is the followup's to merge again.
+  [STAGE.SYNC]: (_done, state) => state.is_merged || state.is_committed,
+  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
+  // The round-2 pass 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 started_of(text2) {
+  return text2.split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
+}
+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,
+  mark_done,
+  mark_merge_waiting,
+  mark_place_waiting,
+  mark_started,
+  read_done,
+  read_merge_waiting,
+  read_place_waiting,
+  read_started,
+  record_path,
+  started_of,
+  stop_reason
+};
+
+// scripts/git/repository-lock.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// scripts/josh/process-owner.ts
+import { z as z4 } from "zod";
+var process_owner_schema = z4.object({ pid: z4.number(), process_start: z4.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(target) {
+  return parse_owner(stamp_file.read_stamp_text(target));
+}
+function is_owner_gone(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
+}
+function restore(aside, target) {
+  try {
+    linkSync(aside, target);
+  } catch {
+  }
+}
+function stale_record(target, is_gone) {
+  const raw = stamp_file.read_stamp_text(target);
+  const owner = parse_owner(raw);
+  return owner !== void 0 && is_gone(owner) ? raw : void 0;
+}
+function move_aside(target) {
+  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
+  try {
+    renameSync(target, aside);
+    return aside;
+  } catch {
+    return void 0;
+  }
+}
+function clear_stale(target, is_gone = is_owner_gone) {
+  const raw = stale_record(target, is_gone);
+  if (raw === void 0) return;
+  const aside = move_aside(target);
+  if (aside === void 0) return;
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
+  rmSync2(aside, { force: true });
+}
+function claim(target) {
+  clear_stale(target);
+  return stamp_file.create_stamp(target, process_identity.own_fields());
+}
+function release(target) {
+  const owner = read_owner(target);
+  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
+    stamp_file.remove_stamp(target);
+  }
+}
+async function acquire(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(POLL_INTERVAL_MS);
+  }
+  return true;
+}
+function sleep_sync(ms) {
+  Atomics.wait(SLEEP_CELL, 0, 0, ms);
+}
+function acquire_sync(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    sleep_sync(SYNC_POLL_INTERVAL_MS);
+  }
+  return true;
+}
+async function with_lock(work, target, max_wait_ms) {
+  if (!await acquire(target, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target);
+  }
+}
+function with_lock_sync(work, target, max_wait_ms) {
+  if (!acquire_sync(target, max_wait_ms)) return void 0;
+  try {
+    return work();
+  } finally {
+    release(target);
+  }
+}
+var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
+
+// scripts/run/event/run-event-stream.ts
+import { z as z5 } from "zod";
+var EVENT_PREFIX = "josh-run-events-";
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 15e3;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR = "\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",
+  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",
+  // 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"
+};
+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
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS
+]);
+var event_schema = z5.object({
+  pos: z5.number(),
+  at: z5.string(),
+  kind: z5.string(),
+  text: z5.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.
+  elapsed_ms: z5.number().optional()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository2) {
+  return stamp_file.stamp_path(EVENT_PREFIX, repository2, 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(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line2(line)).filter(is_present);
+}
+function read_events(target) {
+  return read_lines(target).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_SEPARATOR)}${LINE_SEPARATOR}`;
+}
+function append_held(target, event) {
+  const position = last_position(read_lines(target)) + POSITION_INCREMENT;
+  const events = bounded([...read_events(target), { pos: position, ...event }]);
+  stamp_file.replace_text_stamp(target, serialize(events));
+  return position;
+}
+function append_event(target, event) {
+  if (!is_event_kind(event.kind)) return { appended: false, position: FIRST_POSITION };
+  const lock = `${target}${LOCK_SUFFIX}`;
+  const position = repository_lock.with_lock_sync(
+    () => append_held(target, 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 append(target, kind, text2, at) {
+  return append_event(target, { at, kind, text: text2 });
+}
+function read_from(target, position) {
+  const events = read_events(target);
+  return {
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
+  };
+}
+function read_last(target) {
+  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
+}
+function has_since(events, kind, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT).some((event) => event.kind === kind);
+}
+var FIELD_SEPARATOR = " \xB7 ";
+function format_event(event) {
+  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
+}
+var run_event_stream = {
+  EVENT_CAP,
+  EVENT_KIND,
+  EVENT_KINDS,
+  TRACE_KINDS,
+  append,
+  append_event,
+  format_event,
+  has_since,
+  is_stage_start,
+  read_events,
+  read_from,
+  read_last,
+  target_of
+};
+
+// scripts/discovery/repo-origin.ts
+var GITHUB_HOST = "github.com";
+var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
+var GIT_SUFFIX = ".git";
+var PATH_SEPARATOR2 = "/";
+var USER_SEPARATOR = "@";
+var HOST_SEPARATOR = ":";
+var OWNER_INDEX = 0;
+var REPO_INDEX = 1;
+var REPO_PATH_SEGMENTS = 2;
+var NOT_FOUND4 = -1;
+var SECTION_PREFIX = "[";
+var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
+var REMOTE_SECTION = /^\[remote\s+"[^"]+"\]$/u;
+var URL_KEY = "url";
+function is_github_hostname(host) {
+  return host.toLowerCase() === GITHUB_HOST;
+}
+function is_github_ssh_host(host) {
+  const normalized = host.toLowerCase();
+  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
+}
+function strip_git_suffix(name) {
+  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
+}
+function to_identity(repository_path) {
+  const segments = repository_path.split(PATH_SEPARATOR2).filter((segment) => segment !== "");
+  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
+  const owner = segments[OWNER_INDEX] ?? "";
+  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
+  return repo === "" ? void 0 : { owner, repo };
+}
+function parse_scp_like(url) {
+  const user_end = url.indexOf(USER_SEPARATOR);
+  const authority = user_end === NOT_FOUND4 ? url : url.slice(user_end + 1);
+  const host_end = authority.indexOf(HOST_SEPARATOR);
+  if (host_end === NOT_FOUND4 || !is_github_ssh_host(authority.slice(0, host_end))) return void 0;
+  return to_identity(authority.slice(host_end + 1));
+}
+function parse_url_like(url) {
+  try {
+    const parsed = new URL(url);
+    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parse_origin_url(url) {
+  const trimmed = url.trim();
+  if (trimmed === "") return void 0;
+  return parse_url_like(trimmed) ?? parse_scp_like(trimmed);
+}
+function is_section_header(line) {
+  return line.startsWith(SECTION_PREFIX);
+}
+function origin_section_lines(lines) {
+  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
+  if (start === NOT_FOUND4) return [];
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => is_section_header(line));
+  return end === NOT_FOUND4 ? rest : rest.slice(0, end);
+}
+function url_value(line) {
+  const separator = line.indexOf("=");
+  if (separator === NOT_FOUND4 || line.slice(0, separator).trim() !== URL_KEY) return void 0;
+  return line.slice(separator + 1).trim();
+}
+function parse_origin_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return origin_section_lines(lines).map((line) => url_value(line)).find((url) => url !== void 0);
+}
+function section_groups(lines) {
+  const groups = [];
+  for (const line of lines) {
+    if (is_section_header(line)) groups.push([line]);
+    else groups.at(-1)?.push(line);
+  }
+  return groups;
+}
+function parse_remote_urls_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line) => url_value(line))).filter((url) => url !== void 0);
+}
+function format_identity(identity) {
+  return `${identity.owner}${PATH_SEPARATOR2}${identity.repo}`.toLowerCase();
+}
+var repo_origin = {
+  GITHUB_HOST,
+  is_github_hostname,
+  is_github_ssh_host,
+  parse_origin_from_config,
+  parse_origin_url,
+  parse_remote_urls_from_config,
+  format_identity
+};
+
+// scripts/discovery/repo-discovery.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import path7 from "node:path";
+
+// scripts/lib/stamped-memo.ts
+import { lstatSync } from "node:fs";
+var NO_STAMP = "";
+var STAMP_SEPARATOR = ":";
+function create() {
+  const answers2 = /* @__PURE__ */ new Map();
+  return {
+    of(key, stamp, compute) {
+      const known = answers2.get(key);
+      if (known?.stamp === stamp) return known.value;
+      const value = compute();
+      answers2.set(key, { stamp, value });
+      return value;
+    },
+    keep(keys) {
+      for (const key of answers2.keys()) if (!keys.has(key)) answers2.delete(key);
+    }
+  };
+}
+function file_stamp(file) {
+  try {
+    const status2 = lstatSync(file);
+    return [status2.ino, status2.mtimeMs, status2.ctimeMs, status2.size].join(STAMP_SEPARATOR);
+  } catch {
+    return NO_STAMP;
+  }
+}
+var stamped_memo = { NO_STAMP, create, file_stamp };
+
+// scripts/discovery/repo-map-logic.ts
+var OVERRIDE_ENTRY_SEPARATOR = ",";
+var OVERRIDE_PAIR_SEPARATOR = "=";
+var OVERRIDE_PAIR_PARTS = 2;
+var KEY_INDEX = 0;
+var PATH_INDEX = 1;
+function is_same_owner(identity, current_owner) {
+  return identity.owner.toLowerCase() === current_owner.toLowerCase();
+}
+function add_entry(target, origin_url2, repository_path, current_owner) {
+  if (origin_url2 === void 0) return;
+  const identity = repo_origin.parse_origin_url(origin_url2);
+  if (identity === void 0 || !is_same_owner(identity, current_owner)) return;
+  target.set(repo_origin.format_identity(identity), repository_path);
+}
+function parse_override_entry(entry) {
+  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
+  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
+  const key = parts[KEY_INDEX] ?? "";
+  const repository_path = parts[PATH_INDEX] ?? "";
+  if (repository_path === "") return void 0;
+  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key}` };
+}
+function parse_overrides(raw) {
+  if (raw === void 0) return [];
+  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
+}
+function build_repository_map(discovered, current_owner, override_value) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner);
+  for (const entry of parse_overrides(override_value)) {
+    add_entry(result, entry.origin_url, entry.path, current_owner);
+  }
+  return result;
+}
+var repo_map_logic = {
+  is_same_owner,
+  build_repository_map
+};
+
+// scripts/discovery/repo-discovery.ts
+var GIT_DIRECTORY = ".git";
+var GIT_CONFIG = "config";
+var GITDIR_PREFIX2 = "gitdir:";
+var COMMON_DIRECTORY_FILE = "commondir";
+var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
+function resolve_common_directory(git_directory) {
+  const pointer = path7.join(git_directory, COMMON_DIRECTORY_FILE);
+  if (!existsSync3(pointer)) return git_directory;
+  try {
+    return path7.resolve(git_directory, readFileSync4(pointer, "utf8").trim());
+  } catch {
+    return git_directory;
+  }
+}
+function follow_git_file(repository_path, git_file) {
+  const pointer = readFileSync4(git_file, "utf8").trim();
+  if (!pointer.startsWith(GITDIR_PREFIX2)) return void 0;
+  return path7.resolve(repository_path, pointer.slice(GITDIR_PREFIX2.length).trim());
+}
+function resolve_git_directory(repository_path) {
+  const candidate = path7.join(repository_path, GIT_DIRECTORY);
+  if (!existsSync3(candidate)) return void 0;
+  try {
+    if (statSync3(candidate).isDirectory()) return candidate;
+    const linked = follow_git_file(repository_path, candidate);
+    return linked === void 0 ? void 0 : resolve_common_directory(linked);
+  } catch {
+    return void 0;
+  }
+}
+function read_text(file) {
+  try {
+    return readFileSync4(file, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var git_directories2 = stamped_memo.create();
+var configs = stamped_memo.create();
+function read_config(repository_path) {
+  const git_entry = path7.join(repository_path, GIT_DIRECTORY);
+  const git_directory = git_directories2.of(
+    repository_path,
+    stamped_memo.file_stamp(git_entry),
+    () => resolve_git_directory(repository_path)
+  );
+  if (git_directory === void 0) return void 0;
+  const config = path7.join(git_directory, GIT_CONFIG);
+  return configs.of(config, stamped_memo.file_stamp(config), () => read_text(config));
+}
+function read_origin_url(repository_path) {
+  const config = read_config(repository_path);
+  return config === void 0 ? void 0 : repo_origin.parse_origin_from_config(config);
+}
+function read_remote_urls(repository_path) {
+  const config = read_config(repository_path);
+  return config === void 0 ? [] : repo_origin.parse_remote_urls_from_config(config);
+}
+function sibling_directories(parent) {
+  try {
+    return readdirSync2(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path7.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function scan_siblings(parent) {
+  return sibling_directories(parent).map((repository_path) => ({
+    path: repository_path,
+    origin_url: read_origin_url(repository_path)
+  }));
+}
+function resolve_current_owner(repository_path) {
+  const origin_url2 = read_origin_url(repository_path);
+  if (origin_url2 === void 0) return void 0;
+  return repo_origin.parse_origin_url(origin_url2)?.owner;
+}
+function main_worktree(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0 || path7.basename(git_directory) !== GIT_DIRECTORY) {
+    return repository_path;
+  }
+  return path7.dirname(git_directory);
+}
+function discover_repositories(repository_path, environment = process.env) {
+  const main = main_worktree(repository_path);
+  const current_owner = resolve_current_owner(main);
+  if (current_owner === void 0) return /* @__PURE__ */ new Map();
+  return repo_map_logic.build_repository_map(
+    scan_siblings(path7.dirname(main)),
+    current_owner,
+    environment[OVERRIDE_ENV_KEY]
+  );
+}
+var repo_discovery = {
+  OVERRIDE_ENV_KEY,
+  main_worktree,
+  read_origin_url,
+  read_remote_urls,
+  resolve_current_owner,
+  scan_siblings,
+  discover_repositories
+};
+
+// 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 prompt_references(prompt) {
+  const found = /* @__PURE__ */ new Set();
+  for (const match of prompt.matchAll(ISSUE_NUMBER)) {
+    found.add(repo_prefix(prompt, match.index) + match[0]);
+  }
+  return found;
+}
+function unquoted_references(message, prompt) {
+  const quoted = prompt_references(prompt);
+  return bare_references(message).filter((reference2) => !quoted.has(reference2));
+}
+function has_bare_reference(message) {
+  return bare_references(message).length > 0;
+}
+function cite_argument(reference2) {
+  return reference2.startsWith("#") ? reference2.slice(1) : reference2;
+}
+function cite_arguments(references) {
+  return references.map((reference2) => cite_argument(reference2));
+}
+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,
+  cite_arguments,
+  has_bare_reference,
+  linkify,
+  prose_lines,
+  unquoted_references
+};
+
+// 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 path8 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 z6 } from "zod";
+var STATE_PREFIX = "josh-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 = z6.object({ started_at: z6.string(), owner_pid: z6.number().optional() });
+var stuck_schema = z6.object({ pid: z6.number(), reason: z6.string() });
+var lane_state_schema = z6.object({
+  issue: z6.string(),
+  run: lane_run_schema.optional(),
+  state: z6.enum(LANE_STATES),
+  launched_at: z6.string().optional(),
+  changed_at: z6.string(),
+  changed_by: z6.string(),
+  stuck: z6.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 stamp_file.stamp_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_schema);
+}
+function write_record(directory, record) {
+  stamp_file.replace_stamp(state_path(directory, record.issue), record);
+}
+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 record = next_record(change, previous, directory, now);
+  write_record(directory, record);
+  return { kind: "written", record };
+}
+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_outcome(change, options) {
+  try {
+    return await outcome_of(change, options);
+  } catch (error) {
+    return { kind: "skipped", reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function record_change(change, options = {}) {
+  const outcome = await settled_outcome(change, options);
+  if (outcome.kind === "skipped") warn(change, outcome.reason);
+  return outcome;
+}
+async function read_state(issue2, directory) {
+  const root = await resolve_directory(directory);
+  return root === void 0 ? void 0 : read_record2(root, issue2);
+}
+function recorded_issues(directory) {
+  const empty = state_path(directory, "");
+  const head = path8.basename(empty).slice(0, -STATE_SUFFIX.length);
+  return readdirSync3(path8.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 root = await resolve_directory(directory);
+  if (root === void 0) return [];
+  const records = recorded_issues(root).map((issue2) => read_record2(root, issue2));
+  return records.filter((record) => record !== 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 record = { ...previous, stuck };
+  write_record(directory, record);
+  return { kind: "written", record };
+}
+async function record_stuck(issue2, stuck, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return NO_DIRECTORY;
+  return locked(root, issue2, () => stuck_held(issue2, stuck, root));
+}
+async function read_states(issues, directory) {
+  const root = await resolve_directory(directory);
+  if (root === void 0) return /* @__PURE__ */ new Map();
+  const read3 = issues.map((issue2) => [
+    issue2,
+    read_record2(root, issue2)
+  ]);
+  return new Map(read3.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(record) {
+  if (record?.state !== "paused") return void 0;
+  return paused_text(Date.parse(record.changed_at), record.changed_by);
+}
+var lane_state = {
+  LANE_STATES,
+  NO_STATE_HINT,
+  is_allowed,
+  paused_note,
+  paused_text,
+  read_records,
+  read_state,
+  read_states,
+  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(read3) {
+  if (read3.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
+  return { kind: SINCE_SCOPE, started_at: read3.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 KIND = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.RESTART,
+  KIND.WITHDRAW,
+  KIND.PARK,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.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 === KIND.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 own2 = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own2, scope);
+  return own2.findLast((event) => is_own_ship_event(event, issue2));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.MERGE,
+  KIND.PARK,
+  KIND.SPLIT,
+  KIND.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 === KIND.CHILD_LAUNCH;
+}
+function is_launch_or_withdrawal(event, issue2) {
+  const is_kind = event.kind === KIND.CHILD_LAUNCH || event.kind === KIND.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 === KIND.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 KIND2 = run_event_stream.EVENT_KIND;
+var LAUNCH_KINDS = /* @__PURE__ */ new Set([KIND2.CHILD_LAUNCH, KIND2.RESTART]);
+var OFF_LANE_KINDS = /* @__PURE__ */ new Set([
+  KIND2.MERGE,
+  KIND2.PARK,
+  KIND2.WITHDRAW,
+  KIND2.OUTAGE,
+  KIND2.SPLIT,
+  KIND2.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(record) {
+  const launched_at = record?.launched_at;
+  return launched_at === void 0 ? void 0 : Date.parse(launched_at);
+}
+function counted_from(run3, started_ms) {
+  return run3 === void 0 ? started_ms : Date.parse(run3.started_at);
+}
+function is_ended(spans) {
+  return spans.at(-1)?.end_ms !== void 0;
+}
+function ending_elapsed(read3) {
+  const started_ms = launched_ms(read3.record);
+  if (started_ms === void 0) return void 0;
+  const from_ms = counted_from(read3.record?.run, started_ms);
+  const spans = (spans_of(read3.events).get(read3.issue) ?? []).filter(
+    (span) => span.from_ms >= from_ms
+  );
+  return is_ended(spans) ? void 0 : elapsed_of(spans, started_ms, read3.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_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function stream_target() {
+  const repository2 = await run_carry.repository_directory();
+  return repository2 === void 0 ? void 0 : run_event_stream.target_of(repository2);
+}
+async function 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(target, 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(target),
+    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(target, kind, text2, at) {
+  const event = { kind, text: text2, at: at.toISOString() };
+  return run_event_stream.append_event(target, {
+    ...event,
+    ...await ending_fields(target, event)
+  });
+}
+async function emit(kind, text2, at = /* @__PURE__ */ new Date()) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return;
+    await append_at(target, kind, text2, at);
+  } catch {
+  }
+}
+async function emit_once(kind, text2) {
+  try {
+    const target = await stream_target();
+    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
+    return run_event_stream.append(target, kind, text2, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+function invocation_events(repository2, target) {
+  const events = run_event_stream.read_events(target);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository2)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since_with(kind, reset_kind, compose) {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return void 0;
+    const target = run_event_stream.target_of(repository2);
+    if (run_event_stream.has_since(invocation_events(repository2, target), kind, reset_kind)) {
+      return void 0;
+    }
+    const text2 = await compose();
+    return run_event_stream.append(target, kind, text2, now_iso()).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 repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return [];
+    const read3 = run_carry.read_carry(run_carry.carry_path(repository2));
+    const scope = run_event_scope.scope_of(read3);
+    const events = run_event_stream.read_events(run_event_stream.target_of(repository2));
+    return run_event_scope.scoped_events(events, scope) ?? [];
+  } catch {
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    return repository2 === void 0 ? [] : invocation_events(repository2, run_event_stream.target_of(repository2));
+  } catch {
+    return [];
+  }
+}
+async function all_events() {
+  try {
+    const target = await stream_target();
+    return target === void 0 ? [] : run_event_stream.read_events(target);
+  } 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
+};
+
+// scripts/lib/ancestor-directories.ts
+import path9 from "node:path";
+var MAX_DEPTH = 64;
+function list(start_directory) {
+  const directories2 = [];
+  let current = path9.resolve(start_directory);
+  while (directories2.length < MAX_DEPTH && !directories2.includes(current)) {
+    directories2.push(current);
+    current = path9.dirname(current);
+  }
+  return directories2;
+}
+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 readFileSync5 } 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 = readFileSync5(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/git/git-schemas.ts
+import { z as z7 } from "zod";
+var package_name_schema = z7.object({ name: z7.string().min(1) });
+var rollup_item_schema = z7.looseObject({
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
+  __typename: z7.string().nullish(),
+  state: z7.string().nullish(),
+  status: z7.string().nullish(),
+  conclusion: z7.string().nullish(),
+  name: z7.string().nullish(),
+  context: z7.string().nullish(),
+  description: z7.string().nullish()
+});
+var pr_raw_schema = z7.object({
+  statusCheckRollup: z7.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: z7.array(z7.string()).optional(),
+  mergeStateStatus: z7.string().optional(),
+  reviewDecision: z7.string().optional(),
+  headRefOid: z7.string().optional()
+});
+var pull_comment_schema = z7.object({
+  body: z7.string().optional(),
+  html_url: z7.string().optional(),
+  user: z7.object({ login: z7.string().optional() }).optional()
+});
+var ai_review_pull_comment_schema = z7.object({
+  body: z7.string().optional(),
+  url: z7.string().optional(),
+  author: z7.object({ login: z7.string().optional() }).optional()
+});
+var pr_info_schema = z7.object({
+  mergeable: z7.union([z7.boolean(), z7.string()]).nullable().optional(),
+  mergeStateStatus: z7.string().nullable().optional(),
+  state: z7.string().optional()
+});
+var epic_issue_schema = z7.object({
+  number: z7.number(),
+  body: z7.string().optional(),
+  // REST answers null for an issue never closed and `reopened` for one a person reopened.
+  stateReason: z7.string().nullish()
+});
+var blocking_issue_schema = z7.object({
+  number: z7.number(),
+  state: z7.string().optional(),
+  repository_url: z7.string().optional()
+});
+var blocked_by_schema = z7.object({
+  nodes: z7.array(blocking_issue_schema).default([]),
+  totalCount: z7.number().optional()
+}).optional();
+var epic_child_schema = z7.object({
+  state: z7.string().optional(),
+  blockedBy: blocked_by_schema
+});
+var rest_comment_schema = z7.looseObject({
+  body: z7.string().nullish(),
+  html_url: z7.string().optional(),
+  user: z7.looseObject({ login: z7.string().optional() }).nullish()
+});
+var issue_label_schema = z7.object({ name: z7.string() });
+var epic_subject_schema = z7.object({
+  number: z7.number(),
+  state: z7.string().optional(),
+  labels: z7.array(issue_label_schema).optional(),
+  body: z7.string().optional()
+});
+var open_issue_schema = z7.object({
+  number: z7.number(),
+  title: z7.string(),
+  labels: z7.array(issue_label_schema).optional(),
+  createdAt: z7.string(),
+  blockedBy: blocked_by_schema,
+  // Present only on the pickup listing, which reads it for the paths each issue declares.
+  body: z7.string().optional()
+});
 
 export {
   json_value,
-  PORT_SEED_KEY,
-  LANE_SEAT_KEY,
-  ENV_FILE_NAME,
-  ports,
+  file_reader,
   process_identity,
   process_owner_schema,
+  issue_number_shape,
+  lane_paths,
+  stamped_memo,
   PORCELAIN_FLAG,
   UNTRACKED_FILES_FLAG,
-  git_utilities,
+  get_exit_code,
   has_timed_out,
   git_spawn,
   git_diff_reads,
   GIT_LOCATION_VARIABLES,
-  git_location_environment,
   git_spawn_sync,
   git_command,
   cli_flags,
-  backlog_budget,
-  issue_number_shape,
   run_invocation,
-  lane_paths,
-  file_reader,
   time_instant,
   cost_usage,
   cost_transcript,
   agent_session_environment,
   own_session,
-  run_carry
+  run_carry,
+  PORT_SEED_KEY,
+  LANE_SEAT_KEY,
+  ENV_FILE_NAME,
+  ports,
+  figure_format,
+  pr_raw_schema,
+  epic_issue_schema,
+  blocking_issue_schema,
+  blocked_by_schema,
+  rest_comment_schema,
+  issue_label_schema,
+  open_issue_schema,
+  issue_cite,
+  git_common_directory,
+  repository_lock,
+  run_ship_stage,
+  run_event_stream,
+  repo_origin,
+  repo_map_logic,
+  repo_discovery,
+  issue_citation,
+  session_cite,
+  lane_state,
+  run_event_scope,
+  run_event_stream_emit,
+  ancestor_directories,
+  PACKAGE_JSON,
+  package_manifest
 };