@joshuafolkken/kit 1.1094.0 → 1.1128.0

package/dist/hooks/{chunk-M2XDCUKD.js → chunk-M7QKEKWO.js}

@@ -1,32 +1,29 @@
 import {
   ALREADY_DONE_LABEL,
-  BREAKING_CHANGE_LABEL,
-  BUGFIX_LABEL,
   CONTEXT_CUT_THRESHOLD,
-  ENHANCEMENT_LABEL,
-  FULL_PAGE_QUERY,
   IN_PROGRESS_LABEL,
   NEEDS_DECISION_LABEL,
   NEEDS_HUMAN_REVIEW_LABEL,
+  PORCELAIN_FLAG,
   RECENT_REQUEST_WINDOW,
-  RELEASE_CLASSIFICATION_NAMES,
   agent_role_profile,
   agent_session_environment,
   bash_triggers,
+  cli_flags,
   error_text,
   filing_cap,
-  gh_failure,
   git_command,
   git_common_directory,
-  git_gh_api_path,
-  git_gh_exec,
+  git_gh_command,
+  git_gh_issue_read,
+  git_gh_pr_read,
+  git_spawn_sync,
   has_any_label,
-  has_stderr_field,
   issue_cite,
   lane_background,
   lane_park,
   lane_registry,
-  parse_json_array_or_undefined,
+  open_issue_schema,
   parse_json_object_safe,
   read_json_listing,
   repo_origin,
@@ -38,31 +35,31 @@ import {
   run_tail,
   shell_segments,
   tail_commands
-} from "./chunk-UD24EAIL.js";
+} from "./chunk-AIOIOMPX.js";
 import {
   find_local_bin_upwards
 } from "./chunk-3V37IID6.js";
 import {
   batch_outcome
-} from "./chunk-IL27YTPH.js";
+} from "./chunk-XYUIQOW3.js";
 import {
   investigation_refusal
-} from "./chunk-KHWHKJOM.js";
+} from "./chunk-7HVB7SZG.js";
 import {
   duplicate_read_outcome
-} from "./chunk-3C4YCCEF.js";
+} from "./chunk-5SD2YM7Z.js";
 import {
   investigation_reads
-} from "./chunk-7ZPFAVR7.js";
+} from "./chunk-NXYMNPUQ.js";
 import {
   lane_guard_policy,
   time_batch_guard
-} from "./chunk-O4LL4HTI.js";
+} from "./chunk-QVLT52OV.js";
 import {
   hook_decision,
   lane_child_marker,
   run_issue_number
-} from "./chunk-E54KGFEQ.js";
+} from "./chunk-MKVGBQPA.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_attribute,
@@ -74,7 +71,7 @@ import {
   lane_paths,
   stamp_file,
   time_shell
-} from "./chunk-NKOG3XAV.js";
+} from "./chunk-4JZDP5X5.js";
 
 // scripts/rules/direct-filing.ts
 var DIRECT_FILING_REASON = '\u26D4 direct filing: an Issue is filed with `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>]`, never with `gh api \u2026/issues` or `gh issue create`. The command runs every filing step in order \u2014 the duplicate scout, the body lint and its classification labels, the depth and `route:` labels, the `## Origin` check when filing into another repository, and `epic:bundle` after the create \u2014 so none of them is a step to remember. When the scout prints candidates it holds the filing: read each, then reissue with `--distinct <N,\u2026>` for the ones that are separate deliverables. Reference: `docs/josh-commands-automation.md` \u2192 "`josh issue:file`". **This rule fires on every occurrence, not once per run.**';
@@ -298,7 +295,8 @@ function is_life_fresh(target, threshold_ms) {
   try {
     const pinged_ms = parse_pinged_at(raw);
     return pinged_ms !== void 0 && Date.now() - pinged_ms < threshold_ms;
-  } catch {
+  } catch (error) {
+    error_text.trace_swallowed("run_progress_clock.is_life_fresh", error);
     return false;
   }
 }
@@ -442,7 +440,7 @@ function decide(call, run2, can_record) {
   if (can_record) ARM_RECORD.record(target, lands_ms);
   return false;
 }
-var EARLY_HEARTBEAT_REASON = '\u26D4 early heartbeat: this call arms a wait timer of its own, and the progress clock is not yours to keep. `pnpm josh run:progress --wait` waits the interval out for you (`JOSH_PROGRESS_INTERVAL_MINUTES`, or `josh.progress_interval_minutes` in `package.json`, default 20 minutes), prints the five labelled lines and exits \u2014 start it in the background, relay the lines it printed when it exits, and start the next one. Two timers armed at once is what produced reports 3\u20135 minutes apart on a 15-minute setting (joshuafolkken/kit#1570): a new one was armed on the turn a timer fired and again on the turn a child\'s completion woke the run, and `--mark` recorded each report without anything refusing the early ones. **An explicit ask is not a heartbeat**: if the person asked for progress now, run `pnpm josh run:progress --once`, which prints the five labelled lines whatever the clock says. If you are waiting on something rather than on a clock, wait on the thing itself \u2014 `pnpm josh followup` waits for CI. The procedure is `.claude/skills/workflow-commands/backlogrun.md` \u2192 "Progress while the run is quiet". **This rule fires on every early arm, not once per run**, so reissuing the same sleep will be refused again.';
+var EARLY_HEARTBEAT_REASON = "\u26D4 early heartbeat: this call arms a wait timer of its own, and the progress clock is not yours to keep. `pnpm josh run:progress --wait` keeps it for you (`JOSH_PROGRESS_INTERVAL_MINUTES`, or `josh.progress_interval_minutes` in `package.json`, default 20 minutes): start it once in the background and it reports the five labelled lines to the run's event stream on its own, without waking you \u2014 relay nothing, and start it again only after it exits, which it does when newly runnable work arrives. Two timers armed at once is what produced reports 3\u20135 minutes apart on a 15-minute setting (joshuafolkken/kit#1570): a new one was armed on the turn a timer fired and again on the turn a child's completion woke the run, and `--mark` recorded each report without anything refusing the early ones. **An explicit ask is not a heartbeat**: if the person asked for progress now, run `pnpm josh run:progress --once`, which prints the five labelled lines whatever the clock says. If you are waiting on something rather than on a clock, wait on the thing itself \u2014 `pnpm josh followup` waits for CI. The procedure is `.claude/skills/workflow-commands/backlogrun.md` \u2192 \"Progress while the run is quiet\". **This rule fires on every early arm, not once per run**, so reissuing the same sleep will be refused again.";
 var PROGRESS_NAMES = /* @__PURE__ */ new Set(["run:progress"]);
 var WATCH_FLAG = /(?:^|\s)--(?:wait|once)(?=\s|$)/u;
 function is_progress_watch_segment(segment) {
@@ -671,7 +669,6 @@ var git_force = {
 
 // scripts/cost-runtime/cost-cli.ts
 import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
 
 // scripts/cost-runtime/codex-usage.ts
 import { globSync, readFileSync as readFileSync2 } from "node:fs";
@@ -958,12 +955,8 @@ var PARSE_ARGS_OPTIONS = {
   path: { type: "string" }
 };
 function parse_options(argv) {
-  try {
-    const { values } = parseArgs({ args: [...argv], options: PARSE_ARGS_OPTIONS, strict: true });
-    return to_options(values);
-  } catch {
-    return void 0;
-  }
+  const values = cli_flags.values_of(argv, PARSE_ARGS_OPTIONS);
+  return values === void 0 ? void 0 : to_options(values);
 }
 function report_empty(cwd, session_id) {
   const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
@@ -2026,16 +2019,10 @@ import path5 from "node:path";
 import { existsSync as existsSync2 } from "node:fs";
 import path4 from "node:path";
 
-// scripts/lib/spawn-exit.ts
-function read_spawn_stdout(result) {
-  return result.stdout ?? "";
-}
-
 // scripts/version/kit-descriptor.ts
 var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
 
 // scripts/doctor/doctor-consumer.ts
-import { execaSync } from "execa";
 import { z as z6 } from "zod";
 var NODE_MODULES = "node_modules";
 var SETTINGS_PATH = path4.join(".claude", "settings.json");
@@ -2077,11 +2064,9 @@ function is_plugin_declared(root) {
   return parsed.success && parsed.data.enabledPlugins?.[PLUGIN_ID] === true;
 }
 function configured_hooks_path(root) {
-  const result = execaSync("git", ["-C", root, "config", "--get", "core.hooksPath"], {
-    reject: false,
+  const value = git_spawn_sync.read(["-C", root, "config", "--get", "core.hooksPath"], {
     timeout: GIT_TIMEOUT_MS
   });
-  const value = read_spawn_stdout(result).trim();
   return value === "" ? void 0 : value;
 }
 function claude_md_state(root) {
@@ -2141,6 +2126,7 @@ function report_consumer_setup(root) {
 var doctor_consumer = {
   claude_md_line,
   claude_md_state,
+  configured_hooks_path,
   hooks_path_line,
   is_kit_consumer,
   is_plugin_declared,
@@ -2543,9 +2529,6 @@ var shell_body_trigger = {
   keeps_body_safe
 };
 
-// scripts/test/test-declared-changed.ts
-import { execFileSync } from "node:child_process";
-
 // scripts/gate/project-checks.ts
 import { existsSync as existsSync4, globSync as globSync2, readFileSync as readFileSync4 } from "node:fs";
 import path7 from "node:path";
@@ -2553,7 +2536,6 @@ import path7 from "node:path";
 // scripts/init/project-profile.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "node:fs";
 import path6 from "node:path";
-import { execaSync as execaSync2 } from "execa";
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".svelte-kit"]);
 var WEB_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".css", ".js", ".jsx", ".mjs", ".cjs"]);
 var TYPESCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx"]);
@@ -2644,11 +2626,8 @@ function scan_files(root) {
   return { has_web, has_typescript };
 }
 function has_github_remote(root) {
-  const result = execaSync2("git", ["config", "--get", "remote.origin.url"], {
-    cwd: root,
-    reject: false
-  });
-  return result.exitCode === 0 && repo_origin.parse_origin_url(result.stdout) !== void 0;
+  const url = git_spawn_sync.origin_url(root);
+  return url !== void 0 && repo_origin.parse_origin_url(url) !== void 0;
 }
 function inspect_project(root, requested) {
   const profile = resolve_profile(root, requested);
@@ -2874,15 +2853,9 @@ function path_of(line) {
   return arrow === -1 ? body : body.slice(arrow + RENAME_ARROW.length);
 }
 function read_changed_paths_sync() {
-  try {
-    const output = execFileSync("git", ["status", "--porcelain"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return output.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH).map((line) => path_of(line));
-  } catch {
-    return [];
-  }
+  const output = git_spawn_sync.run(["status", PORCELAIN_FLAG], { timeout: 0 });
+  if (output.exit_code !== 0) return [];
+  return output.stdout.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH).map((line) => path_of(line));
 }
 var injected = {};
 function source_paths() {
@@ -3344,1680 +3317,11 @@ var delivered_rules = {
 };
 
 // scripts/run/run-watcher-hook.ts
-import { z as z19 } from "zod";
+import { z as z12 } from "zod";
 
 // scripts/run/run-progress-read.ts
 import { loadavg } from "node:os";
 
-// scripts/gh/git-gh-helpers.ts
-function parse_pr_state_string(result) {
-  const trimmed = result.trim();
-  return trimmed.length > 0 ? trimmed : 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 z8 } from "zod";
-var package_name_schema = z8.object({ name: z8.string().min(1) });
-var rollup_item_schema = z8.looseObject({
-  // eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
-  __typename: z8.string().optional(),
-  state: z8.string().optional(),
-  status: z8.string().optional(),
-  conclusion: z8.string().optional(),
-  name: z8.string().optional(),
-  context: z8.string().optional()
-});
-var pr_raw_schema = z8.object({
-  statusCheckRollup: z8.array(rollup_item_schema).optional(),
-  mergeStateStatus: z8.string().optional(),
-  reviewDecision: z8.string().optional()
-});
-var pull_comment_schema = z8.object({
-  body: z8.string().optional(),
-  html_url: z8.string().optional(),
-  user: z8.object({ login: z8.string().optional() }).optional()
-});
-var ai_review_pull_comment_schema = z8.object({
-  body: z8.string().optional(),
-  url: z8.string().optional(),
-  author: z8.object({ login: z8.string().optional() }).optional()
-});
-var pr_info_schema = z8.object({
-  mergeable: z8.union([z8.boolean(), z8.string()]).nullable().optional(),
-  mergeStateStatus: z8.string().nullable().optional(),
-  state: z8.string().optional()
-});
-var epic_issue_schema = z8.object({
-  number: z8.number(),
-  body: z8.string().optional()
-});
-var blocking_issue_schema = z8.object({
-  number: z8.number(),
-  state: z8.string().optional(),
-  repository_url: z8.string().optional()
-});
-var blocked_by_schema = z8.object({
-  nodes: z8.array(blocking_issue_schema).default([]),
-  totalCount: z8.number().optional()
-}).optional();
-var epic_child_schema = z8.object({
-  state: z8.string().optional(),
-  blockedBy: blocked_by_schema
-});
-var rest_comment_schema = z8.looseObject({
-  body: z8.string().nullish(),
-  html_url: z8.string().optional(),
-  user: z8.looseObject({ login: z8.string().optional() }).nullish()
-});
-var issue_label_schema = z8.object({ name: z8.string() });
-var epic_subject_schema = z8.object({
-  number: z8.number(),
-  state: z8.string().optional(),
-  labels: z8.array(issue_label_schema).optional(),
-  body: z8.string().optional()
-});
-var open_issue_schema = z8.object({
-  number: z8.number(),
-  title: z8.string(),
-  labels: z8.array(issue_label_schema).optional(),
-  createdAt: z8.string(),
-  blockedBy: blocked_by_schema
-});
-
-// scripts/gh/git-gh-issue-rest.ts
-import { z as z9 } 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 = z9.looseObject({
-  number: z9.number(),
-  issue_dependencies_summary: z9.looseObject({ total_blocked_by: z9.number().optional() }).nullish(),
-  // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z9.looseObject({ merged_at: z9.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_SEPARATOR = ",";
-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_SEPARATOR).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(status) {
-  if (status >= SERVER_ERROR_FLOOR) return true;
-  return status === RATE_LIMITED_STATUS;
-}
-function classify_status(status) {
-  if (status === void 0) return "unreachable";
-  return is_retryable_status(status) ? "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(status) {
-  return gh_reachability.classify_status(status) === "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 read2 = await issue_view_field_classified(issue_number, field, repo);
-  return read2.kind === "read" ? read2.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 read2 = await issue_view_json_classified(issue_number, fields, repo);
-  return read2.kind === "read" ? read2.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 path10 = `${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: path10, should_paginate: true });
-  } catch {
-    return void 0;
-  }
-}
-async function has_no_relations_endpoint(issue_number, repo) {
-  const status = await git_gh_exec.exec_gh_api_status(
-    git_gh_api_path.blocked_by_api_path(issue_number, repo)
-  );
-  return status === 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 label = 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)}${label}${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 path10 = listing_path(request, page);
-  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path10 }));
-  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)
-  };
-}
-async function read_relations2(rows, repo) {
-  const relations = [];
-  for (const row of rows) {
-    relations.push(await read_blocked_by(String(row.number), row, repo));
-  }
-  return relations;
-}
-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_METHOD2 = "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 {
-    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, label) {
-  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: [label] })
-    })
-  );
-}
-async function issue_remove_label(issue_number, label) {
-  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(label)}`,
-    method: DELETE_METHOD2
-  });
-}
-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_METHOD2
-    });
-  });
-}
-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(label, limit) {
-  return await issue_list2({ json_fields: NUMBER_AND_BODY_FIELDS, limit, label });
-}
-async function issue_list_by_label_summary(label, limit, options) {
-  return await issue_list2({
-    json_fields: options?.json_fields ?? PICKUP_FIELDS,
-    limit,
-    label
-  });
-}
-async function issue_list_by_label_in_repo(label, limit, repo) {
-  return await issue_list2({ json_fields: SUMMARY_FIELDS, limit, label, 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 readFileSync5 } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { z as z10 } 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 = z10.object({ name: z10.string() });
-var USER = z10.object({ login: z10.string() });
-var PULL_REQUEST = z10.object({ number: z10.number(), user: USER });
-var EVENT = z10.object({
-  pull_request: PULL_REQUEST,
-  repository: z10.object({ full_name: z10.string() })
-});
-function classification_error(labels, author) {
-  const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()));
-  if (legacy.length > 0) return `Remove legacy release labels: ${legacy.join(", ")}`;
-  const selected = labels.filter((label) => CLASSIFICATION_SET.has(label.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(label) {
-  return `${DECLARATION_PREFIX}${label}`;
-}
-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 = z10.object({ labels: z10.array(LABEL), body: z10.string().nullable() }).parse(JSON.parse(issue_json));
-  const names = issue.labels.map((label) => label.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 [label] = selected;
-  if (label === 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 label;
-}
-function fetch_current_labels(repository, pull_number) {
-  const path10 = `repos/${repository}/issues/${String(pull_number)}/labels`;
-  try {
-    const names = git_gh_exec.exec_gh_api_sync({ path: path10, 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(readFileSync5(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 sleep(duration_ms) {
-  await new Promise((resolve2) => {
-    setTimeout(resolve2, duration_ms);
-  });
-}
-async function wait_between(wait, interval_ms, attempt, attempts) {
-  if (attempt < attempts - 1) await wait(interval_ms);
-}
-async function poll_until(is_done, options) {
-  const wait = options.sleeper ?? sleep;
-  for (let attempt = 0; attempt < options.attempts; attempt += 1) {
-    if (await is_done()) return true;
-    await wait_between(wait, options.interval_ms, attempt, options.attempts);
-  }
-  return false;
-}
-var poll = { poll_until, sleep };
-
-// scripts/gh/git-gh-pr.ts
-import { z as z14 } from "zod";
-
-// scripts/gh/git-gh-pr-rest.ts
-import { z as z11 } from "zod";
-var rest_repo_schema = z11.looseObject({ full_name: z11.string().optional() }).nullish();
-var rest_pull_side_schema = z11.looseObject({ repo: rest_repo_schema });
-var rest_pull_schema = z11.looseObject({
-  number: z11.number(),
-  html_url: z11.string().optional(),
-  body: z11.string().nullish(),
-  state: z11.string().optional(),
-  merged: z11.boolean().nullish(),
-  merged_at: z11.string().nullish(),
-  mergeable: z11.boolean().nullish(),
-  mergeable_state: z11.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: z11.looseObject({ ref: z11.string().optional(), sha: z11.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: z11.string().optional(),
-  auto_merge: z11.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_STATE2 = "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_STATE2) ?? 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 read2 = await read_pr_number(branch_name);
-  return read2.kind === "read" ? read2.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 read2 = await read_pr_number(branch_name);
-  if (read2.kind === "read") return read2.pr_number;
-  if (read2.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
-  throw to_unreadable_error(branch_name, read2.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 read2 = await read_pr_number(branch_name);
-  if (read2.kind === "unreadable") throw to_unreadable_error(branch_name, read2.cause);
-  return read2.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 path10 = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
-  try {
-    return to_json(await git_gh_exec.exec_gh_api({ path: path10, 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 z12 } 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 = z12.looseObject({
-  state: z12.string().optional(),
-  user: z12.looseObject({ login: z12.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 z13 } from "zod";
-var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
-var TYPE_NAME_KEY = "__typename";
-var rollup_element_schema = z13.looseObject({});
-var check_runs_page_schema = z13.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: z13.array(rollup_element_schema)
-});
-var id_holder_schema = z13.object({ id: z13.number() });
-var status_page_schema = z13.looseObject({
-  statuses: z13.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(run2) {
-  const { name, app } = run2;
-  if (typeof name !== "string") return void 0;
-  return JSON.stringify([name, read_id(app)]);
-}
-function read_rank(run2) {
-  const id = read_id(run2);
-  if (id === void 0) return void 0;
-  return { suite: read_id(run2["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(run2, newest) {
-  const key = check_run_group_key(run2);
-  const rank = read_rank(run2);
-  if (key === void 0 || rank === void 0) return;
-  if (should_replace(newest.get(key), rank)) newest.set(key, run2);
-}
-function is_newest_run(run2, newest) {
-  const key = check_run_group_key(run2);
-  if (key === void 0 || read_rank(run2) === void 0) return true;
-  return newest.get(key) === run2;
-}
-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 run2 of runs) remember_newest_run(run2, newest);
-  return runs.filter((run2) => is_newest_run(run2, 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((status) => ({ ...status, [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(path10) {
-  return await git_gh_exec.exec_gh_api({
-    path: `${path10}${FULL_PAGE_QUERY}`,
-    should_paginate: true,
-    should_slurp: true
-  });
-}
-async function read_array_pages(path10) {
-  return await git_gh_exec.exec_gh_api({
-    path: `${path10}${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 path10 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
-  return git_gh_pr_review.to_review_decision(await read_array_pages(path10));
-}
-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 = z14.array(z14.object({ name: z14.string() }));
-async function add_pr_classification(number, label) {
-  await git_gh_exec.exec_gh_api({
-    path: `${git_gh_api_path.issue_api_path(number)}${LABELS_SEGMENT2}`,
-    body: JSON.stringify({ labels: [label] })
-  });
-}
-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((label) => label.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, label) {
-  if (await pr_get_classification(branch_name) !== void 0) return;
-  const number = await require_pr_number(branch_name);
-  await add_pr_classification(String(number), label);
-}
-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, label) {
-  const classification_error2 = pr_classification.classification_error([label], "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, label);
-  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 {
-    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 trimmed = value.trim();
-  if (trimmed.length === 0) return void 0;
-  return trimmed;
-}
-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 status = read_string(item[KEY_STATUS])?.toLowerCase();
-  if (status !== "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((check4) => check4.trim()).filter((check4) => check4.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((check4) => is_required_match(check4.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((status) => status === 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((check4) => check4.status !== CHECK_STATUS_PASS);
-  if (non_passing.length === 0) return false;
-  return non_passing.every((check4) => is_coderabbit_check(check4.name));
-}
-function is_required_check(check_name) {
-  return REQUIRED_CHECKS.some((required) => is_required_match(check_name, required));
-}
-function is_blocking_failure(check4) {
-  if (check4.status !== CHECK_STATUS_FAIL) return false;
-  return !is_coderabbit_check(check4.name) || is_required_check(check4.name);
-}
-function collect_blocking_failures(snapshot) {
-  return snapshot.rollup.filter((check4) => is_blocking_failure(check4)).map((check4) => check4.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 read2 = await read_pr_state(input, evaluator);
-  if (read2.kind === "unreadable") return await retry_after_unreadable(input, read2.cause);
-  const classification = classify_poll_result({
-    snapshot: read2.snapshot,
-    stable_count: input.stable_count,
-    required_stable_reads: input.options.required_stable_reads,
-    evaluator
-  });
-  if (classification.is_done) {
-    return { snapshot: read2.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(check4) {
-  return !is_coderabbit_check(check4.name) || is_required_check(check4.name);
-}
-function evaluate_checks_settled(snapshot) {
-  const awaited = snapshot.rollup.filter((check4) => is_awaited_check(check4));
-  const considered = awaited.length === 0 ? snapshot.rollup : awaited;
-  if (considered.length === 0 || considered.some((check4) => check4.status === CHECK_STATUS_PENDING)) {
-    return "pending";
-  }
-  return snapshot.rollup.some((check4) => check4.status === CHECK_STATUS_FAIL) ? "failure" : "success";
-}
-function describe_checks_failure(snapshot) {
-  const failed = snapshot.rollup.filter((check4) => check4.status === CHECK_STATUS_FAIL);
-  return `${CHECKS_FAILED_MESSAGE}: ${failed.map((check4) => check4.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
-};
-
 // scripts/epic/epic-busy.ts
 var LISTING_LIMIT = 100;
 var PARKED_LABELS = /* @__PURE__ */ new Set([NEEDS_DECISION_LABEL, ALREADY_DONE_LABEL]);
@@ -5080,30 +3384,30 @@ var epic_busy = {
 };
 
 // scripts/run/run-liveness.ts
-import { readFileSync as readFileSync6, realpathSync, statSync } from "node:fs";
+import { readFileSync as readFileSync5, realpathSync, statSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import path8 from "node:path";
-import { setTimeout as sleep2 } from "node:timers/promises";
+import { setTimeout as sleep } from "node:timers/promises";
 
 // scripts/agent/agent-event.ts
-import { z as z16 } from "zod";
+import { z as z9 } from "zod";
 
 // scripts/agent/claude-result-event.ts
-import { z as z15 } from "zod";
-var RESULT_EVENT_SCHEMA = z15.looseObject({
-  type: z15.literal("result"),
-  is_error: z15.unknown().optional(),
-  subtype: z15.unknown().optional(),
-  num_turns: z15.unknown().optional(),
-  permission_denials: z15.unknown().optional(),
-  result: z15.unknown().optional(),
-  session_id: z15.unknown().optional(),
-  usage: z15.unknown().optional()
+import { z as z8 } from "zod";
+var RESULT_EVENT_SCHEMA = z8.looseObject({
+  type: z8.literal("result"),
+  is_error: z8.unknown().optional(),
+  subtype: z8.unknown().optional(),
+  num_turns: z8.unknown().optional(),
+  permission_denials: z8.unknown().optional(),
+  result: z8.unknown().optional(),
+  session_id: z8.unknown().optional(),
+  usage: z8.unknown().optional()
 });
-var USAGE_SCHEMA = z15.looseObject({
-  input_tokens: z15.unknown().optional(),
-  cache_read_input_tokens: z15.unknown().optional(),
-  output_tokens: z15.unknown().optional()
+var USAGE_SCHEMA = z8.looseObject({
+  input_tokens: z8.unknown().optional(),
+  cache_read_input_tokens: z8.unknown().optional(),
+  output_tokens: z8.unknown().optional()
 });
 function usable_reason(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
@@ -5142,31 +3446,31 @@ function decode(value) {
 var claude_result_event = { decode };
 
 // scripts/agent/agent-event.ts
-var TEXT_BLOCK_SCHEMA = z16.looseObject({ type: z16.literal("text"), text: z16.string() });
-var CLAUDE_MESSAGE_SCHEMA = z16.looseObject({ content: z16.array(z16.unknown()).optional() });
-var CLAUDE_INIT_SCHEMA = z16.looseObject({ type: z16.literal("system"), subtype: z16.literal("init") });
-var CLAUDE_ASSISTANT_SCHEMA = z16.looseObject({
-  type: z16.literal("assistant"),
+var TEXT_BLOCK_SCHEMA = z9.looseObject({ type: z9.literal("text"), text: z9.string() });
+var CLAUDE_MESSAGE_SCHEMA = z9.looseObject({ content: z9.array(z9.unknown()).optional() });
+var CLAUDE_INIT_SCHEMA = z9.looseObject({ type: z9.literal("system"), subtype: z9.literal("init") });
+var CLAUDE_ASSISTANT_SCHEMA = z9.looseObject({
+  type: z9.literal("assistant"),
   message: CLAUDE_MESSAGE_SCHEMA
 });
-var USAGE_SCHEMA2 = z16.looseObject({
-  input_tokens: z16.number().optional(),
-  cached_input_tokens: z16.number().optional(),
-  output_tokens: z16.number().optional()
+var USAGE_SCHEMA2 = z9.looseObject({
+  input_tokens: z9.number().optional(),
+  cached_input_tokens: z9.number().optional(),
+  output_tokens: z9.number().optional()
 });
-var CODEX_START_SCHEMA = z16.looseObject({ type: z16.enum(["thread.started", "turn.started"]) });
-var CODEX_PROGRESS_SCHEMA = z16.looseObject({
-  type: z16.enum(["item.started", "item.updated", "item.completed"]),
-  item: z16.looseObject({ type: z16.string(), text: z16.string().optional() }).optional()
+var CODEX_START_SCHEMA = z9.looseObject({ type: z9.enum(["thread.started", "turn.started"]) });
+var CODEX_PROGRESS_SCHEMA = z9.looseObject({
+  type: z9.enum(["item.started", "item.updated", "item.completed"]),
+  item: z9.looseObject({ type: z9.string(), text: z9.string().optional() }).optional()
 });
-var CODEX_COMPLETE_SCHEMA = z16.looseObject({
-  type: z16.literal("turn.completed"),
+var CODEX_COMPLETE_SCHEMA = z9.looseObject({
+  type: z9.literal("turn.completed"),
   usage: USAGE_SCHEMA2.optional()
 });
-var CODEX_FAILURE_SCHEMA = z16.looseObject({
-  type: z16.enum(["turn.failed", "error"]),
-  error: z16.looseObject({ message: z16.string().optional() }).optional(),
-  message: z16.string().optional()
+var CODEX_FAILURE_SCHEMA = z9.looseObject({
+  type: z9.enum(["turn.failed", "error"]),
+  error: z9.looseObject({ message: z9.string().optional() }).optional(),
+  message: z9.string().optional()
 });
 var EMPTY_STATE = {
   provider: void 0,
@@ -5257,7 +3561,7 @@ function describe(state) {
 var agent_event = { describe, read };
 
 // scripts/issue/issue-state.ts
-import { z as z17 } from "zod";
+import { z as z10 } from "zod";
 var NO_LABELS = "(none)";
 var LABEL_SEPARATOR = ", ";
 var STATE_LABEL = "state: ";
@@ -5267,9 +3571,9 @@ var YES = "yes";
 var NO = "no";
 var ISSUE_LABEL = "issue: ";
 var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z17.looseObject({ name: z17.string() });
-var issue_state_schema = z17.looseObject({
-  state: z17.string(),
+var label_schema = z10.looseObject({ name: z10.string() });
+var issue_state_schema = z10.looseObject({
+  state: z10.string(),
   labels: label_schema.array().optional()
 });
 function parse_issue_state(json) {
@@ -5317,7 +3621,7 @@ var DEFAULT_SILENT_MINUTES = 30;
 var DEFAULT_GAP_SECONDS = 5;
 var MS_PER_MINUTE3 = 6e4;
 var MS_PER_SECOND2 = 1e3;
-var OPEN_STATE3 = "OPEN";
+var OPEN_STATE2 = "OPEN";
 var STATE_FIELDS = "state,labels";
 var REASONS = {
   [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
@@ -5405,7 +3709,7 @@ function read_agent_state(output_path) {
   const safe_path = to_safe_path(output_path);
   if (safe_path === void 0) return void 0;
   try {
-    const state = agent_event.read(readFileSync6(safe_path, "utf8"));
+    const state = agent_event.read(readFileSync5(safe_path, "utf8"));
     return state.provider === void 0 ? void 0 : state;
   } catch {
     return void 0;
@@ -5419,7 +3723,7 @@ async function read_output_frozen(request) {
   const first = sample_output(request.output_path);
   if (first === void 0) return void 0;
   if (request.now_ms - first.mtime_ms < request.silent_window_ms) return false;
-  await sleep2(request.gap_ms);
+  await sleep(request.gap_ms);
   const second = sample_output(request.output_path);
   if (second === void 0) return void 0;
   return second.mtime_ms === first.mtime_ms && second.size === first.size;
@@ -5436,7 +3740,7 @@ async function read_child_settled(issue, repo) {
   if (json === void 0) return void 0;
   const state = issue_state.parse_issue_state(json);
   if (state === void 0) return void 0;
-  return state.state !== OPEN_STATE3 || carries_settled_label(state.labels);
+  return state.state !== OPEN_STATE2 || carries_settled_label(state.labels);
 }
 async function read_traces(request) {
   const [is_initial_child_settled, is_output_frozen, is_tree_dirty] = await Promise.all([
@@ -5476,14 +3780,14 @@ var run_liveness = {
 
 // scripts/lane/lane-report.ts
 var NO_LANES2 = "No lanes are open.";
-var OPEN_STATE4 = "open";
+var OPEN_STATE3 = "open";
 var STRANDED_STATE = "stranded";
 var UNREADABLE_STATE = "unreadable";
 var UNKNOWN_VALUE = "-";
 var COLUMN_SEPARATOR = "  ";
 function lane_state(lane) {
   if (lane.is_stranded) return STRANDED_STATE;
-  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE4;
+  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE3;
 }
 function value_or_unknown(value) {
   return value === void 0 ? UNKNOWN_VALUE : String(value);
@@ -5527,7 +3831,7 @@ function describe_opened(lane) {
 }
 var lane_report = {
   NO_LANES: NO_LANES2,
-  OPEN_STATE: OPEN_STATE4,
+  OPEN_STATE: OPEN_STATE3,
   STRANDED_STATE,
   UNREADABLE_STATE,
   describe_lane,
@@ -5537,7 +3841,7 @@ var lane_report = {
 };
 
 // scripts/run/run-preflight.ts
-import { z as z18 } from "zod";
+import { z as z11 } from "zod";
 var CLEAN_VERDICT = "clean";
 var RECLAIM_VERDICT = "reclaim";
 var RESUME_VERDICT = "resume";
@@ -5547,7 +3851,7 @@ var OPEN_PR = "open";
 var MERGED_PR = "merged";
 var CLOSED_PR = "closed";
 var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema2 = z18.object({ state: z18.string().optional() });
+var pr_info_schema = z11.object({ state: z11.string().optional() });
 var GH_PR_STATES = /* @__PURE__ */ new Map([
   ["CLOSED", CLOSED_PR],
   ["MERGED", MERGED_PR],
@@ -5626,12 +3930,12 @@ function decide5(tree, child, issue) {
 }
 function read_pr_field(raw) {
   try {
-    return pr_info_schema2.parse(JSON.parse(raw)).state;
+    return pr_info_schema.parse(JSON.parse(raw)).state;
   } catch {
     return void 0;
   }
 }
-function to_pr_state2(raw) {
+function to_pr_state(raw) {
   const state = read_pr_field(raw);
   return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
 }
@@ -5643,17 +3947,17 @@ async function read_tree_state() {
   ]);
   return { branch: current, default_branch, is_dirty };
 }
-async function read_pr_state2(branch_name) {
+async function read_pr_state(branch_name) {
   if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
   const raw = await git_gh_pr_read.pr_view(branch_name);
   if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
-  return to_pr_state2(raw);
+  return to_pr_state(raw);
 }
 function is_pr_open(state) {
   return state === OPEN_PR;
 }
 async function read_pr_of_branch(branch_name) {
-  return { branch_name, pr_state: await read_pr_state2(branch_name) };
+  return { branch_name, pr_state: await read_pr_state(branch_name) };
 }
 function pick_child_state(reads) {
   const decided = reads.find((read2) => is_pr_decided(read2.pr_state));
@@ -5728,8 +4032,8 @@ var run_preflight = {
   check: check2,
   decide: decide5,
   read_child_state,
-  read_pr_state: read_pr_state2,
-  to_pr_state: to_pr_state2
+  read_pr_state,
+  to_pr_state
 };
 
 // scripts/run/run-progress-read.ts
@@ -5829,7 +4133,7 @@ var TICK_MULTIPLIER = 3;
 var MS_PER_SECOND3 = 1e3;
 var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
 var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND3;
-var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding`;
+var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding. It reports to the run event stream on its own and exits only when newly runnable work arrives, so start it once and relay nothing`;
 var OK_RESULT = { kind: "ok" };
 async function owes_watcher() {
   if (!await run_headless.is_backlog_parent()) return false;
@@ -5849,7 +4153,7 @@ var run_watcher_guard = {
 // scripts/run/run-watcher-hook.ts
 var SWITCH_ENV_KEY2 = "JOSH_WATCHER_GUARD";
 var STAMP_PREFIX2 = "josh-watcher-guard-";
-var payload_schema = z19.object({ transcript_path: z19.string().min(1) });
+var payload_schema = z12.object({ transcript_path: z12.string().min(1) });
 function transcript_of(raw_payload) {
   try {
     const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
@@ -5910,7 +4214,8 @@ async function refusal_for(transcript, now_ms, state) {
 function is_unit_call(raw_payload) {
   try {
     return (hook_decision.parse_hook_payload(raw_payload)?.agent_id ?? "") !== "";
-  } catch {
+  } catch (error) {
+    error_text.trace_swallowed("run_parent_cut_hook.is_unit_call", error);
     return false;
   }
 }