@joshuafolkken/kit 1.1094.0 → 1.1128.0

package/dist/hooks/{chunk-UD24EAIL.js → chunk-AIOIOMPX.js}

@@ -1,7 +1,7 @@
 import {
   lane_child_marker,
   run_issue_number
-} from "./chunk-E54KGFEQ.js";
+} from "./chunk-MKVGBQPA.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_blocks,
@@ -13,7 +13,7 @@ import {
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-NKOG3XAV.js";
+} from "./chunk-4JZDP5X5.js";
 import {
   ENV_FILE_NAME,
   LANE_SEAT_KEY,
@@ -21,6 +21,41 @@ import {
   ports
 } from "./chunk-RKUAD3I6.js";
 
+// scripts/lib/bounded-pool.ts
+function pool_width(limit, total) {
+  if (!Number.isFinite(limit)) return 1;
+  return Math.max(1, Math.min(Math.floor(limit), total));
+}
+function throw_first_failure(failures) {
+  if (failures.length === 0) return;
+  const [first] = failures;
+  throw first;
+}
+async function drain(pool, worker) {
+  for (let entry = pool.queue.shift(); entry !== void 0 && pool.failures.length === 0; entry = pool.queue.shift()) {
+    const [index, item] = entry;
+    try {
+      pool.results.push({ index, value: await worker(item, index) });
+    } catch (error) {
+      pool.failures.push(error);
+    }
+  }
+}
+async function bounded_map(items, limit, worker) {
+  const pool = {
+    failures: [],
+    queue: items.map((item, index) => [index, item]),
+    results: []
+  };
+  const consumers = Array.from({ length: pool_width(limit, items.length) }, async () => {
+    await drain(pool, worker);
+  });
+  await Promise.all(consumers);
+  throw_first_failure(pool.failures);
+  return pool.results.toSorted((left, right) => left.index - right.index).map((result) => result.value);
+}
+var bounded_pool = { bounded_map, pool_width };
+
 // scripts/rules/shell-segments.ts
 var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
 function segments_of(command) {
@@ -108,8 +143,8 @@ function current_turn(tail) {
 function turn_filing_count(tail) {
   return prior_filing_count(current_turn(tail));
 }
-function decide(_call, run2) {
-  return prior_filing_count(time_density_hook.read_tail(run2.transcript)) >= CAP_REACHED;
+function decide(_call, run3) {
+  return prior_filing_count(time_density_hook.read_tail(run3.transcript)) >= CAP_REACHED;
 }
 var FILING_CAP_REASON = `\u26D4 filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling \u2014 on reaching it, stop and report rather than filing more. Automatic filing is capped so a run cannot manufacture Issues faster than they can be closed (\`.claude/skills/workflow-commands/SKILL.md\` \u2192 \xA72d, \`observation-filing.md\`). A further Issue that genuinely must exist is a person's call, not this run's. **This rule fires on every filing past the cap, not once per run**, so reissuing the same filing will be refused again.`;
 var ROW = {
@@ -149,9 +184,6 @@ var git_utilities = {
   get_git_command_for_spawn
 };
 
-// scripts/git/git-push-transport.ts
-import { execa as execa2 } from "execa";
-
 // scripts/git/git-execa-error.ts
 function get_exit_code(error) {
   if (typeof error !== "object" || error === null) return void 0;
@@ -170,6 +202,9 @@ function create_spawn_error(command, exit_code) {
   return new Error(error_message, { cause: { exit_code: exit_code_string } });
 }
 
+// scripts/git/git-push-transport.ts
+import { execa as execa2 } from "execa";
+
 // scripts/git/git-ssh-keepalive.ts
 import { execa } from "execa";
 var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
@@ -300,6 +335,44 @@ var git_spawn = {
   with_output_remote
 };
 
+// scripts/lib/spawn-exit.ts
+function read_spawn_stdout(result) {
+  return result.stdout ?? "";
+}
+function read_spawn_stderr(result) {
+  return result.stderr ?? "";
+}
+
+// scripts/git/git-spawn-sync.ts
+import { execaSync } from "execa";
+var GIT_TIMEOUT_MS = 1e4;
+var SUCCESS_EXIT_CODE = 0;
+var C_LOCALE = { LC_ALL: "C", LANGUAGE: "C" };
+function run(args, options = {}) {
+  const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
+    ...options,
+    extendEnv: true,
+    reject: false,
+    timeout: options.timeout ?? GIT_TIMEOUT_MS
+  });
+  return {
+    exit_code: result.exitCode,
+    stdout: read_spawn_stdout(result),
+    stderr: read_spawn_stderr(result)
+  };
+}
+function read2(args, options = {}) {
+  const result = run(args, options);
+  return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
+}
+function origin_url(cwd) {
+  return read2(["config", "--get", "remote.origin.url"], { cwd });
+}
+function toplevel(timeout = GIT_TIMEOUT_MS) {
+  return run(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
+}
+var git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run, read: read2, origin_url, toplevel };
+
 // scripts/git/git-command.ts
 async function branch() {
   return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -309,7 +382,9 @@ async function status(directory) {
   return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
 }
 async function repository_root() {
-  return await git_spawn.read(["rev-parse", "--show-toplevel"]);
+  const result = git_spawn_sync.toplevel();
+  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
+  return result.stdout.trim();
 }
 async function head_commit() {
   return await git_spawn.read(["rev-parse", "HEAD"]);
@@ -342,9 +417,9 @@ async function get_default_branch() {
   return DEFAULT_BRANCH_FALLBACK;
 }
 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;
@@ -582,6 +657,18 @@ var git_command = {
   is_upstream_not_set_error
 };
 
+// scripts/lib/error-message.ts
+function message_of(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var DEBUG_ENV_KEY = "JOSH_DEBUG";
+function trace_swallowed(where, error) {
+  if ((process.env[DEBUG_ENV_KEY] ?? "").trim() === "") return;
+  process.stderr.write(`josh debug: ${where}: ${message_of(error)}
+`);
+}
+var error_text = { message_of, trace_swallowed };
+
 // scripts/run/run-hold.ts
 import { z } from "zod";
 var HOLD_PREFIX = "josh-run-hold-";
@@ -657,7 +744,8 @@ async function is_tree_dirty(directory) {
   try {
     const status2 = await git_command.status(directory);
     return status2.trim() !== "";
-  } catch {
+  } catch (error) {
+    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
     return true;
   }
 }
@@ -692,8 +780,8 @@ function stale_message(hold) {
 function uncommitted_message(hold) {
   return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
 }
-function race_message(read2, target) {
-  if (read2.kind === "held") return held_message(read2.hold);
+function race_message(read3, target) {
+  if (read3.kind === "held") return held_message(read3.hold);
   return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
 }
 function unknown_message() {
@@ -1300,9 +1388,9 @@ function directories(cwd) {
   const key2 = cache_key(cwd);
   const known = answers.get(key2);
   if (known !== void 0) return known;
-  const read2 = read_directories(cwd);
-  if (read2.length > 0) answers.set(key2, read2);
-  return read2;
+  const read3 = read_directories(cwd);
+  if (read3.length > 0) answers.set(key2, read3);
+  return read3;
 }
 function own(cwd) {
   return directories(cwd)[OWN_GIT_DIRECTORY];
@@ -1616,8 +1704,8 @@ function worktree_git_directory_sync() {
 }
 function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
   if (directory === void 0) return void 0;
-  const read2 = read_cut(cut_path(directory), now);
-  return read2.kind === "carried" ? read2.cut : void 0;
+  const read3 = read_cut(cut_path(directory), now);
+  return read3.kind === "carried" ? read3.cut : void 0;
 }
 function lane_cut_sync(lane_directory) {
   const directory = git_common_directory.own(lane_directory);
@@ -1684,8 +1772,8 @@ function end_cut(target) {
 }
 function hold_of(directory) {
   if (directory === void 0) return void 0;
-  const read2 = run_hold.read_hold(run_hold.hold_path(directory));
-  return read2.kind === "held" || read2.kind === "stale" ? read2.hold : void 0;
+  const read3 = run_hold.read_hold(run_hold.hold_path(directory));
+  return read3.kind === "held" || read3.kind === "stale" ? read3.hold : void 0;
 }
 function fullrun_issue(hold) {
   return hold?.is_fullrun === true ? hold.issue : void 0;
@@ -1989,13 +2077,13 @@ function is_live_beacon(target) {
     timeout: PROBE_TIMEOUT_MS2
   }).status === 0;
 }
-function has_matching_start(pid, recorded_start, read2) {
-  const observed = read2(pid);
+function has_matching_start(pid, recorded_start, read3) {
+  const observed = read3(pid);
   return observed === void 0 ? void 0 : observed === recorded_start;
 }
-function matches_recorded_start(pid, recorded_start, read2) {
+function matches_recorded_start(pid, recorded_start, read3) {
   const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read2) : is_live_beacon(target);
+  return target === void 0 ? has_matching_start(pid, recorded_start, read3) : is_live_beacon(target);
 }
 var own_probe = /* @__PURE__ */ new Map();
 function own_start() {
@@ -2006,10 +2094,10 @@ function own_fields() {
   const start = own_start();
   return { pid: process.pid, ...start !== void 0 && { process_start: start } };
 }
-function is_same_process(pid, recorded_start, read2 = read_start) {
+function is_same_process(pid, recorded_start, read3 = read_start) {
   if (pid === void 0 || !is_live_pid(pid)) return false;
   if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read2);
+  return matches_recorded_start(pid, recorded_start, read3);
 }
 function is_own_process(pid, recorded_start) {
   return pid === process.pid && recorded_start === own_start();
@@ -2188,11 +2276,20 @@ function parse_or_undefined(config) {
     return void 0;
   }
 }
-var cli_flags = { refuse_unknown_flags, parse_or_undefined };
+function values_of(argv, options) {
+  return parse_or_undefined({ args: [...argv], options })?.values;
+}
+function arguments_of(argv, options) {
+  return parse_or_undefined({ args: [...argv], options, allowPositionals: true });
+}
+function string_of(value) {
+  return typeof value === "string" ? value : void 0;
+}
+var cli_flags = { refuse_unknown_flags, parse_or_undefined, values_of, arguments_of, string_of };
 
 // scripts/backlog/backlog-budget-cli.ts
 var ARGV_OFFSET = 2;
-var SUCCESS_EXIT_CODE = 0;
+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]`;
@@ -2207,10 +2304,7 @@ var OPTIONS = {
   started: { type: "string" }
 };
 function read_arguments(argv) {
-  return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS, strict: true })?.values;
-}
-function text_of(value) {
-  return typeof value === "string" ? value : void 0;
+  return cli_flags.values_of(argv, OPTIONS);
 }
 function to_answer(raw) {
   return backlog_budget.ANSWERS.find((answer) => answer === raw);
@@ -2232,14 +2326,14 @@ function is_readable(raw, parsed) {
 var COUNT_NAMES = ["idle", "max", "merged", "running"];
 function counts_of(values) {
   return {
-    idle: to_count(text_of(values.idle)),
-    max: to_count(text_of(values.max)),
-    merged: to_count(text_of(values.merged)),
-    running: to_count(text_of(values.running))
+    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(text_of(values[name]), counts[name]));
+  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) {
@@ -2248,17 +2342,20 @@ function to_idle_ms(idle_minutes) {
   return idle_minutes * backlog_budget.MS_PER_MINUTE;
 }
 function is_watch_readable(values) {
-  if (to_idle_ms(to_count(text_of(values.idle))) === void 0) return true;
-  return text_of(values.active) !== void 0;
+  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(text_of(values.active), to_time_ms(text_of(values.active))) && is_watch_readable(values) && are_counts_readable(values, counts_of(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(text_of(values.active)) ?? base.started_at_ms,
+    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,
@@ -2266,9 +2363,9 @@ function input_of(values, base) {
   };
 }
 function build_input(values, now_ms) {
-  const answer = to_answer(text_of(values.answer));
+  const answer = to_answer(cli_flags.string_of(values.answer));
   if (answer === void 0) return void 0;
-  const started_at_ms = to_time_ms(text_of(values.started));
+  const started_at_ms = to_time_ms(cli_flags.string_of(values.started));
   if (started_at_ms === void 0) return void 0;
   if (!are_values_readable(values)) return void 0;
   return input_of(values, { answer, now_ms, started_at_ms });
@@ -2277,7 +2374,7 @@ function refuse() {
   console.error(USAGE);
   return FAILURE_EXIT_CODE2;
 }
-function run(argv, now_ms = Date.now()) {
+function run2(argv, now_ms = Date.now()) {
   const values = read_arguments(argv);
   if (values === void 0) return refuse();
   const input = build_input(values, now_ms);
@@ -2287,23 +2384,23 @@ function run(argv, now_ms = Date.now()) {
     console.info(
       JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish: backlog_budget.is_finish(input) })
     );
-    return SUCCESS_EXIT_CODE;
+    return SUCCESS_EXIT_CODE2;
   }
   path_decision.print_decision(JSON_KEY, verdict, reason, false);
-  return SUCCESS_EXIT_CODE;
+  return SUCCESS_EXIT_CODE2;
 }
 function main(argv) {
-  process.exitCode = run(argv);
+  process.exitCode = run2(argv);
 }
 var backlog_budget_cli = {
   JSON_KEY,
   OPTIONS,
-  SUCCESS_EXIT_CODE,
+  SUCCESS_EXIT_CODE: SUCCESS_EXIT_CODE2,
   USAGE,
   build_input,
   main,
   read_arguments,
-  run,
+  run: run2,
   to_answer,
   to_count,
   to_time_ms
@@ -2342,10 +2439,10 @@ function flag_tokens(tokens, start) {
   const rendered = [];
   let index = start;
   while (index < tokens.length) {
-    const read2 = read_flag(tokens, index);
-    if (read2 === void 0) return void 0;
-    rendered.push(read2.part);
-    index += read2.advance;
+    const read3 = read_flag(tokens, index);
+    if (read3 === void 0) return void 0;
+    rendered.push(read3.part);
+    index += read3.advance;
   }
   return rendered;
 }
@@ -2472,8 +2569,8 @@ function classify3(raw, now) {
 function read_carry(target, now = /* @__PURE__ */ new Date()) {
   return classify3(stamp_file.read_stamp_text(target), now);
 }
-function owner_of(pid, read2 = process_identity.read_start) {
-  return { pid, start: read2(pid) };
+function owner_of(pid, read3 = process_identity.read_start) {
+  return { pid, start: read3(pid) };
 }
 function fresh_carry(invocation, owner, now) {
   return {
@@ -2533,9 +2630,9 @@ function is_at_cut_cap(carry) {
 function end_carry(target) {
   stamp_file.remove_stamp(target);
 }
-function retrospective_done_of(read2) {
-  if (read2.kind !== "carried" && read2.kind !== "expired") return false;
-  return read2.carry.retrospective === true;
+function retrospective_done_of(read3) {
+  if (read3.kind !== "carried" && read3.kind !== "expired") return false;
+  return read3.carry.retrospective === true;
 }
 function remaining_of(carry) {
   if (carry === void 0) return void 0;
@@ -2634,11 +2731,11 @@ import { existsSync, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync
 import path3 from "node:path";
 
 // scripts/gh/gh-cli-token.ts
-import { execaSync } from "execa";
+import { execaSync as execaSync2 } from "execa";
 var GH_CLI_TIMEOUT_MS = 5e3;
 function get() {
   try {
-    const { stdout } = execaSync("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
+    const { stdout } = execaSync2("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
     const token = stdout.trim();
     return token.length > 0 ? token : void 0;
   } catch {
@@ -2979,9 +3076,9 @@ function scoped_events(events, scope) {
   if (floor === void 0) return void 0;
   return events.filter((event) => is_within(event, floor));
 }
-function scope_of(read2) {
-  if (read2.kind === "carried" || read2.kind === "expired") {
-    return { kind: SINCE_SCOPE, started_at: read2.carry.started_at };
+function scope_of(read3) {
+  if (read3.kind === "carried" || read3.kind === "expired") {
+    return { kind: SINCE_SCOPE, started_at: read3.carry.started_at };
   }
   return UNKNOWN_EVENT_SCOPE;
 }
@@ -3060,7 +3157,8 @@ async function emit_once(kind, text) {
     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, text, now_iso()).appended;
-  } catch {
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
     return false;
   }
 }
@@ -3078,7 +3176,8 @@ async function emit_once_since(kind, text, reset_kind) {
       return false;
     }
     return run_event_stream.append(target, kind, text, now_iso()).appended;
-  } catch {
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
     return false;
   }
 }
@@ -3089,8 +3188,8 @@ async function current_events() {
   try {
     const repository2 = await run_carry.repository_directory();
     if (repository2 === void 0) return [];
-    const read2 = run_carry.read_carry(run_carry.carry_path(repository2));
-    const scope = run_event_scope.scope_of(read2);
+    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 {
@@ -3474,7 +3573,9 @@ function is_confirmation_notify(command) {
   );
 }
 var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
+var COMMAND_NOTIFY_MARKER = "stop notified: a confirmation Telegram was sent by this command";
 function mentions_confirmation_notify(text) {
+  if (text.includes(COMMAND_NOTIFY_MARKER)) return true;
   return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
 }
 function is_parking_child(directory = process.cwd()) {
@@ -3493,6 +3594,7 @@ function records_the_park(command) {
 }
 var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
 var lane_park = {
+  COMMAND_NOTIFY_MARKER,
   LANE_PARK_REASON,
   is_confirmation_notify,
   is_parking_child,
@@ -3598,9 +3700,9 @@ var PATH_INDEX = 1;
 function is_same_owner(identity, current_owner2) {
   return identity.owner.toLowerCase() === current_owner2.toLowerCase();
 }
-function add_entry(target, origin_url, repository_path, current_owner2) {
-  if (origin_url === void 0) return;
-  const identity = repo_origin.parse_origin_url(origin_url);
+function add_entry(target, origin_url2, repository_path, current_owner2) {
+  if (origin_url2 === void 0) return;
+  const identity = repo_origin.parse_origin_url(origin_url2);
   if (identity === void 0 || !is_same_owner(identity, current_owner2)) return;
   target.set(repo_origin.format_identity(identity), repository_path);
 }
@@ -3685,9 +3787,9 @@ function scan_siblings(parent) {
   }));
 }
 function resolve_current_owner(repository_path) {
-  const origin_url = read_origin_url(repository_path);
-  if (origin_url === void 0) return void 0;
-  return repo_origin.parse_origin_url(origin_url)?.owner;
+  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);
@@ -4181,8 +4283,8 @@ function environment() {
 function is_headless(source = process.env) {
   return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
 }
-function is_driving(read2) {
-  return read2?.kind === "carried" && read2.carry.is_handed_off !== true;
+function is_driving(read3) {
+  return read3?.kind === "carried" && read3.carry.is_handed_off !== true;
 }
 async function read_carry_here() {
   const repository2 = await run_carry.repository_directory();
@@ -4194,15 +4296,15 @@ async function must_keep_waiting(source = process.env) {
   return is_driving(await read_carry_here());
 }
 async function current_carry() {
-  const read2 = await read_carry_here();
-  return read2?.kind === "carried" ? read2.carry : void 0;
+  const read3 = await read_carry_here();
+  return read3?.kind === "carried" ? read3.carry : void 0;
 }
 function is_owned_here(carry, ancestry) {
   return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
 }
-function driven_here(read2, ancestry) {
-  if (read2?.kind !== "carried" || !is_driving(read2)) return void 0;
-  return is_owned_here(read2.carry, ancestry) ? read2.carry : void 0;
+function driven_here(read3, ancestry) {
+  if (read3?.kind !== "carried" || !is_driving(read3)) return void 0;
+  return is_owned_here(read3.carry, ancestry) ? read3.carry : void 0;
 }
 async function driving_carry(source = process.env, ancestry = lane_reap.own_ancestry) {
   if (lane_child_marker.marked_issue(source) !== void 0) return void 0;
@@ -4234,11 +4336,13 @@ function issue_url(slug, number) {
 function citation_line(slug, number, summary) {
   return `[#${number}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`;
 }
+function reference(slug, number, title) {
+  if (slug === void 0) return `#${number}`;
+  return title === void 0 ? `[#${number}](${issue_url(slug, number)})` : citation_line(slug, number, title);
+}
 function citer(slug, titles) {
   return function cite(number) {
-    if (slug === void 0) return `#${number}`;
-    const title = titles.get(number);
-    return title === void 0 ? `[#${number}](${issue_url(slug, number)})` : citation_line(slug, number, title);
+    return reference(slug, number, titles.get(number));
   };
 }
 function qualified_target(token) {
@@ -4275,6 +4379,7 @@ var issue_cite = {
   missing_line,
   no_repo_line,
   parse_target,
+  reference,
   unreadable_line
 };
 
@@ -4340,19 +4445,13 @@ var git_gh_api_path = {
   commit_status_api_path
 };
 
+// scripts/gh/git-gh-exec.ts
+import { execa as execa5, execaSync as execaSync3 } from "execa";
+
 // scripts/lib/timeouts.ts
 var FETCH_TIMEOUT_MS = 1e4;
 var COMMAND_TIMEOUT_MS = 3e4;
 
-// scripts/lib/error-message.ts
-function message_of(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-var error_text = { message_of };
-
-// scripts/gh/git-gh-exec.ts
-import { execa as execa5, execaSync as execaSync2 } from "execa";
-
 // scripts/gh/git-gh-check.ts
 import { execa as execa4 } from "execa";
 var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
@@ -4510,7 +4609,7 @@ async function exec_gh_api_status(path6, timeout_ms) {
 function exec_gh_api_status_sync(path6, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
-    const { stdout } = execaSync2("gh", ["api", "--include", "--silent", path6], options);
+    const { stdout } = execaSync3("gh", ["api", "--include", "--silent", path6], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
@@ -4554,7 +4653,7 @@ function exec_gh_api_sync(request) {
   const body_option = request.body === void 0 ? {} : { input: request.body };
   const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
   try {
-    const { stdout } = execaSync2("gh", to_gh_api_args(request), options);
+    const { stdout } = execaSync3("gh", to_gh_api_args(request), options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -4579,33 +4678,1706 @@ var git_gh_exec = {
   parse_status_line
 };
 
+// scripts/gh/git-gh-helpers.ts
+function parse_pr_state_string(result) {
+  const trimmed2 = result.trim();
+  return trimmed2.length > 0 ? trimmed2 : void 0;
+}
+function is_pr_already_exists_message(error_message) {
+  return error_message.toLowerCase().includes("already exists");
+}
+function get_error_message_with_stderr(error) {
+  if (!(error instanceof Error)) return String(error);
+  if (has_stderr_field(error) && error.stderr.length > 0) return `${error.message}
+${error.stderr}`;
+  return error.message;
+}
+function handle_pr_create_error(error) {
+  const error_message = get_error_message_with_stderr(error);
+  if (is_pr_already_exists_message(error_message)) {
+    throw new Error("PR_ALREADY_EXISTS");
+  }
+  throw error;
+}
+var git_gh_helpers = {
+  parse_pr_state_string,
+  get_error_message_with_stderr,
+  handle_pr_create_error
+};
+
+// scripts/git/schemas.ts
+import { z as z11 } from "zod";
+var package_name_schema = z11.object({ name: z11.string().min(1) });
+var rollup_item_schema = z11.looseObject({
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
+  __typename: z11.string().optional(),
+  state: z11.string().optional(),
+  status: z11.string().optional(),
+  conclusion: z11.string().optional(),
+  name: z11.string().optional(),
+  context: z11.string().optional()
+});
+var pr_raw_schema = z11.object({
+  statusCheckRollup: z11.array(rollup_item_schema).optional(),
+  mergeStateStatus: z11.string().optional(),
+  reviewDecision: z11.string().optional()
+});
+var pull_comment_schema = z11.object({
+  body: z11.string().optional(),
+  html_url: z11.string().optional(),
+  user: z11.object({ login: z11.string().optional() }).optional()
+});
+var ai_review_pull_comment_schema = z11.object({
+  body: z11.string().optional(),
+  url: z11.string().optional(),
+  author: z11.object({ login: z11.string().optional() }).optional()
+});
+var pr_info_schema = z11.object({
+  mergeable: z11.union([z11.boolean(), z11.string()]).nullable().optional(),
+  mergeStateStatus: z11.string().nullable().optional(),
+  state: z11.string().optional()
+});
+var epic_issue_schema = z11.object({
+  number: z11.number(),
+  body: z11.string().optional()
+});
+var blocking_issue_schema = z11.object({
+  number: z11.number(),
+  state: z11.string().optional(),
+  repository_url: z11.string().optional()
+});
+var blocked_by_schema = z11.object({
+  nodes: z11.array(blocking_issue_schema).default([]),
+  totalCount: z11.number().optional()
+}).optional();
+var epic_child_schema = z11.object({
+  state: z11.string().optional(),
+  blockedBy: blocked_by_schema
+});
+var rest_comment_schema = z11.looseObject({
+  body: z11.string().nullish(),
+  html_url: z11.string().optional(),
+  user: z11.looseObject({ login: z11.string().optional() }).nullish()
+});
+var issue_label_schema = z11.object({ name: z11.string() });
+var epic_subject_schema = z11.object({
+  number: z11.number(),
+  state: z11.string().optional(),
+  labels: z11.array(issue_label_schema).optional(),
+  body: z11.string().optional()
+});
+var open_issue_schema = z11.object({
+  number: z11.number(),
+  title: z11.string(),
+  labels: z11.array(issue_label_schema).optional(),
+  createdAt: z11.string(),
+  blockedBy: blocked_by_schema
+});
+
+// scripts/gh/git-gh-issue-rest.ts
+import { z as z12 } from "zod";
+
+// scripts/gh/git-gh-rest-state.ts
+var MERGED_STATE = "MERGED";
+function to_gh_state(state) {
+  return state?.toUpperCase();
+}
+
+// scripts/gh/git-gh-issue-rest.ts
+var rest_issue_schema = z12.looseObject({
+  number: z12.number(),
+  issue_dependencies_summary: z12.looseObject({ total_blocked_by: z12.number().optional() }).nullish(),
+  // Present only on a pull request, which this endpoint serves as readily as an issue.
+  pull_request: z12.looseObject({ merged_at: z12.string().nullish() }).nullish()
+});
+var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
+var REPOSITORY_URL_GROUP = 1;
+var BLOCKED_BY_FIELD = "blockedBy";
+var BLOCKED_BY_COUNT_FIELD = "blocked_by_count";
+var STATE_FIELD = "state";
+var BODY_FIELD = "body";
+var FIELD_SEPARATOR2 = ",";
+var EMPTY_BODY = "";
+var REST_FIELD_NAMES = /* @__PURE__ */ new Map([
+  ["url", "html_url"],
+  ["createdAt", "created_at"]
+]);
+var NOT_AN_ISSUE_MESSAGE = "gh api answered something other than an issue object";
+var NOT_AN_ISSUE_LISTING_MESSAGE = "gh api answered something other than an issue listing";
+var NOT_A_BLOCKER_LISTING_MESSAGE = "gh api answered something other than a blocked-by listing";
+function rest_field_name(field) {
+  return REST_FIELD_NAMES.get(field) ?? field;
+}
+function split_fields(fields) {
+  return fields.split(FIELD_SEPARATOR2).map((field) => field.trim()).filter((field) => field.length > 0);
+}
+function to_issue_state(rest, value) {
+  if (typeof rest.pull_request?.merged_at === "string") return MERGED_STATE;
+  return typeof value === "string" ? to_gh_state(value) : value;
+}
+function total_blocked_by(rest) {
+  return rest.issue_dependencies_summary?.total_blocked_by;
+}
+function to_gh_field_value(field, rest) {
+  if (field === BLOCKED_BY_COUNT_FIELD) return total_blocked_by(rest);
+  const value = rest[rest_field_name(field)];
+  if (field === STATE_FIELD) return to_issue_state(rest, value);
+  return field === BODY_FIELD ? value ?? EMPTY_BODY : value;
+}
+function parse_rest_issue(rest_json) {
+  const parsed = parse_json_object_safe(rest_json, rest_issue_schema);
+  if (parsed === void 0) throw new Error(NOT_AN_ISSUE_MESSAGE);
+  return parsed;
+}
+function is_pull_request(rest) {
+  return rest.pull_request !== void 0 && rest.pull_request !== null;
+}
+function parse_rest_issues(rest_json) {
+  const parsed = parse_json_array_or_undefined(rest_json, rest_issue_schema);
+  if (parsed === void 0) throw new Error(NOT_AN_ISSUE_LISTING_MESSAGE);
+  return parsed;
+}
+function empty_blocked_by() {
+  return { nodes: [], totalCount: 0 };
+}
+function repo_of_url(repository_url) {
+  const match = REPOSITORY_URL.exec(repository_url ?? "");
+  return match?.[REPOSITORY_URL_GROUP];
+}
+function to_blocked_by(blockers_json, exact_total) {
+  const parsed = parse_json_array_or_undefined(blockers_json, blocking_issue_schema);
+  if (parsed === void 0) throw new Error(NOT_A_BLOCKER_LISTING_MESSAGE);
+  const nodes = parsed.map((blocker) => ({ ...blocker, state: to_gh_state(blocker.state) }));
+  return { nodes, totalCount: exact_total ?? nodes.length };
+}
+function to_gh_issue(rest, fields, blocked_by) {
+  return Object.fromEntries(
+    fields.map((field) => [
+      field,
+      field === BLOCKED_BY_FIELD ? blocked_by : to_gh_field_value(field, rest)
+    ])
+  );
+}
+function to_field_text(value) {
+  if (typeof value === "string") return value;
+  return value === void 0 || value === null ? EMPTY_BODY : JSON.stringify(value);
+}
+var CLOSED = "CLOSED";
+function reference_of_blocker(node, fallback_repo) {
+  const repo = repo_of_url(node.repository_url) ?? fallback_repo;
+  if (node.state === void 0) return { repo, number: node.number };
+  return { repo, number: node.number, state: node.state.toUpperCase() === CLOSED ? CLOSED : "OPEN" };
+}
+var git_gh_issue_rest = {
+  empty_blocked_by,
+  repo_of_url,
+  reference_of_blocker,
+  split_fields,
+  is_pull_request,
+  parse_rest_issue,
+  parse_rest_issues,
+  total_blocked_by,
+  to_blocked_by,
+  to_gh_issue,
+  to_field_text
+};
+
+// scripts/gh/git-gh-reachability.ts
+var RATE_LIMITED_STATUS = 429;
+var SERVER_ERROR_FLOOR = 500;
+function is_retryable_status(status2) {
+  if (status2 >= SERVER_ERROR_FLOOR) return true;
+  return status2 === RATE_LIMITED_STATUS;
+}
+function classify_status(status2) {
+  if (status2 === void 0) return "unreachable";
+  return is_retryable_status(status2) ? "unreachable" : "reachable";
+}
+var gh_reachability = { classify_status };
+
+// scripts/gh/git-gh-issue-read.ts
+async function read_blocked_by_listing(issue_number, repo, exact_total) {
+  const json = await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.blocked_by_api_path(issue_number, repo)}${git_gh_api_path.FULL_PAGE_QUERY}`
+  });
+  return git_gh_issue_rest.to_blocked_by(json, exact_total);
+}
+async function read_blocked_by(issue_number, rest, repo) {
+  if (git_gh_issue_rest.is_pull_request(rest)) return git_gh_issue_rest.empty_blocked_by();
+  const exact_total = git_gh_issue_rest.total_blocked_by(rest);
+  if (exact_total === 0) return git_gh_issue_rest.empty_blocked_by();
+  return await read_blocked_by_listing(issue_number, repo, exact_total);
+}
+function mark_followup(error) {
+  if (!(error instanceof Error)) return error;
+  const failure = gh_failure.failure_of(error);
+  if (failure === void 0) return error;
+  return gh_failure.attach(error, { ...failure, is_followup: true });
+}
+async function read_relations(issue_number, rest, repo) {
+  try {
+    return await read_blocked_by(issue_number, rest, repo);
+  } catch (error) {
+    throw mark_followup(error);
+  }
+}
+async function read_issue_fields(issue_number, fields, repo) {
+  const rest = git_gh_issue_rest.parse_rest_issue(
+    await git_gh_exec.exec_gh_api({ path: git_gh_api_path.issue_api_path(issue_number, repo) })
+  );
+  const requested = git_gh_issue_rest.split_fields(fields);
+  const blocked_by = requested.includes(BLOCKED_BY_FIELD) ? await read_relations(issue_number, rest, repo) : void 0;
+  return git_gh_issue_rest.to_gh_issue(rest, requested, blocked_by);
+}
+var NOT_FOUND_STATUS = 404;
+function is_number_unresolved(failure) {
+  return failure.status === NOT_FOUND_STATUS && failure.is_followup !== true;
+}
+function to_unreadable_reason(status2) {
+  return gh_reachability.classify_status(status2) === "unreachable" ? "unreachable" : "rejected";
+}
+function to_read_failure(error) {
+  const failure = gh_failure.failure_of(error);
+  if (failure === void 0) return { kind: "unreadable", reason: "malformed", status: void 0 };
+  if (is_number_unresolved(failure)) return { kind: "missing" };
+  return {
+    kind: "unreadable",
+    reason: to_unreadable_reason(failure.status),
+    status: failure.status
+  };
+}
+async function issue_view_json_classified(issue_number, fields, repo) {
+  try {
+    const issue = await read_issue_fields(issue_number, fields, repo);
+    return { kind: "read", json: JSON.stringify(issue) };
+  } catch (error) {
+    return to_read_failure(error);
+  }
+}
+async function issue_view_field_classified(issue_number, field, repo) {
+  try {
+    const issue = await read_issue_fields(issue_number, field, repo);
+    return { kind: "read", text: git_gh_issue_rest.to_field_text(issue[field]) };
+  } catch (error) {
+    return to_read_failure(error);
+  }
+}
+async function issue_view_field(issue_number, field, repo) {
+  const read3 = await issue_view_field_classified(issue_number, field, repo);
+  return read3.kind === "read" ? read3.text : void 0;
+}
+async function issue_get_title(issue_number, repo) {
+  const result = await issue_view_field(issue_number, "title", repo);
+  return result === void 0 ? void 0 : git_gh_helpers.parse_pr_state_string(result);
+}
+async function issue_get_body(issue_number, repo) {
+  return await issue_view_field(issue_number, "body", repo);
+}
+async function issue_get_body_classified(issue_number, repo) {
+  return await issue_view_field_classified(issue_number, "body", repo);
+}
+async function issue_view_json(issue_number, fields, repo) {
+  const read3 = await issue_view_json_classified(issue_number, fields, repo);
+  return read3.kind === "read" ? read3.json : void 0;
+}
+var STATE_AND_RELATIONS_FIELDS = "number,state,labels,blockedBy";
+async function issue_get_state_and_relations(issue_number, repo) {
+  return await issue_view_json(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
+}
+async function issue_get_state_and_relations_classified(issue_number, repo) {
+  return await issue_view_json_classified(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
+}
+function is_unreachable_read(failure) {
+  return failure.kind === "unreadable" && failure.reason === "unreachable";
+}
+var PLAN_FIELDS = "number,title,body,state,url,labels,blockedBy";
+async function issue_get_plan_fields(issue_number) {
+  return await issue_view_json(issue_number, PLAN_FIELDS);
+}
+async function issue_get_plan_fields_classified(issue_number) {
+  return await issue_view_json_classified(issue_number, PLAN_FIELDS);
+}
+async function issue_get_labels_and_body(issue_number) {
+  return await issue_view_json(issue_number, "number,state,labels,body");
+}
+async function issue_list_comments(issue_number) {
+  const path6 = `${git_gh_api_path.issue_comments_api_path(issue_number)}${git_gh_api_path.FULL_PAGE_QUERY}`;
+  try {
+    return await git_gh_exec.exec_gh_api({ path: path6, should_paginate: true });
+  } catch {
+    return void 0;
+  }
+}
+async function has_no_relations_endpoint(issue_number, repo) {
+  const status2 = await git_gh_exec.exec_gh_api_status(
+    git_gh_api_path.blocked_by_api_path(issue_number, repo)
+  );
+  return status2 === NOT_FOUND_STATUS;
+}
+async function issue_blocked_by_references(issue_number, own_repo, repo) {
+  try {
+    const listing = await read_blocked_by_listing(issue_number, repo);
+    return listing.nodes.map((blocker) => git_gh_issue_rest.reference_of_blocker(blocker, own_repo));
+  } catch (error) {
+    if (await has_no_relations_endpoint(issue_number, repo)) return [];
+    throw error;
+  }
+}
+async function issue_blocked_by_numbers(issue_number, repo) {
+  const references = await issue_blocked_by_references(issue_number, "", repo);
+  return references.map((blocker) => blocker.number);
+}
+var git_gh_issue_read = {
+  issue_blocked_by_numbers,
+  issue_blocked_by_references,
+  issue_get_title,
+  issue_get_body,
+  issue_get_body_classified,
+  issue_view_json,
+  issue_view_json_classified,
+  issue_get_state_and_relations,
+  issue_get_state_and_relations_classified,
+  is_unreachable_read,
+  issue_get_plan_fields,
+  issue_get_plan_fields_classified,
+  issue_get_labels_and_body,
+  issue_list_comments
+};
+
+// scripts/gh/git-gh-issue-list.ts
+var PER_PAGE = 100;
+var FIRST_PAGE = 1;
+var DEFAULT_STATE = "open";
+var DEFAULT_SORT = "created";
+var LISTING_DIRECTION = "direction=desc";
+function listing_query(request) {
+  const state = request.state ?? DEFAULT_STATE;
+  const sort = request.sort ?? DEFAULT_SORT;
+  return `state=${state}&sort=${sort}&${LISTING_DIRECTION}`;
+}
+function listing_path(request, page) {
+  const label2 = request.label === void 0 ? "" : `&labels=${encodeURIComponent(request.label)}`;
+  const paging = `&per_page=${String(PER_PAGE)}&page=${String(page)}`;
+  return `${git_gh_api_path.issues_api_path(request.repo)}?${listing_query(request)}${label2}${paging}`;
+}
+var DIGIT_PATTERN = /\d/u;
+function has_token_occurrence(body, term) {
+  let index = body.indexOf(term);
+  while (index !== -1) {
+    if (!DIGIT_PATTERN.test(body.charAt(index + term.length))) return true;
+    index = body.indexOf(term, index + 1);
+  }
+  return false;
+}
+function matches_body(rest, term) {
+  if (term === void 0) return true;
+  const { body } = rest;
+  return typeof body === "string" && has_token_occurrence(body, term);
+}
+function is_selected(rest, request) {
+  return !git_gh_issue_rest.is_pull_request(rest) && matches_body(rest, request.body_term);
+}
+async function fetch_page(request, page) {
+  const path6 = listing_path(request, page);
+  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path6 }));
+  return {
+    selected: rows.filter((row) => is_selected(row, request)),
+    is_full: rows.length >= PER_PAGE
+  };
+}
+var MAX_PAGES = 5;
+var MAX_SCANNED = MAX_PAGES * PER_PAGE;
+function wants_more(has_more, selected_count, limit) {
+  return has_more && selected_count < limit;
+}
+async function fetch_selected(request) {
+  const selected = [];
+  let page = FIRST_PAGE;
+  let has_more = true;
+  while (page <= MAX_PAGES && wants_more(has_more, selected.length, request.limit)) {
+    const result = await fetch_page(request, page);
+    selected.push(...result.selected);
+    has_more = result.is_full;
+    page += 1;
+  }
+  return {
+    rows: selected.slice(0, request.limit),
+    is_capped: wants_more(has_more, selected.length, request.limit)
+  };
+}
+var RELATION_CONCURRENCY = 8;
+async function read_relations2(rows, repo) {
+  return await bounded_pool.bounded_map(
+    rows,
+    RELATION_CONCURRENCY,
+    async (row) => await read_blocked_by(String(row.number), row, repo)
+  );
+}
+async function issue_list(request) {
+  try {
+    const { rows, is_capped } = await fetch_selected(request);
+    const fields = git_gh_issue_rest.split_fields(request.json_fields);
+    const relations = fields.includes(BLOCKED_BY_FIELD) ? await read_relations2(rows, request.repo) : void 0;
+    const mapped = rows.map(
+      (row, index) => git_gh_issue_rest.to_gh_issue(row, fields, relations?.[index])
+    );
+    return { json: JSON.stringify(mapped), is_capped };
+  } catch {
+    return { json: void 0, is_capped: false };
+  }
+}
+var git_gh_issue_list = {
+  issue_list
+};
+
+// scripts/gh/git-gh-issue-write.ts
+var PATCH_METHOD = "PATCH";
+var DELETE_METHOD = "DELETE";
+var HTML_URL_FILTER = ".html_url";
+var ID_FILTER = ".id";
+var LABELS_SEGMENT = "/labels";
+var COMMENTS_SEGMENT = "/comments";
+var CLOSED_STATE = "closed";
+var COLOR_HASH = "#";
+async function did_write_succeed(write) {
+  try {
+    await write();
+    return true;
+  } catch (error) {
+    error_text.trace_swallowed("git_gh_issue_write.did_write_succeed", error);
+    return false;
+  }
+}
+async function issue_edit_body(issue_number, body) {
+  return await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.issue_api_path(issue_number),
+    method: PATCH_METHOD,
+    body: JSON.stringify({ body }),
+    jq_filter: HTML_URL_FILTER
+  });
+}
+async function issue_comment(issue_number, body) {
+  return await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.issue_api_path(issue_number)}${COMMENTS_SEGMENT}`,
+    body: JSON.stringify({ body }),
+    jq_filter: HTML_URL_FILTER
+  });
+}
+async function issue_try_comment(issue_number, body) {
+  return await did_write_succeed(async () => await issue_comment(issue_number, body));
+}
+async function issue_close(issue_number, comment) {
+  return await did_write_succeed(async () => {
+    if (comment !== void 0) await issue_comment(issue_number, comment);
+    await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.issue_api_path(issue_number),
+      method: PATCH_METHOD,
+      body: JSON.stringify({ state: CLOSED_STATE })
+    });
+  });
+}
+function to_label_color(color) {
+  return color.startsWith(COLOR_HASH) ? color.slice(COLOR_HASH.length) : color;
+}
+async function label_ensure(input) {
+  try {
+    await git_gh_exec.exec_gh_api({
+      path: `${git_gh_api_path.repo_api_path()}${LABELS_SEGMENT}`,
+      body: JSON.stringify({
+        name: input.name,
+        color: to_label_color(input.color),
+        description: input.description
+      })
+    });
+  } catch {
+  }
+}
+function issue_create_request(input) {
+  const { labels } = input;
+  return {
+    path: git_gh_api_path.issues_api_path(input.repo),
+    body: JSON.stringify({
+      title: input.title,
+      ...labels !== void 0 && { labels },
+      body: input.body
+    }),
+    jq_filter: HTML_URL_FILTER
+  };
+}
+async function issue_create_with_label(input) {
+  return await git_gh_exec.exec_gh_api(
+    issue_create_request({ title: input.title, body: input.body, labels: [input.label] })
+  );
+}
+async function issue_add_label(issue_number, label2) {
+  return await did_write_succeed(
+    async () => await git_gh_exec.exec_gh_api({
+      path: `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`,
+      body: JSON.stringify({ labels: [label2] })
+    })
+  );
+}
+async function issue_remove_label(issue_number, label2) {
+  const labels_path = `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`;
+  await git_gh_exec.exec_gh_api({
+    path: `${labels_path}/${encodeURIComponent(label2)}`,
+    method: DELETE_METHOD
+  });
+}
+async function read_issue_id(issue_number) {
+  const raw = await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.issue_api_path(issue_number),
+    jq_filter: ID_FILTER
+  });
+  const issue_id = Number(raw.trim());
+  if (!Number.isSafeInteger(issue_id) || issue_id <= 0) {
+    throw new Error(`gh api answered no database id for issue #${issue_number}`);
+  }
+  return issue_id;
+}
+async function issue_add_blocked_by(issue_number, blocker) {
+  return await did_write_succeed(async () => {
+    const issue_id = await read_issue_id(blocker);
+    await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.blocked_by_api_path(issue_number),
+      body: JSON.stringify({ issue_id })
+    });
+  });
+}
+async function issue_remove_blocked_by(issue_number, blocker) {
+  return await did_write_succeed(async () => {
+    const issue_id = await read_issue_id(blocker);
+    const relations_path = git_gh_api_path.blocked_by_api_path(issue_number);
+    await git_gh_exec.exec_gh_api({
+      path: `${relations_path}/${String(issue_id)}`,
+      method: DELETE_METHOD
+    });
+  });
+}
+var git_gh_issue_write = {
+  issue_edit_body,
+  issue_comment,
+  issue_try_comment,
+  issue_close,
+  label_ensure,
+  issue_create_request,
+  issue_create_with_label,
+  issue_add_label,
+  issue_remove_label,
+  issue_add_blocked_by,
+  issue_remove_blocked_by
+};
+
+// scripts/gh/git-gh-issue.ts
+var NUMBER_AND_BODY_FIELDS = "number,body";
+var BACKLOG_SCAN_FIELDS = `number,title,body,${BLOCKED_BY_COUNT_FIELD}`;
+var NUMBER_TITLE_AND_LABELS_FIELDS = "number,title,labels";
+var SUMMARY_FIELDS = "number,title,labels,createdAt";
+var PICKUP_FIELDS = `${SUMMARY_FIELDS},blockedBy`;
+var { issue_list: issue_list2 } = git_gh_issue_list;
+async function issue_list_recent(limit) {
+  return await issue_list2({ json_fields: SUMMARY_FIELDS, limit });
+}
+async function issue_list_open_bodies(limit) {
+  return await issue_list2({ json_fields: BACKLOG_SCAN_FIELDS, limit });
+}
+async function issue_list_recently_closed(limit) {
+  return await issue_list2({
+    json_fields: NUMBER_TITLE_AND_LABELS_FIELDS,
+    limit,
+    state: "closed",
+    sort: "updated"
+  });
+}
+async function issue_search_body(term, limit) {
+  return await issue_list2({
+    json_fields: NUMBER_AND_BODY_FIELDS,
+    limit,
+    body_term: term
+  });
+}
+async function issue_list_by_label(label2, limit) {
+  return await issue_list2({ json_fields: NUMBER_AND_BODY_FIELDS, limit, label: label2 });
+}
+async function issue_list_by_label_summary(label2, limit, options) {
+  return await issue_list2({
+    json_fields: options?.json_fields ?? PICKUP_FIELDS,
+    limit,
+    label: label2
+  });
+}
+async function issue_list_by_label_in_repo(label2, limit, repo) {
+  return await issue_list2({ json_fields: SUMMARY_FIELDS, limit, label: label2, repo });
+}
+var git_gh_issue = {
+  ...git_gh_issue_read,
+  ...git_gh_issue_write,
+  issue_list_recent,
+  issue_list_by_label,
+  issue_list_by_label_in_repo,
+  issue_list_by_label_summary,
+  issue_search_body,
+  issue_list_open_bodies,
+  issue_list_recently_closed
+};
+
+// scripts/ci/pr-classification.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { z as z13 } from "zod";
+var CLASSIFICATION_SET = new Set(RELEASE_CLASSIFICATION_NAMES);
+var ISSUE_BUG_LABEL = "bug";
+var DECLARATION_PREFIX = "- \u30EA\u30EA\u30FC\u30B9\u5206\u985E: ";
+var DECLARATION = new RegExp(`^${DECLARATION_PREFIX}(.+)$`, "gmu");
+var LEGACY_LABELS = /* @__PURE__ */ new Set(["semver-major", "semver-minor"]);
+var LABEL = z13.object({ name: z13.string() });
+var USER = z13.object({ login: z13.string() });
+var PULL_REQUEST = z13.object({ number: z13.number(), user: USER });
+var EVENT = z13.object({
+  pull_request: PULL_REQUEST,
+  repository: z13.object({ full_name: z13.string() })
+});
+function classification_error(labels, author) {
+  const legacy = labels.filter((label2) => LEGACY_LABELS.has(label2.toLowerCase()));
+  if (legacy.length > 0) return `Remove legacy release labels: ${legacy.join(", ")}`;
+  const selected = labels.filter((label2) => CLASSIFICATION_SET.has(label2.toLowerCase()));
+  if (selected.length > 1) {
+    return `Choose exactly one release classification; found: ${selected.join(", ")}`;
+  }
+  if (selected.length === 1 || author.endsWith("[bot]")) return void 0;
+  return `Choose one release classification: ${RELEASE_CLASSIFICATION_NAMES.join(", ")}`;
+}
+function declaration(label2) {
+  return `${DECLARATION_PREFIX}${label2}`;
+}
+function is_classification(value) {
+  return CLASSIFICATION_SET.has(value);
+}
+function release_candidates(candidates) {
+  if (!candidates.includes(BREAKING_CHANGE_LABEL)) return candidates;
+  return candidates.filter((candidate) => candidate !== ENHANCEMENT_LABEL);
+}
+function issue_candidates(issue_json) {
+  const issue = z13.object({ labels: z13.array(LABEL), body: z13.string().nullable() }).parse(JSON.parse(issue_json));
+  const names = issue.labels.map((label2) => label2.name.toLowerCase());
+  const declared = [...(issue.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
+  const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
+  const unknown = declared.filter((value) => !is_classification(value));
+  if (unknown.length > 0) throw new Error(`Unknown release classification: ${unknown.join(", ")}`);
+  if (names.includes(ISSUE_BUG_LABEL) && !candidates.includes(BREAKING_CHANGE_LABEL)) {
+    candidates.push(BUGFIX_LABEL);
+  }
+  return candidates;
+}
+function select_issue_classification(issue_json) {
+  const candidates = issue_candidates(issue_json);
+  const selected = [...new Set(candidates)];
+  const [label2] = selected;
+  if (label2 === void 0 || selected.length > 1) {
+    throw new Error(
+      `Choose one release classification before opening the PR: ${RELEASE_CLASSIFICATION_NAMES.join(", ")}; found: ${selected.join(", ") || "none"}. Add "${DECLARATION_PREFIX}<label>" to the Issue body.`
+    );
+  }
+  return label2;
+}
+function fetch_current_labels(repository2, pull_number) {
+  const path6 = `repos/${repository2}/issues/${String(pull_number)}/labels`;
+  try {
+    const names = git_gh_exec.exec_gh_api_sync({ path: path6, jq_filter: ".[].name" });
+    return names.split("\n").filter((name) => name !== "");
+  } catch (error) {
+    const detail = error_text.message_of(error);
+    throw new Error(`Could not read the pull request labels: ${detail}`, { cause: error });
+  }
+}
+function check_event(event_path, read_labels = fetch_current_labels) {
+  const event = EVENT.parse(JSON.parse(readFileSync4(event_path, "utf8")));
+  const labels = read_labels(event.repository.full_name, event.pull_request.number);
+  return classification_error(labels, event.pull_request.user.login);
+}
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+  const event_path = process.env["GITHUB_EVENT_PATH"];
+  if (!event_path) throw new Error("GITHUB_EVENT_PATH is required");
+  const error = check_event(event_path);
+  if (error) {
+    console.error(`::error::${error}`);
+    process.exitCode = 1;
+  }
+}
+var pr_classification = {
+  classification_error,
+  check_event,
+  fetch_current_labels,
+  declaration,
+  is_classification,
+  select_issue_classification
+};
+
+// scripts/lib/poll.ts
+async function sleep3(duration_ms) {
+  await new Promise((resolve3) => {
+    setTimeout(resolve3, duration_ms);
+  });
+}
+async function wait_between(wait, interval_ms, attempt, attempts) {
+  if (attempt < attempts - 1) await wait(interval_ms);
+}
+async function poll_until(is_done2, options) {
+  const wait = options.sleeper ?? sleep3;
+  for (let attempt = 0; attempt < options.attempts; attempt += 1) {
+    if (await is_done2()) return true;
+    await wait_between(wait, options.interval_ms, attempt, options.attempts);
+  }
+  return false;
+}
+var poll = { poll_until, sleep: sleep3 };
+
+// scripts/gh/git-gh-pr.ts
+import { z as z17 } from "zod";
+
+// scripts/gh/git-gh-pr-rest.ts
+import { z as z14 } from "zod";
+var rest_repo_schema = z14.looseObject({ full_name: z14.string().optional() }).nullish();
+var rest_pull_side_schema = z14.looseObject({ repo: rest_repo_schema });
+var rest_pull_schema = z14.looseObject({
+  number: z14.number(),
+  html_url: z14.string().optional(),
+  body: z14.string().nullish(),
+  state: z14.string().optional(),
+  merged: z14.boolean().nullish(),
+  merged_at: z14.string().nullish(),
+  mergeable: z14.boolean().nullish(),
+  mergeable_state: z14.string().optional(),
+  // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
+  // REST hangs the check runs and the status contexts off the commit rather than off the pull
+  // request (joshuafolkken/kit#1028).
+  head: z14.looseObject({ ref: z14.string().optional(), sha: z14.string().optional(), repo: rest_repo_schema }).nullish(),
+  base: rest_pull_side_schema.nullish(),
+  // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
+  // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`
+  // (joshuafolkken/kit#2497).
+  node_id: z14.string().optional(),
+  auto_merge: z14.looseObject({}).nullish()
+});
+var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
+var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
+var NOT_A_COMMENT_LISTING_MESSAGE = "gh api answered something other than a comment listing";
+var OPEN_STATE = "open";
+var EMPTY_BODY2 = "";
+function parse_rest_pull(rest_json) {
+  const parsed = parse_json_object_safe(rest_json, rest_pull_schema);
+  if (parsed === void 0) throw new Error(NOT_A_PULL_MESSAGE);
+  return parsed;
+}
+function parse_rest_pulls(rest_json) {
+  const parsed = parse_json_array_or_undefined(rest_json, rest_pull_schema);
+  if (parsed === void 0) throw new Error(NOT_A_PULL_LISTING_MESSAGE);
+  return parsed;
+}
+function select_pull(pulls) {
+  return pulls.find((pull) => pull.state === OPEN_STATE) ?? pulls[0];
+}
+function is_merged(pull) {
+  return pull.merged === true || typeof pull.merged_at === "string";
+}
+function to_pr_state(pull) {
+  return is_merged(pull) ? MERGED_STATE : to_gh_state(pull.state);
+}
+function to_repo_name(side) {
+  return side?.repo?.full_name;
+}
+function is_same_repository_head(pull) {
+  const head_repo = to_repo_name(pull.head);
+  return head_repo !== void 0 && head_repo === to_repo_name(pull.base);
+}
+function to_pr_info(pull) {
+  return {
+    mergeable: pull.mergeable,
+    mergeStateStatus: to_gh_state(pull.mergeable_state),
+    state: to_pr_state(pull)
+  };
+}
+function to_pr_comments(rest_json) {
+  const parsed = parse_json_array_or_undefined(rest_json, rest_comment_schema);
+  if (parsed === void 0) throw new Error(NOT_A_COMMENT_LISTING_MESSAGE);
+  return parsed.map((comment) => ({
+    body: comment.body ?? EMPTY_BODY2,
+    url: comment.html_url,
+    author: { login: comment.user?.login }
+  }));
+}
+var git_gh_pr_rest = {
+  parse_rest_pull,
+  parse_rest_pulls,
+  select_pull,
+  is_same_repository_head,
+  is_merged,
+  to_pr_state,
+  to_pr_info,
+  to_pr_comments
+};
+
+// scripts/gh/git-gh-pr-read.ts
+var pr_number_by_branch = /* @__PURE__ */ new Map();
+var LOOKUP_QUERY = "state=all&sort=created&direction=desc&per_page=100";
+var COMMENTS_QUERY = FULL_PAGE_QUERY;
+var OWNER_PLACEHOLDER = "{owner}";
+var NO_PULL_REQUEST_MESSAGE = "gh api found no pull request for branch";
+var UNREADABLE_PULL_REQUEST_MESSAGE = "gh api could not read the pull requests for branch";
+function lookup_path(branch_name) {
+  const head = `${OWNER_PLACEHOLDER}:${encodeURIComponent(branch_name)}`;
+  return `${git_gh_api_path.pulls_api_path()}?head=${head}&${LOOKUP_QUERY}`;
+}
+async function fetch_pr_number(branch_name) {
+  const json = await git_gh_exec.exec_gh_api({ path: lookup_path(branch_name) });
+  return git_gh_pr_rest.select_pull(git_gh_pr_rest.parse_rest_pulls(json))?.number;
+}
+var pending_pr_number_by_branch = /* @__PURE__ */ new Map();
+async function fetch_pr_number_read(branch_name) {
+  try {
+    const pr_number = await fetch_pr_number(branch_name);
+    if (pr_number === void 0) return { kind: "missing" };
+    pr_number_by_branch.set(branch_name, pr_number);
+    return { kind: "read", pr_number };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+async function start_pr_number_read(branch_name) {
+  const pending = pending_pr_number_by_branch.get(branch_name);
+  if (pending !== void 0) return await pending;
+  const lookup = fetch_pr_number_read(branch_name);
+  pending_pr_number_by_branch.set(branch_name, lookup);
+  try {
+    return await lookup;
+  } finally {
+    pending_pr_number_by_branch.delete(branch_name);
+  }
+}
+function forget_pr_numbers() {
+  pr_number_by_branch.clear();
+  pending_pr_number_by_branch.clear();
+}
+async function read_pr_number(branch_name) {
+  const cached = pr_number_by_branch.get(branch_name);
+  if (cached !== void 0) return { kind: "read", pr_number: cached };
+  return await start_pr_number_read(branch_name);
+}
+async function resolve_pr_number(branch_name) {
+  const read3 = await read_pr_number(branch_name);
+  return read3.kind === "read" ? read3.pr_number : void 0;
+}
+function to_unreadable_error(branch_name, cause) {
+  return new Error(`${UNREADABLE_PULL_REQUEST_MESSAGE}: ${branch_name}`, { cause });
+}
+async function require_pr_number(branch_name) {
+  const read3 = await read_pr_number(branch_name);
+  if (read3.kind === "read") return read3.pr_number;
+  if (read3.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
+  throw to_unreadable_error(branch_name, read3.cause);
+}
+async function read_pull(pr_number) {
+  const json = await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_api_path(String(pr_number))
+  });
+  return git_gh_pr_rest.parse_rest_pull(json);
+}
+async function read_pull_of_branch(branch_name) {
+  const pr_number = await resolve_pr_number(branch_name);
+  if (pr_number === void 0) return void 0;
+  try {
+    return await read_pull(pr_number);
+  } catch {
+    return void 0;
+  }
+}
+async function pr_exists(branch_name) {
+  const read3 = await read_pr_number(branch_name);
+  if (read3.kind === "unreadable") throw to_unreadable_error(branch_name, read3.cause);
+  return read3.kind === "read";
+}
+async function pr_get_number(branch_name) {
+  return await resolve_pr_number(branch_name);
+}
+async function pr_get_url(branch_name) {
+  const pull = await read_pull_of_branch(branch_name);
+  if (pull?.html_url === void 0) return void 0;
+  return git_gh_helpers.parse_pr_state_string(pull.html_url);
+}
+async function pr_get_merge_state(branch_name) {
+  const pull = await read_pull_of_branch(branch_name);
+  if (pull === void 0) return void 0;
+  return {
+    is_merged: git_gh_pr_rest.is_merged(pull),
+    merged_at: pull.merged_at ?? void 0,
+    head_sha: pull.head?.sha
+  };
+}
+async function pr_get_body(branch_name) {
+  const pull = await read_pull_of_branch(branch_name);
+  const body = pull?.body;
+  return typeof body === "string" && body.length > 0 ? body : void 0;
+}
+async function pr_view(branch_name) {
+  const pull = await read_pull_of_branch(branch_name);
+  if (pull === void 0) return "";
+  return JSON.stringify(git_gh_pr_rest.to_pr_info(pull));
+}
+async function read_comments(branch_name, to_path, to_json) {
+  const pr_number = await resolve_pr_number(branch_name);
+  if (pr_number === void 0) return void 0;
+  const path6 = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
+  try {
+    return to_json(await git_gh_exec.exec_gh_api({ path: path6, should_paginate: true }));
+  } catch {
+    return void 0;
+  }
+}
+function to_comments_json(raw) {
+  return JSON.stringify(git_gh_pr_rest.to_pr_comments(raw));
+}
+function as_served(raw) {
+  return raw;
+}
+async function pr_get_comments(branch_name) {
+  return await read_comments(branch_name, git_gh_api_path.issue_comments_api_path, to_comments_json);
+}
+async function pr_get_review_comments(branch_name) {
+  return await read_comments(branch_name, git_gh_api_path.pull_comments_api_path, as_served);
+}
+var git_gh_pr_read = {
+  pr_exists,
+  pr_get_number,
+  pr_get_url,
+  pr_get_body,
+  pr_get_merge_state,
+  pr_view,
+  pr_get_comments,
+  pr_get_review_comments
+};
+
+// scripts/gh/git-gh-pr-review.ts
+import { z as z15 } from "zod";
+var REVIEW_APPROVED = "APPROVED";
+var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
+var REVIEW_NONE = "";
+var STATE_CHANGING_REVIEWS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
+var rest_review_schema = z15.looseObject({
+  state: z15.string().optional(),
+  user: z15.looseObject({ login: z15.string().optional() }).nullish()
+});
+var NOT_A_REVIEW_LISTING = "gh api answered something other than a review listing";
+function parse_rest_reviews(reviews_json) {
+  const parsed = parse_json_array_or_undefined(reviews_json, rest_review_schema);
+  if (parsed === void 0) throw new Error(NOT_A_REVIEW_LISTING);
+  return parsed;
+}
+var UNATTRIBUTED_REVIEWER = "(no author)";
+function read_reviewer(review) {
+  const login = review.user?.login;
+  return typeof login === "string" && login.length > 0 ? login : UNATTRIBUTED_REVIEWER;
+}
+function read_state_changing(review) {
+  const state = review.state?.toUpperCase();
+  return state !== void 0 && STATE_CHANGING_REVIEWS.has(state) ? state : void 0;
+}
+function fold_latest_states(reviews) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const review of reviews) {
+    const state = read_state_changing(review);
+    if (state !== void 0) latest.set(read_reviewer(review), state);
+  }
+  return latest;
+}
+function to_review_decision(reviews_json) {
+  const latest = new Set(fold_latest_states(parse_rest_reviews(reviews_json)).values());
+  if (latest.has(REVIEW_CHANGES_REQUESTED)) return REVIEW_CHANGES_REQUESTED;
+  return latest.has(REVIEW_APPROVED) ? REVIEW_APPROVED : REVIEW_NONE;
+}
+var git_gh_pr_review = { to_review_decision };
+
+// scripts/gh/git-gh-pr-rollup.ts
+import { z as z16 } from "zod";
+var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
+var TYPE_NAME_KEY = "__typename";
+var rollup_element_schema = z16.looseObject({});
+var check_runs_page_schema = z16.looseObject({
+  // Required, not optional: GitHub always names the key, and accepting a page without one would
+  // answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
+  check_runs: z16.array(rollup_element_schema)
+});
+var id_holder_schema = z16.object({ id: z16.number() });
+var status_page_schema = z16.looseObject({
+  statuses: z16.array(rollup_element_schema)
+});
+var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
+var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
+function read_pages(raw_json, schema, message) {
+  const pages = parse_json_array_or_undefined(raw_json, schema);
+  if (pages === void 0) throw new Error(message);
+  return pages;
+}
+var NO_SUITE = -1;
+function read_id(value) {
+  const parsed = id_holder_schema.safeParse(value);
+  return parsed.success ? parsed.data.id : void 0;
+}
+function check_run_group_key(run3) {
+  const { name, app } = run3;
+  if (typeof name !== "string") return void 0;
+  return JSON.stringify([name, read_id(app)]);
+}
+function read_rank(run3) {
+  const id = read_id(run3);
+  if (id === void 0) return void 0;
+  return { suite: read_id(run3["check_suite"]) ?? NO_SUITE, run: id };
+}
+function is_ranked_above(candidate, current) {
+  if (candidate.suite !== current.suite) return candidate.suite > current.suite;
+  return candidate.run > current.run;
+}
+function should_replace(previous, rank) {
+  const previous_rank = previous === void 0 ? void 0 : read_rank(previous);
+  return previous_rank === void 0 || is_ranked_above(rank, previous_rank);
+}
+function remember_newest_run(run3, newest) {
+  const key2 = check_run_group_key(run3);
+  const rank = read_rank(run3);
+  if (key2 === void 0 || rank === void 0) return;
+  if (should_replace(newest.get(key2), rank)) newest.set(key2, run3);
+}
+function is_newest_run(run3, newest) {
+  const key2 = check_run_group_key(run3);
+  if (key2 === void 0 || read_rank(run3) === void 0) return true;
+  return newest.get(key2) === run3;
+}
+function to_check_run_items(check_runs_json) {
+  const pages = read_pages(check_runs_json, check_runs_page_schema, NOT_A_CHECK_RUNS_LISTING);
+  const runs = pages.flatMap((page) => page.check_runs);
+  const newest = /* @__PURE__ */ new Map();
+  for (const run3 of runs) remember_newest_run(run3, newest);
+  return runs.filter((run3) => is_newest_run(run3, newest));
+}
+function to_status_context_items(status_json) {
+  const pages = read_pages(status_json, status_page_schema, NOT_A_STATUS_LISTING);
+  return pages.flatMap((page) => page.statuses).map((status2) => ({ ...status2, [TYPE_NAME_KEY]: STATUS_CONTEXT_TYPE_NAME }));
+}
+function to_status_check_rollup(input) {
+  return [
+    ...to_check_run_items(input.check_runs_json),
+    ...to_status_context_items(input.status_json)
+  ];
+}
+var git_gh_pr_rollup = {
+  to_status_check_rollup
+};
+
+// scripts/gh/git-gh-pr-snapshot.ts
+var NO_HEAD_SHA_MESSAGE = "gh api answered a pull request with no head commit";
+async function read_object_pages(path6) {
+  return await git_gh_exec.exec_gh_api({
+    path: `${path6}${FULL_PAGE_QUERY}`,
+    should_paginate: true,
+    should_slurp: true
+  });
+}
+async function read_array_pages(path6) {
+  return await git_gh_exec.exec_gh_api({
+    path: `${path6}${FULL_PAGE_QUERY}`,
+    should_paginate: true
+  });
+}
+function read_head_sha(pull) {
+  const sha = pull.head?.sha;
+  if (sha === void 0) throw new Error(NO_HEAD_SHA_MESSAGE);
+  return sha;
+}
+async function read_status_check_rollup(commit_sha) {
+  const [check_runs_json, status_json] = await Promise.all([
+    read_object_pages(git_gh_api_path.commit_check_runs_api_path(commit_sha)),
+    read_object_pages(git_gh_api_path.commit_status_api_path(commit_sha))
+  ]);
+  return git_gh_pr_rollup.to_status_check_rollup({ check_runs_json, status_json });
+}
+async function pr_get_review_decision(pr_number) {
+  const path6 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
+  return git_gh_pr_review.to_review_decision(await read_array_pages(path6));
+}
+async function build_checks_fields(pull) {
+  return {
+    statusCheckRollup: await read_status_check_rollup(read_head_sha(pull)),
+    mergeStateStatus: to_gh_state(pull.mergeable_state)
+  };
+}
+async function resolve_pull(branch_name) {
+  const pr_number = await require_pr_number(branch_name);
+  return { pr_number, pull: await read_pull(pr_number) };
+}
+async function pr_get_checks_snapshot(branch_name) {
+  const { pr_number, pull } = await resolve_pull(branch_name);
+  return { pr_number, snapshot_json: JSON.stringify(await build_checks_fields(pull)) };
+}
+async function pr_get_state_snapshot(branch_name) {
+  const { pr_number, pull } = await resolve_pull(branch_name);
+  const [fields, review_decision] = await Promise.all([
+    build_checks_fields(pull),
+    pr_get_review_decision(pr_number)
+  ]);
+  return JSON.stringify({ ...fields, reviewDecision: review_decision });
+}
+var git_gh_pr_snapshot = {
+  pr_get_state_snapshot,
+  pr_get_checks_snapshot,
+  pr_get_review_decision
+};
+
+// scripts/gh/git-gh-pr.ts
+var HTML_URL_FILTER2 = ".html_url";
+var PUT_METHOD = "PUT";
+var PATCH_METHOD2 = "PATCH";
+var MERGE_COMMIT_METHOD = "merge";
+var MERGE_REQUEST_TIMEOUT_MS = 18e4;
+var MERGE_UNCONFIRMED_MESSAGE = "gh api could not read the pull request back after the merge request failed";
+var MERGE_READ_BACK_ATTEMPTS = 3;
+var MERGE_READ_BACK_INTERVAL_MS = 1e3;
+var PR_NUMBER_PATTERN = /\/pull\/([1-9]\d*)$/u;
+var LABELS_SEGMENT2 = "/labels";
+var PR_LABELS = z17.array(z17.object({ name: z17.string() }));
+async function add_pr_classification(number, label2) {
+  await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.issue_api_path(number)}${LABELS_SEGMENT2}`,
+    body: JSON.stringify({ labels: [label2] })
+  });
+}
+async function pr_get_classification(branch_name) {
+  const number = await require_pr_number(branch_name);
+  const response = await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.issue_api_path(String(number))}${LABELS_SEGMENT2}`
+  });
+  const names = PR_LABELS.parse(JSON.parse(response)).map((label2) => label2.name.toLowerCase());
+  const selected = names.filter((name) => pr_classification.is_classification(name));
+  if (selected.length === 0) return void 0;
+  const error = pr_classification.classification_error(names, "human");
+  if (error !== void 0) throw new Error(error);
+  return selected[0];
+}
+async function pr_ensure_classification(branch_name, label2) {
+  if (await pr_get_classification(branch_name) !== void 0) return;
+  const number = await require_pr_number(branch_name);
+  await add_pr_classification(String(number), label2);
+}
+async function post_pull_request(title, body) {
+  const base = await git_command.get_default_branch();
+  const head = await git_command.branch();
+  forget_pr_numbers();
+  try {
+    return await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.pulls_api_path(),
+      body: JSON.stringify({ title, body, head, base }),
+      jq_filter: HTML_URL_FILTER2
+    });
+  } catch (error) {
+    return git_gh_helpers.handle_pr_create_error(error);
+  }
+}
+async function pr_create(title, body, label2) {
+  const classification_error2 = pr_classification.classification_error([label2], "human");
+  if (classification_error2 !== void 0) throw new Error(classification_error2);
+  const url = await post_pull_request(title, body);
+  const number = PR_NUMBER_PATTERN.exec(url)?.[1];
+  if (number === void 0) throw new Error(`Could not identify the created pull request: ${url}`);
+  await add_pr_classification(number, label2);
+  return url;
+}
+async function pr_comment(branch_name, body) {
+  const pr_number = await require_pr_number(branch_name);
+  return await git_gh_issue_write.issue_comment(String(pr_number), body);
+}
+async function pr_update_body(branch_name, body) {
+  const pr_number = await require_pr_number(branch_name);
+  await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_api_path(String(pr_number)),
+    method: PATCH_METHOD2,
+    body: JSON.stringify({ body })
+  });
+}
+async function put_merge(pr_number) {
+  await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_merge_api_path(String(pr_number)),
+    method: PUT_METHOD,
+    body: JSON.stringify({ merge_method: MERGE_COMMIT_METHOD }),
+    timeout_ms: MERGE_REQUEST_TIMEOUT_MS
+  });
+}
+async function read_merge_state(pr_number) {
+  try {
+    return git_gh_pr_rest.is_merged(await read_pull(pr_number));
+  } catch (error) {
+    console.warn(`Could not read the pull request back: ${String(error)}`);
+    return void 0;
+  }
+}
+async function sleep_between_read_backs(attempt) {
+  if (attempt < MERGE_READ_BACK_ATTEMPTS - 1) await poll.sleep(MERGE_READ_BACK_INTERVAL_MS);
+}
+async function has_merge_landed(pr_number, merge_error) {
+  for (let attempt = 0; attempt < MERGE_READ_BACK_ATTEMPTS; attempt += 1) {
+    const is_merged2 = await read_merge_state(pr_number);
+    if (is_merged2 !== void 0) return is_merged2;
+    await sleep_between_read_backs(attempt);
+  }
+  throw new Error(MERGE_UNCONFIRMED_MESSAGE, { cause: merge_error });
+}
+async function pr_merge(branch_name) {
+  const pr_number = await require_pr_number(branch_name);
+  try {
+    await put_merge(pr_number);
+  } catch (error) {
+    if (!await has_merge_landed(pr_number, error)) throw error;
+  }
+}
+var git_gh_pr = {
+  ...git_gh_pr_read,
+  ...git_gh_pr_snapshot,
+  pr_create,
+  pr_get_classification,
+  pr_ensure_classification,
+  pr_comment,
+  pr_merge,
+  pr_update_body
+};
+
+// scripts/gh/git-gh-pr-auto-merge.ts
+var GRAPHQL_PATH = "graphql";
+var OPEN_PULLS_QUERY = `${git_gh_api_path.FULL_PAGE_QUERY}&state=open`;
+var MISSING_NODE_ID_MESSAGE = "gh api answered a pull request without a node_id";
+var ENABLE_AUTO_MERGE_MUTATION = "mutation($id: ID!) { enablePullRequestAutoMerge(input: { pullRequestId: $id, mergeMethod: MERGE }) { clientMutationId } }";
+async function pr_enable_auto_merge(branch_name) {
+  const pull = await read_pull(await require_pr_number(branch_name));
+  if (pull.node_id === void 0) throw new Error(MISSING_NODE_ID_MESSAGE);
+  await git_gh_exec.exec_gh_api({
+    path: GRAPHQL_PATH,
+    body: JSON.stringify({ query: ENABLE_AUTO_MERGE_MUTATION, variables: { id: pull.node_id } })
+  });
+}
+async function pr_is_merged(branch_name) {
+  try {
+    return git_gh_pr_rest.is_merged(await read_pull(await require_pr_number(branch_name)));
+  } catch (error) {
+    error_text.trace_swallowed("git_gh_pr_auto_merge.pr_is_merged", error);
+    return false;
+  }
+}
+function head_reference_of(pull) {
+  return pull.head?.ref ?? "";
+}
+function has_head_prefix(pull, prefix) {
+  return git_gh_pr_rest.is_same_repository_head(pull) && head_reference_of(pull).startsWith(prefix);
+}
+function to_open_pull(pull) {
+  return {
+    number: pull.number,
+    head_ref: head_reference_of(pull),
+    has_auto_merge: pull.auto_merge !== null && pull.auto_merge !== void 0
+  };
+}
+async function pr_list_open_with_head_prefix(prefix) {
+  const json = await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.pulls_api_path()}${OPEN_PULLS_QUERY}`,
+    should_paginate: true
+  });
+  return git_gh_pr_rest.parse_rest_pulls(json).filter((pull) => has_head_prefix(pull, prefix)).map((pull) => to_open_pull(pull));
+}
+var git_gh_pr_auto_merge = {
+  pr_enable_auto_merge,
+  pr_is_merged,
+  pr_list_open_with_head_prefix
+};
+
+// scripts/gh/git-gh-repo.ts
+async function repo_get_name_with_owner() {
+  try {
+    const result = await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.repo_api_path(),
+      jq_filter: ".full_name"
+    });
+    return git_gh_helpers.parse_pr_state_string(result);
+  } catch {
+    return void 0;
+  }
+}
+var git_gh_repo = {
+  repo_get_name_with_owner
+};
+
+// scripts/gh/git-pr-checks-parse.ts
+var CHECK_STATUS_PASS = "pass";
+var CHECK_STATUS_PENDING = "pending";
+var CHECK_STATUS_FAIL = "fail";
+var CHECK_STATUS_MISSING = "missing";
+var PASSING_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped", "neutral"]);
+var KEY_TYPE_NAME = "__typename";
+var KEY_STATE = "state";
+var KEY_STATUS = "status";
+var KEY_CONCLUSION = "conclusion";
+var KEY_NAME = "name";
+var KEY_CONTEXT = "context";
+function read_string(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed2 = value.trim();
+  if (trimmed2.length === 0) return void 0;
+  return trimmed2;
+}
+var PENDING_STATUS_STATES = /* @__PURE__ */ new Set(["pending", "expected"]);
+function parse_status_context(item) {
+  const state = read_string(item[KEY_STATE])?.toLowerCase();
+  if (state === "success") return CHECK_STATUS_PASS;
+  if (state !== void 0 && PENDING_STATUS_STATES.has(state)) return CHECK_STATUS_PENDING;
+  return CHECK_STATUS_FAIL;
+}
+function is_passing_conclusion(item) {
+  const conclusion = read_string(item[KEY_CONCLUSION])?.toLowerCase();
+  return conclusion !== void 0 && PASSING_CONCLUSIONS.has(conclusion);
+}
+function parse_check_run(item) {
+  const status2 = read_string(item[KEY_STATUS])?.toLowerCase();
+  if (status2 !== "completed") return CHECK_STATUS_PENDING;
+  return is_passing_conclusion(item) ? CHECK_STATUS_PASS : CHECK_STATUS_FAIL;
+}
+function parse_rollup_status(item) {
+  const type_name = read_string(item[KEY_TYPE_NAME]);
+  if (type_name === "StatusContext") return parse_status_context(item);
+  return parse_check_run(item);
+}
+function read_rollup_array(parsed) {
+  const result = pr_raw_schema.safeParse(parsed);
+  if (!result.success) return [];
+  return result.data.statusCheckRollup ?? [];
+}
+function parse_rollup_item(item) {
+  const name = read_string(item[KEY_NAME]) ?? read_string(item[KEY_CONTEXT]);
+  if (name === void 0) return void 0;
+  return { name, status: parse_rollup_status(item) };
+}
+function parse_rollup_checks(raw_json) {
+  const parsed = json_value.parse_or_undefined(raw_json);
+  const rollup = read_rollup_array(parsed);
+  const checks = [];
+  for (const item of rollup) {
+    const parsed_item = parse_rollup_item(item);
+    if (parsed_item !== void 0) checks.push(parsed_item);
+  }
+  return checks;
+}
+function parse_pr_state_snapshot(raw_json) {
+  const parsed = json_value.parse_or_undefined(raw_json);
+  const result = pr_raw_schema.safeParse(parsed);
+  const data = result.success ? result.data : void 0;
+  return {
+    rollup: parse_rollup_checks(raw_json),
+    merge_state_status: read_string(data?.mergeStateStatus),
+    review_decision: read_string(data?.reviewDecision)
+  };
+}
+
+// scripts/gh/git-pr-checks-eval.ts
+var DEFAULT_REQUIRED_CHECKS = ["SonarQube"];
+var CODERABBIT_CHECK_NAME = "CodeRabbit";
+var REQUIRED_CHECKS_ENV_VAR = "JOSH_REQUIRED_CHECKS";
+function parse_required_checks() {
+  const raw = process.env[REQUIRED_CHECKS_ENV_VAR];
+  if (!raw) return DEFAULT_REQUIRED_CHECKS;
+  return raw.split(",").map((check) => check.trim()).filter((check) => check.length > 0);
+}
+var REQUIRED_CHECKS = parse_required_checks();
+var MERGE_STATE_CLEAN = "CLEAN";
+var MERGE_STATE_UNSTABLE = "UNSTABLE";
+var MERGE_STATE_DIRTY = "DIRTY";
+var REVIEW_CHANGES_REQUESTED2 = "CHANGES_REQUESTED";
+var CHECK_SUITE_SEPARATOR = " / ";
+var FAILURE_MESSAGE_PREFIX = "PR checks failed";
+var FAILURE_REASON_REVIEW = "review requested changes";
+var FAILURE_REASON_CHECKS = "failed checks";
+var FAILURE_REASON_CONFLICT = "merge conflict";
+function is_required_match(check_name, required_name) {
+  if (check_name === required_name) return true;
+  return check_name.startsWith(`${required_name}${CHECK_SUITE_SEPARATOR}`);
+}
+function find_required_check(checks, required_name) {
+  return checks.find((check) => is_required_match(check.name, required_name));
+}
+function read_required_statuses(checks) {
+  return REQUIRED_CHECKS.map(
+    (name) => find_required_check(checks, name)?.status ?? CHECK_STATUS_MISSING
+  );
+}
+function is_review_blocked(review_decision) {
+  return review_decision === REVIEW_CHANGES_REQUESTED2;
+}
+function is_merge_conflict(merge_state_status) {
+  return merge_state_status === MERGE_STATE_DIRTY;
+}
+function evaluate_failure_state(input) {
+  if (is_merge_conflict(input.merge_state_status) || is_review_blocked(input.review_decision) || input.failed_checks.length > 0) {
+    return "failure";
+  }
+  return void 0;
+}
+function is_merge_state_clean(merge_state_status) {
+  return merge_state_status === MERGE_STATE_CLEAN;
+}
+function is_every_required_passing(statuses) {
+  return statuses.every((status2) => status2 === CHECK_STATUS_PASS);
+}
+function is_coderabbit_check(check_name) {
+  return is_required_match(check_name, CODERABBIT_CHECK_NAME);
+}
+function is_unstable_only_from_coderabbit(snapshot) {
+  if (snapshot.merge_state_status !== MERGE_STATE_UNSTABLE) return false;
+  const non_passing = snapshot.rollup.filter((check) => check.status !== CHECK_STATUS_PASS);
+  if (non_passing.length === 0) return false;
+  return non_passing.every((check) => is_coderabbit_check(check.name));
+}
+function is_required_check(check_name) {
+  return REQUIRED_CHECKS.some((required) => is_required_match(check_name, required));
+}
+function is_blocking_failure(check) {
+  if (check.status !== CHECK_STATUS_FAIL) return false;
+  return !is_coderabbit_check(check.name) || is_required_check(check.name);
+}
+function collect_blocking_failures(snapshot) {
+  return snapshot.rollup.filter((check) => is_blocking_failure(check)).map((check) => check.name);
+}
+function is_mergeable_state(snapshot) {
+  if (is_merge_state_clean(snapshot.merge_state_status)) return true;
+  return is_unstable_only_from_coderabbit(snapshot);
+}
+function collect_failure_reasons(snapshot) {
+  const reasons = [];
+  if (is_merge_conflict(snapshot.merge_state_status)) reasons.push(FAILURE_REASON_CONFLICT);
+  if (is_review_blocked(snapshot.review_decision)) reasons.push(FAILURE_REASON_REVIEW);
+  const failed = collect_blocking_failures(snapshot);
+  if (failed.length > 0) reasons.push(`${FAILURE_REASON_CHECKS}: ${failed.join(", ")}`);
+  return reasons;
+}
+function describe_pr_failure(snapshot) {
+  const reasons = collect_failure_reasons(snapshot);
+  if (reasons.length === 0) return `${FAILURE_MESSAGE_PREFIX}.`;
+  return `${FAILURE_MESSAGE_PREFIX} (${reasons.join("; ")}).`;
+}
+function evaluate_pr_state(snapshot) {
+  const statuses = read_required_statuses(snapshot.rollup);
+  const failure = evaluate_failure_state({
+    review_decision: snapshot.review_decision,
+    failed_checks: collect_blocking_failures(snapshot),
+    merge_state_status: snapshot.merge_state_status
+  });
+  if (failure !== void 0) return failure;
+  if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) {
+    return "success";
+  }
+  return "pending";
+}
+function is_review_decision_decisive(snapshot) {
+  return evaluate_pr_state(snapshot) !== "pending";
+}
+
+// scripts/gh/git-pr-checks.ts
+var SECONDS_TO_MS = 1e3;
+var CHECK_WAIT_INTERVAL_MS = 1e4;
+var DEFAULT_TIMEOUT_SECONDS = 1920;
+function compute_max_attempts(timeout_seconds, interval_ms) {
+  return Math.ceil(timeout_seconds / (interval_ms / SECONDS_TO_MS)) + 1;
+}
+var DEFAULT_MAX_ATTEMPTS = compute_max_attempts(DEFAULT_TIMEOUT_SECONDS, CHECK_WAIT_INTERVAL_MS);
+function get_configured_max_attempts() {
+  const environment_seconds = Number(process.env["JOSH_CI_TIMEOUT_SECONDS"]);
+  return Number.isFinite(environment_seconds) && environment_seconds > 0 ? compute_max_attempts(environment_seconds, CHECK_WAIT_INTERVAL_MS) : DEFAULT_MAX_ATTEMPTS;
+}
+var CHECK_MAX_ATTEMPTS = get_configured_max_attempts();
+var DEFAULT_STABLE_READS = 2;
+var MAX_CONSECUTIVE_READ_FAILURES = 3;
+var PR_CHECKS_TIMEOUT_MESSAGE = "Timed out while waiting for PR checks to complete.";
+function is_pr_checks_timeout(error) {
+  return error instanceof Error && error.message === PR_CHECKS_TIMEOUT_MESSAGE;
+}
+var SHOULD_ALWAYS_READ_REVIEW_DECISION = () => true;
+var MERGE_GATE_EVALUATOR = {
+  evaluate: evaluate_pr_state,
+  describe: describe_pr_failure,
+  should_read_review_decision: is_review_decision_decisive
+};
+function advance_stable_count(previous, state) {
+  return state === "success" ? previous + 1 : 0;
+}
+function classify_poll_result(input) {
+  const state = input.evaluator.evaluate(input.snapshot);
+  if (state === "failure") throw new Error(input.evaluator.describe(input.snapshot));
+  const next_stable_count = advance_stable_count(input.stable_count, state);
+  return {
+    is_done: next_stable_count >= input.required_stable_reads,
+    next_stable_count
+  };
+}
+async function read_pr_state(input, evaluator) {
+  try {
+    const snapshot = await input.options.fetcher(
+      input.options.branch_name,
+      evaluator.should_read_review_decision ?? SHOULD_ALWAYS_READ_REVIEW_DECISION
+    );
+    return { kind: "read", snapshot };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+async function sleep_before_next_attempt(input) {
+  if (input.attempt < input.options.max_attempts - 1) {
+    await poll.sleep(input.options.interval_ms);
+  }
+}
+async function retry_after_unreadable(input, cause) {
+  const next_failure_count = input.failure_count + 1;
+  if (next_failure_count >= MAX_CONSECUTIVE_READ_FAILURES) throw cause;
+  console.warn(
+    `Could not read the PR state (${String(next_failure_count)}/${String(MAX_CONSECUTIVE_READ_FAILURES)}); asking again on the next poll: ${String(cause)}`
+  );
+  await sleep_before_next_attempt(input);
+  return { next_stable_count: 0, next_failure_count, read_failure: cause };
+}
+function to_exhaustion_error(last_read_failure) {
+  return last_read_failure ?? new Error(PR_CHECKS_TIMEOUT_MESSAGE);
+}
+async function attempt_pr_success_poll(input) {
+  const evaluator = input.options.evaluator ?? MERGE_GATE_EVALUATOR;
+  const read3 = await read_pr_state(input, evaluator);
+  if (read3.kind === "unreadable") return await retry_after_unreadable(input, read3.cause);
+  const classification = classify_poll_result({
+    snapshot: read3.snapshot,
+    stable_count: input.stable_count,
+    required_stable_reads: input.options.required_stable_reads,
+    evaluator
+  });
+  if (classification.is_done) {
+    return { snapshot: read3.snapshot, next_stable_count: 0, next_failure_count: 0 };
+  }
+  await sleep_before_next_attempt(input);
+  return { next_stable_count: classification.next_stable_count, next_failure_count: 0 };
+}
+async function wait_for_pr_success(options) {
+  let carried = { next_stable_count: 0, next_failure_count: 0 };
+  for (let attempt = 0; attempt < options.max_attempts; attempt += 1) {
+    console.info(`Checking PR status\u2026 (${String(attempt + 1)}/${String(options.max_attempts)})`);
+    carried = await attempt_pr_success_poll({
+      options,
+      stable_count: carried.next_stable_count,
+      failure_count: carried.next_failure_count,
+      attempt
+    });
+    if (carried.snapshot !== void 0) return carried.snapshot;
+  }
+  throw to_exhaustion_error(carried.read_failure);
+}
+async function default_fetch_pr_state(branch_name, should_read_review_decision = SHOULD_ALWAYS_READ_REVIEW_DECISION) {
+  const checks = await git_gh_pr_snapshot.pr_get_checks_snapshot(branch_name);
+  const snapshot = parse_pr_state_snapshot(checks.snapshot_json);
+  if (!should_read_review_decision(snapshot)) return snapshot;
+  const decision = await git_gh_pr_snapshot.pr_get_review_decision(checks.pr_number);
+  return { ...snapshot, review_decision: read_string(decision) };
+}
+
+// scripts/gh/git-pr-checks-watch.ts
+var PR_CHECKS_WATCH_TIMEOUT_MS = 12e4;
+var WATCH_TIMED_OUT_NOTE = "\u23F1\uFE0F pr checks --watch timed out.";
+var NO_CHECKS_MESSAGE = "gh api reported no checks on the branch";
+var CHECKS_FAILED_MESSAGE = "gh api reported a failing check on the branch";
+function is_awaited_check(check) {
+  return !is_coderabbit_check(check.name) || is_required_check(check.name);
+}
+function evaluate_checks_settled(snapshot) {
+  const awaited = snapshot.rollup.filter((check) => is_awaited_check(check));
+  const considered = awaited.length === 0 ? snapshot.rollup : awaited;
+  if (considered.length === 0 || considered.some((check) => check.status === CHECK_STATUS_PENDING)) {
+    return "pending";
+  }
+  return snapshot.rollup.some((check) => check.status === CHECK_STATUS_FAIL) ? "failure" : "success";
+}
+function describe_checks_failure(snapshot) {
+  const failed = snapshot.rollup.filter((check) => check.status === CHECK_STATUS_FAIL);
+  return `${CHECKS_FAILED_MESSAGE}: ${failed.map((check) => check.name).join(", ")}`;
+}
+var SHOULD_NEVER_READ_REVIEW_DECISION = () => false;
+var CHECKS_SETTLED_EVALUATOR = {
+  evaluate: evaluate_checks_settled,
+  describe: describe_checks_failure,
+  should_read_review_decision: SHOULD_NEVER_READ_REVIEW_DECISION
+};
+async function watch_until_settled(branch_name) {
+  await wait_for_pr_success({
+    branch_name,
+    fetcher: default_fetch_pr_state,
+    interval_ms: CHECK_WAIT_INTERVAL_MS,
+    max_attempts: compute_max_attempts(
+      PR_CHECKS_WATCH_TIMEOUT_MS / SECONDS_TO_MS,
+      CHECK_WAIT_INTERVAL_MS
+    ),
+    required_stable_reads: DEFAULT_STABLE_READS,
+    evaluator: CHECKS_SETTLED_EVALUATOR
+  });
+}
+async function fail_when_no_checks(branch_name) {
+  const snapshot = await default_fetch_pr_state(branch_name, SHOULD_NEVER_READ_REVIEW_DECISION);
+  if (snapshot.rollup.length === 0) throw new Error(NO_CHECKS_MESSAGE);
+}
+async function pr_checks_watch(branch_name) {
+  try {
+    await watch_until_settled(branch_name);
+    return { timed_out: false };
+  } catch (error) {
+    if (!is_pr_checks_timeout(error)) throw error;
+    await fail_when_no_checks(branch_name);
+    console.info(WATCH_TIMED_OUT_NOTE);
+    return { timed_out: true };
+  }
+}
+var git_pr_checks_watch = { pr_checks_watch };
+
+// scripts/gh/git-gh-command.ts
+var git_gh_command = {
+  ...git_gh_pr,
+  ...git_gh_pr_auto_merge,
+  pr_checks_watch: git_pr_checks_watch.pr_checks_watch,
+  ...git_gh_issue,
+  ...git_gh_repo
+};
+
 export {
+  bounded_pool,
   shell_segments,
   bash_triggers,
   issue_cite,
+  PORCELAIN_FLAG,
+  git_spawn_sync,
   git_command,
   git_common_directory,
+  error_text,
   tail_commands,
   filing_cap,
   CONTEXT_CUT_THRESHOLD,
   RECENT_REQUEST_WINDOW,
   agent_session_environment,
   agent_role_profile,
+  cli_flags,
   backlog_budget,
   run_hold,
   run_cut,
   run_tail,
   lane_background,
-  ENHANCEMENT_LABEL,
-  BREAKING_CHANGE_LABEL,
   IN_PROGRESS_LABEL,
   NEEDS_DECISION_LABEL,
   RUN_SOLO_LABEL,
   RUN_LANE_LABEL,
   NEEDS_HUMAN_REVIEW_LABEL,
   ALREADY_DONE_LABEL,
-  BUGFIX_LABEL,
-  RELEASE_CLASSIFICATION_NAMES,
   has_any_label,
   has_label_name,
   process_identity,
@@ -4620,14 +6392,13 @@ export {
   process_owner_schema,
   lane_registry,
   run_headless,
-  FULL_PAGE_QUERY,
   git_gh_api_path,
-  error_text,
   FETCH_TIMEOUT_MS,
-  parse_json_array_or_undefined,
   read_json_listing,
   parse_json_object_safe,
-  gh_failure,
-  has_stderr_field,
-  git_gh_exec
+  git_gh_exec,
+  open_issue_schema,
+  git_gh_issue_read,
+  git_gh_pr_read,
+  git_gh_command
 };