@joshuafolkken/kit 1.1240.0 → 1.1370.0

package/dist/hooks/chunk-MXVQMLDP.js

@@ -0,0 +1,3705 @@
+import {
+  agent_role_profile,
+  detached_launch,
+  git_common_directory,
+  issue_cite,
+  lane_child_invocation,
+  repo_discovery,
+  repo_origin,
+  repository_lock,
+  run_ship_stage
+} from "./chunk-SYSRHRWU.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  CHECK_STATUS_FAIL,
+  CHECK_STATUS_PENDING,
+  PrConflictError,
+  blocking_issue_schema,
+  cost_blocks,
+  describe_pr_failure,
+  evaluate_pr_state,
+  is_coderabbit_check,
+  is_merge_conflict,
+  is_required_check,
+  is_review_decision_decisive,
+  parse_pr_state_snapshot,
+  read_string,
+  rest_comment_schema,
+  time_density_hook,
+  time_shell,
+  time_transcript_line
+} from "./chunk-TLJYAGZK.js";
+import {
+  lane_child_marker
+} from "./chunk-Z5TMJIPW.js";
+import {
+  agent_session_environment,
+  backlog_budget,
+  cost_usage,
+  git_command,
+  has_timed_out,
+  json_value,
+  process_identity,
+  run_carry,
+  stamp_record
+} from "./chunk-NZN2UFI6.js";
+import {
+  COMMAND_TIMEOUT_MS,
+  stamp_file
+} from "./chunk-NEC4AT4Z.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) {
+  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
+}
+function is_josh_command(segment, names) {
+  const named = time_shell.josh_command_of(segment);
+  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
+  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
+}
+var shell_segments = {
+  is_josh_command,
+  segments_of
+};
+
+// scripts/rules/bash-triggers.ts
+function on_bash_command(is_match) {
+  return function is_trigger(call) {
+    if (call.name !== cost_blocks.BASH_TOOL) return false;
+    return is_match(time_shell.bash_command(call.input));
+  };
+}
+var ISSUE_CREATE_COMMAND = /\bgh\s+(?:\S+\s+)*?issue\s+create\b/u;
+var ISSUES_ENDPOINT = /repos\/[^\s'"]*\/issues(?=$|["'\s])/u;
+var TITLE_FIELD = /(?:-f|-F|--field|--raw-field)\s*'?title=/u;
+function is_direct_filing(command) {
+  if (ISSUE_CREATE_COMMAND.test(command)) return true;
+  return ISSUES_ENDPOINT.test(command) && TITLE_FIELD.test(command);
+}
+var FILING_NAMES = /* @__PURE__ */ new Set(["issue:file"]);
+function is_issue_filing(command) {
+  return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, FILING_NAMES));
+}
+var bash_triggers = { is_direct_filing, is_issue_filing, on_bash_command };
+
+// scripts/rules/tail-commands.ts
+function is_bash_use(block) {
+  return block.type === cost_blocks.TOOL_USE_TYPE && block.name === cost_blocks.BASH_TOOL;
+}
+function bash_commands_of(line) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return [];
+  return parsed.blocks.filter((block) => is_bash_use(block)).map((block) => time_shell.bash_command(block.input));
+}
+function prior_bash_commands(tail) {
+  return tail.split("\n").flatMap((line) => bash_commands_of(line));
+}
+var tail_commands = { is_bash_use, prior_bash_commands };
+
+// scripts/rules/filing-cap.ts
+var FILING_CAP = 10;
+var CAP_REACHED = FILING_CAP;
+function is_filing_use(block) {
+  if (!tail_commands.is_bash_use(block)) return false;
+  return bash_triggers.is_issue_filing(time_shell.bash_command(block.input));
+}
+function collect_block(block, found) {
+  if (block.result_id !== "" && block.is_error === true) found.failures.add(block.result_id);
+  if (is_filing_use(block)) found.filing_ids.push(block.id);
+}
+function collect_line(line, found) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return;
+  for (const block of parsed.blocks) collect_block(block, found);
+}
+function scan_tail(tail) {
+  const found = { filing_ids: [], failures: /* @__PURE__ */ new Set() };
+  for (const line of tail.split("\n")) collect_line(line, found);
+  return found;
+}
+function prior_filing_count(tail) {
+  const { filing_ids, failures } = scan_tail(tail);
+  return filing_ids.filter((id) => !failures.has(id)).length;
+}
+function is_prompt_line(line) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed?.type !== "user") return false;
+  return parsed.blocks.every((block) => block.result_id === "");
+}
+function current_turn(tail) {
+  const lines = tail.split("\n");
+  const start = lines.findLastIndex((line) => is_prompt_line(line));
+  return lines.slice(Math.max(start, 0)).join("\n");
+}
+function turn_filing_count(tail) {
+  return prior_filing_count(current_turn(tail));
+}
+function decide(_call, run) {
+  return prior_filing_count(time_density_hook.read_tail(run.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 \`prerequisite.md\`, \`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 = {
+  id: "filing-cap",
+  is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+  reason: FILING_CAP_REASON,
+  decide
+};
+var filing_cap = {
+  FILING_CAP,
+  FILING_CAP_REASON,
+  ROW,
+  is_prompt_line,
+  prior_filing_count,
+  turn_filing_count
+};
+
+// scripts/rules/issue-citation.ts
+var ISSUE_NUMBER = /#\d+/gu;
+var REFERENCE_BOUNDARY = /[\s#()[\]<>|]/u;
+var OWNER_REPO = /^[^\s/#]+\/[^\s/#]+$/u;
+var MARKDOWN_LINK = /\[[^[\]]*\]\([^()]*\)/gu;
+var NUMBER_CONTINUATION = /^(?:\w|-[a-z])/iu;
+var CONTINUATION_WIDTH = 2;
+var GLUED_LEAD = /[&./]/u;
+var FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u;
+var QUOTE_LINE = /^\s*>/u;
+var PR_PREFIX = /\b(?:pr|pull request)\s*$/iu;
+var BACKTICK_PAIR = 2;
+function link_covers(link, index) {
+  const start = link.index ?? 0;
+  return index >= start && index < start + link[0].length;
+}
+function is_linked_at(line, index) {
+  for (const link of line.matchAll(MARKDOWN_LINK)) {
+    if (link_covers(link, index)) return true;
+  }
+  return false;
+}
+function lead_token(message, hash_index) {
+  let start = hash_index;
+  while (start > 0 && !REFERENCE_BOUNDARY.test(message.charAt(start - 1))) start -= 1;
+  return message.slice(start, hash_index);
+}
+function repo_prefix(message, hash_index) {
+  const token = lead_token(message, hash_index);
+  return OWNER_REPO.test(token) ? token : "";
+}
+function is_inline_code_at(line, index) {
+  const backticks = line.slice(0, index).split("`").length - 1;
+  return backticks % BACKTICK_PAIR === 1;
+}
+function is_bare_at(line, index) {
+  if (is_linked_at(line, index) || is_inline_code_at(line, index)) return false;
+  return !PR_PREFIX.test(line.slice(0, index));
+}
+function is_glued(line, reference) {
+  const end = reference.index + reference.text.length;
+  if (NUMBER_CONTINUATION.test(line.slice(end, end + CONTINUATION_WIDTH))) return true;
+  return reference.prefix === "" && GLUED_LEAD.test(lead_token(line, reference.index));
+}
+function line_references(line) {
+  const references = [];
+  for (const match of line.matchAll(ISSUE_NUMBER)) {
+    const reference = { index: match.index, prefix: repo_prefix(line, match.index), text: match[0] };
+    if (!is_glued(line, reference) && is_bare_at(line, match.index)) references.push(reference);
+  }
+  return references;
+}
+function collect_line_references(line, found) {
+  for (const reference of line_references(line)) found.push(`${reference.prefix}${reference.text}`);
+}
+function lines_outside_fences(message) {
+  const lines = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    else if (!is_in_fence) lines.push(line);
+  }
+  return lines;
+}
+function prose_lines(message) {
+  return lines_outside_fences(message).filter((line) => !QUOTE_LINE.test(line));
+}
+function bare_references(message) {
+  const found = [];
+  for (const line of prose_lines(message)) collect_line_references(line, found);
+  return [...new Set(found)];
+}
+function prompt_references(prompt) {
+  const found = /* @__PURE__ */ new Set();
+  for (const match of prompt.matchAll(ISSUE_NUMBER)) {
+    found.add(repo_prefix(prompt, match.index) + match[0]);
+  }
+  return found;
+}
+function unquoted_references(message, prompt) {
+  const quoted = prompt_references(prompt);
+  return bare_references(message).filter((reference) => !quoted.has(reference));
+}
+function has_bare_reference(message) {
+  return bare_references(message).length > 0;
+}
+function cite_argument(reference) {
+  return reference.startsWith("#") ? reference.slice(1) : reference;
+}
+function cite_arguments(references) {
+  return references.map((reference) => cite_argument(reference));
+}
+function reference_link(reference, default_slug) {
+  const slug = reference.prefix === "" ? default_slug : reference.prefix;
+  const number = reference.text.slice(1);
+  return `[${reference.prefix}${reference.text}](${issue_cite.issue_url(slug, number)})`;
+}
+function linkify_line(line, slug) {
+  let result = "";
+  let cursor = 0;
+  for (const reference of line_references(line)) {
+    const start = reference.index - reference.prefix.length;
+    result += line.slice(cursor, start) + reference_link(reference, slug);
+    cursor = reference.index + reference.text.length;
+  }
+  return result + line.slice(cursor);
+}
+function rewrite_line(line, slug, is_in_fence) {
+  if (is_in_fence || FENCE_MARKER.test(line) || QUOTE_LINE.test(line)) return line;
+  return linkify_line(line, slug);
+}
+function linkify(message, slug) {
+  const out = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    out.push(rewrite_line(line, slug, is_in_fence));
+  }
+  return out.join("\n");
+}
+var issue_citation = {
+  bare_references,
+  cite_arguments,
+  has_bare_reference,
+  linkify,
+  prose_lines,
+  unquoted_references
+};
+
+// scripts/issue/session-cite.ts
+function session_repo() {
+  const url = repo_discovery.read_origin_url(process.cwd());
+  const identity = url === void 0 ? void 0 : repo_origin.parse_origin_url(url);
+  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
+}
+function issue(number, title, repo = session_repo()) {
+  return issue_cite.reference(repo, String(number), title);
+}
+function text(message) {
+  const repo = session_repo();
+  return repo === void 0 ? message : issue_citation.linkify(message, repo);
+}
+var session_cite = {
+  issue,
+  session_repo,
+  text
+};
+
+// scripts/run/hold/run-hold.ts
+import { z } from "zod";
+var HOLD_PREFIX = "josh-run-hold-";
+var UNNUMBERED_ISSUE = "new";
+var HOLD_MAX_AGE_HOURS = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
+var RELEASE_COMMAND = "pnpm josh run:release";
+var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
+var NOT_IDLE = 'that is not "nothing is running here"';
+var FREE_READ = { kind: "free" };
+var UNREADABLE_READ = { kind: "unreadable" };
+function hold_path(git_directory) {
+  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
+}
+async function worktree_directory() {
+  const directories = await git_command.git_directories();
+  return directories[0];
+}
+async function is_linked_worktree() {
+  const directories = await git_command.git_directories();
+  return directories[0] !== void 0 && directories[0] !== directories[1];
+}
+var run_hold_schema = z.object({
+  issue: z.string(),
+  taken_at: z.string(),
+  pid: z.number(),
+  is_fullrun: z.boolean().optional(),
+  is_halfrun_stop: z.boolean().optional(),
+  prrun_stop_head: z.string().optional(),
+  owner_pid: z.number().optional(),
+  owner_start: z.string().optional()
+});
+function parse_hold(raw) {
+  return json_value.parse_with(raw, run_hold_schema);
+}
+function is_expired(hold, now) {
+  return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
+}
+function is_owner_gone(hold) {
+  const is_stop_mark = hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
+  if (is_stop_mark || hold.owner_pid === void 0) return false;
+  return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
+}
+function is_stale(hold, now) {
+  return is_expired(hold, now) || is_owner_gone(hold);
+}
+function classify(raw, now) {
+  if (raw === void 0) return FREE_READ;
+  const hold = parse_hold(raw);
+  if (hold === void 0) return UNREADABLE_READ;
+  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
+}
+function read_hold(target, now = /* @__PURE__ */ new Date()) {
+  return classify(stamp_file.read_stamp_text(target), now);
+}
+function session_owner(environment = process.env) {
+  const pid = Number(environment[agent_session_environment.AGENT_PID_KEY]);
+  if (!Number.isSafeInteger(pid) || pid <= 0) return {};
+  return { owner_pid: pid, owner_start: process_identity.read_start(pid) };
+}
+function build_hold(issue2, now, is_fullrun) {
+  return { issue: issue2, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
+}
+function write_hold(target, issue2, now = /* @__PURE__ */ new Date()) {
+  const hold = build_hold(issue2, now);
+  stamp_file.write_stamp(target, hold);
+  return hold;
+}
+function create_hold(target, issue2, now = /* @__PURE__ */ new Date(), is_fullrun) {
+  return stamp_file.create_stamp(target, build_hold(issue2, now, is_fullrun));
+}
+var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
+function create_stop_hold(target, issue2, mark, now = /* @__PURE__ */ new Date()) {
+  return stamp_file.create_stamp(target, { ...build_hold(issue2, now), ...mark });
+}
+function create_halfrun_stop_hold(target, issue2, now = /* @__PURE__ */ new Date()) {
+  return create_stop_hold(target, issue2, HALFRUN_STOP_FIELDS, now);
+}
+async function is_tree_dirty(directory) {
+  try {
+    const status = await git_command.status(directory);
+    return status.trim() !== "";
+  } catch (error) {
+    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
+    return true;
+  }
+}
+function release_hold(target) {
+  stamp_file.remove_stamp(target);
+}
+function describe_holder(hold) {
+  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : session_cite.issue(hold.issue);
+  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.owner_pid ?? hold.pid)})`;
+}
+function own_release_command(issue2) {
+  return issue2 === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue2}`;
+}
+function is_own_hold(hold, claimant) {
+  return hold.issue === claimant;
+}
+function is_reentry(hold, claimant) {
+  return claimant !== UNNUMBERED_ISSUE && is_own_hold(hold, claimant);
+}
+function held_message(hold) {
+  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
+}
+function foreign_release_message(hold) {
+  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
+}
+function forced_release_message(hold) {
+  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
+}
+function unreadable_message() {
+  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
+}
+function stale_message(hold) {
+  const why = is_owner_gone(hold) ? "the session that wrote it has ended" : `older than ${String(HOLD_MAX_AGE_HOURS)} hours`;
+  return `Replaced a stale run record held by ${describe_holder(hold)}: ${why}, so the run that wrote it has ended without releasing it.`;
+}
+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 or outlived its session. 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(read, target) {
+  if (read.kind === "held") return held_message(read.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() {
+  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
+}
+var run_hold = {
+  FORCE_RELEASE_COMMAND,
+  HOLD_MAX_AGE_HOURS,
+  HOLD_MAX_AGE_MS,
+  RELEASE_COMMAND,
+  UNNUMBERED_ISSUE,
+  classify,
+  create_halfrun_stop_hold,
+  create_stop_hold,
+  HALFRUN_STOP_FIELDS,
+  create_hold,
+  foreign_release_message,
+  forced_release_message,
+  held_message,
+  hold_path,
+  is_linked_worktree,
+  is_own_hold,
+  is_reentry,
+  is_tree_dirty,
+  own_release_command,
+  race_message,
+  read_hold,
+  release_hold,
+  stale_message,
+  uncommitted_message,
+  unknown_message,
+  unreadable_message,
+  worktree_directory,
+  write_hold
+};
+
+// scripts/cost-runtime/cost-pricing.ts
+var CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var CACHE_WRITE_1H_MULTIPLIER = 2;
+var CACHE_READ_MULTIPLIER = 0.1;
+var TOKENS_PER_MILLION = 1e6;
+var MODEL_PRICES = {
+  "claude-fable-5": { input: 10, output: 50 },
+  "claude-mythos-5": { input: 10, output: 50 },
+  "claude-opus-5": { input: 5, output: 25 },
+  "claude-opus-4-8": { input: 5, output: 25 },
+  "claude-opus-4-7": { input: 5, output: 25 },
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-sonnet-5": { input: 2, output: 10 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-haiku-4-5": { input: 1, output: 5 }
+};
+var CONTEXT_MARKER = "[";
+function resolve_price(model) {
+  const base = model.split(CONTEXT_MARKER)[0] ?? model;
+  const direct = MODEL_PRICES[base];
+  if (direct !== void 0) return direct;
+  const [matched] = Object.keys(MODEL_PRICES).filter((id) => base.startsWith(id)).toSorted((left, right) => right.length - left.length);
+  return matched === void 0 ? void 0 : MODEL_PRICES[matched];
+}
+function estimate_cost(totals, price) {
+  const weighted_input = totals.input_tokens + totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER + totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER + totals.cache_read_tokens * CACHE_READ_MULTIPLIER;
+  return (weighted_input * price.input + totals.output_tokens * price.output) / TOKENS_PER_MILLION;
+}
+function priced(tokens, rate) {
+  return tokens * rate / TOKENS_PER_MILLION;
+}
+function estimate_composition(totals, price) {
+  return {
+    input_usd: priced(totals.input_tokens, price.input),
+    cache_write_5m_usd: priced(
+      totals.cache_write_5m_tokens * CACHE_WRITE_5M_MULTIPLIER,
+      price.input
+    ),
+    cache_write_1h_usd: priced(
+      totals.cache_write_1h_tokens * CACHE_WRITE_1H_MULTIPLIER,
+      price.input
+    ),
+    cache_read_usd: priced(totals.cache_read_tokens * CACHE_READ_MULTIPLIER, price.input),
+    output_usd: priced(totals.output_tokens, price.output)
+  };
+}
+function to_model_cost(model, totals) {
+  const price = resolve_price(model);
+  if (price === void 0) return { model, totals };
+  return { model, totals, cost_usd: estimate_cost(totals, price) };
+}
+function cost_by_model(records) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const running = grouped.get(record.model) ?? cost_usage.EMPTY_TOTALS;
+    grouped.set(record.model, cost_usage.add_totals(running, record.totals));
+  }
+  return [...grouped].map(([model, totals]) => to_model_cost(model, totals));
+}
+function total_cost(costs) {
+  return {
+    usd: costs.reduce((sum, entry) => sum + (entry.cost_usd ?? 0), 0),
+    unpriced: costs.filter((entry) => entry.cost_usd === void 0).map((entry) => entry.model)
+  };
+}
+function cost_of(records) {
+  return total_cost(cost_by_model(records)).usd;
+}
+var cost_pricing = {
+  CACHE_WRITE_5M_MULTIPLIER,
+  CACHE_WRITE_1H_MULTIPLIER,
+  CACHE_READ_MULTIPLIER,
+  resolve_price,
+  estimate_cost,
+  estimate_composition,
+  cost_by_model,
+  total_cost,
+  cost_of
+};
+
+// scripts/cost-runtime/context-cut-payback.ts
+var POST_CUT_CONTEXT = 6e4;
+var EXPECTED_REMAINING_REQUESTS = 10;
+function write_over_read() {
+  return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.CACHE_READ_MULTIPLIER;
+}
+function break_even_context(remaining = EXPECTED_REMAINING_REQUESTS) {
+  if (remaining <= 0) return Infinity;
+  return Math.round(POST_CUT_CONTEXT * (1 + write_over_read() / remaining));
+}
+function break_even_requests(current_context) {
+  const saved_per_request = current_context - POST_CUT_CONTEXT;
+  if (saved_per_request <= 0) return Infinity;
+  return POST_CUT_CONTEXT * write_over_read() / saved_per_request;
+}
+function pays_back(current_context, remaining = EXPECTED_REMAINING_REQUESTS) {
+  return current_context > break_even_context(remaining);
+}
+var context_cut_payback = {
+  POST_CUT_CONTEXT,
+  EXPECTED_REMAINING_REQUESTS,
+  break_even_context,
+  break_even_requests,
+  pays_back
+};
+
+// scripts/cost-runtime/context-cut-threshold.ts
+var CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context();
+
+// scripts/run/cut/run-cut.ts
+import { z as z3 } from "zod";
+
+// scripts/run/cut/run-cut-handoff.ts
+import { readFileSync } from "node:fs";
+import { z as z2 } from "zod";
+var handoff_schema = z2.object({
+  instruction: z2.string(),
+  completed: z2.array(z2.string()),
+  remaining: z2.array(z2.string()),
+  untouched: z2.array(z2.string())
+});
+var COMPLETED_LABEL = "Completed";
+var REMAINING_LABEL = "Remaining";
+var UNTOUCHED_LABEL = "Deliberately untouched";
+var INSTRUCTION_LABEL = "Instruction (verbatim)";
+var EMPTY_LIST_NOTE = "(none)";
+function describe_key(key2) {
+  const value = handoff_schema.shape[key2] instanceof z2.ZodArray ? '["\u2026"]' : '"\u2026"';
+  return `"${key2}": ${value}`;
+}
+var HANDOFF_FORMAT = `a JSON object {${handoff_schema.keyof().options.map((key2) => describe_key(key2)).join(", ")}}`;
+function parse_handoff(raw) {
+  return json_value.parse_with(raw, handoff_schema);
+}
+function read_handoff_file(handoff_path) {
+  try {
+    return parse_handoff(readFileSync(handoff_path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function is_complete_handoff(handoff) {
+  return handoff !== void 0 && handoff.instruction.trim() !== "";
+}
+function is_within_bound(handoff, max_bytes) {
+  return Buffer.byteLength(JSON.stringify(handoff), "utf8") <= max_bytes;
+}
+function load_handoff(handoff_path, max_bytes) {
+  if (handoff_path === void 0) return { kind: "ok", handoff: void 0 };
+  const handoff = read_handoff_file(handoff_path);
+  if (handoff === void 0) {
+    return {
+      kind: "bad",
+      note: `--handoff ${handoff_path} is not a readable handoff file \u2014 write ${HANDOFF_FORMAT}`
+    };
+  }
+  if (!is_within_bound(handoff, max_bytes)) {
+    return { kind: "bad", note: `--handoff ${handoff_path} is too large to carry across the cut` };
+  }
+  return { kind: "ok", handoff };
+}
+function describe_list(label, items) {
+  if (items.length === 0) return `${label}: ${EMPTY_LIST_NOTE}`;
+  const bullets = items.map((item) => `  - ${item}`).join("\n");
+  return `${label}:
+${bullets}`;
+}
+function describe_handoff(handoff) {
+  return [
+    `${INSTRUCTION_LABEL}:
+${handoff.instruction}`,
+    describe_list(COMPLETED_LABEL, handoff.completed),
+    describe_list(REMAINING_LABEL, handoff.remaining),
+    describe_list(UNTOUCHED_LABEL, handoff.untouched)
+  ].join("\n\n");
+}
+var HANDOFF_PATH = ".claude/tmp/handoff-<N>.json";
+var run_cut_handoff = {
+  HANDOFF_FORMAT,
+  HANDOFF_PATH,
+  describe_handoff,
+  handoff_schema,
+  is_complete_handoff,
+  load_handoff,
+  parse_handoff,
+  read_handoff_file
+};
+
+// scripts/run/cut/run-cut.ts
+var CUT_PREFIX = "josh-run-cut-";
+var { PRE_GATE_PHASE, IMPLEMENTATION_PHASE } = agent_role_profile;
+var IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD;
+var CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS;
+var CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
+var END_COMMAND = "pnpm josh run:cut --end";
+var READ_COMMAND = "pnpm josh run:cut --json";
+var MAX_HANDOFF_BYTES = 8192;
+var run_cut_schema = z3.object({
+  invocation: z3.string(),
+  issue: z3.string(),
+  branch: z3.string(),
+  phase: z3.string(),
+  cut_at: z3.string(),
+  is_handed_off: z3.boolean().optional(),
+  handoff: run_cut_handoff.handoff_schema.optional(),
+  is_merge_relaunched: z3.boolean().optional()
+});
+function cut_path(git_directory) {
+  return stamp_file.stamp_path(CUT_PREFIX, git_directory);
+}
+var { worktree_directory: worktree_directory2 } = run_hold;
+function invocation_for(issue2) {
+  return lane_child_invocation.child_invocation(issue2);
+}
+function parse_cut(raw) {
+  return json_value.parse_with(raw, run_cut_schema);
+}
+function cut_at_of(cut) {
+  return cut.cut_at;
+}
+var CUT_SPEC = {
+  parse: parse_cut,
+  timestamp_of: cut_at_of,
+  max_age_ms: CUT_MAX_AGE_MS
+};
+function is_expired2(cut, now) {
+  return stamp_record.is_older_than(cut_at_of(cut), CUT_MAX_AGE_MS, now);
+}
+function classify2(raw, now) {
+  const read = stamp_record.classify(raw, CUT_SPEC, now);
+  if (!("record" in read)) return read;
+  return { kind: read.kind, cut: read.record };
+}
+function read_cut(target, now = /* @__PURE__ */ new Date()) {
+  return classify2(stamp_file.read_stamp_text(target), now);
+}
+function worktree_git_directory_sync() {
+  return git_common_directory.own();
+}
+function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
+  if (directory === void 0) return void 0;
+  const read = read_cut(cut_path(directory), now);
+  return read.kind === "carried" ? read.cut : void 0;
+}
+function lane_cut_sync(lane_directory) {
+  const directory = git_common_directory.own(lane_directory);
+  if (directory === void 0) return void 0;
+  const cut = carried_cut_sync(/* @__PURE__ */ new Date(), directory);
+  return cut === void 0 ? void 0 : { target: cut_path(directory), cut };
+}
+function fresh_cut(spec, now) {
+  return {
+    invocation: invocation_for(spec.issue),
+    issue: spec.issue,
+    branch: spec.branch,
+    phase: spec.phase,
+    cut_at: now.toISOString(),
+    is_handed_off: true,
+    handoff: spec.handoff
+  };
+}
+function resumes_into_implementation(phase) {
+  return phase === IMPLEMENTATION_PHASE;
+}
+function within_handoff_bound(cut) {
+  return Buffer.byteLength(JSON.stringify(cut), "utf8") <= MAX_HANDOFF_BYTES;
+}
+function record_within_bound(spec, now = /* @__PURE__ */ new Date()) {
+  return within_handoff_bound(fresh_cut(spec, now));
+}
+function begin_cut(target, spec, now = /* @__PURE__ */ new Date()) {
+  const cut = fresh_cut(spec, now);
+  if (!within_handoff_bound(cut)) return void 0;
+  return stamp_file.create_stamp(target, cut) ? cut : void 0;
+}
+function is_declared_cut(cut, issue2) {
+  return cut.is_handed_off === true && cut.invocation === invocation_for(issue2);
+}
+function matches_state(cut, request) {
+  return cut.branch === request.current_branch && cut.issue === request.issue && request.is_dirty && request.is_held;
+}
+function is_adopted_cut(cut, issue2) {
+  return cut.is_handed_off === false && cut.invocation === invocation_for(issue2);
+}
+function has_required_handoff(cut) {
+  return !resumes_into_implementation(cut.phase) || run_cut_handoff.is_complete_handoff(cut.handoff);
+}
+function is_relaunchable(cut, issue2) {
+  return is_declared_cut(cut, issue2) && has_required_handoff(cut) && cut.is_merge_relaunched !== true;
+}
+function mark_merge_relaunched(target, cut) {
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, { ...cut, is_merge_relaunched: true });
+}
+function classify_resume(cut, request) {
+  if (is_adopted_cut(cut, request.issue)) return "handed-off";
+  if (!is_declared_cut(cut, request.issue) || !matches_state(cut, request)) return "stale";
+  return has_required_handoff(cut) ? "resume" : "incomplete";
+}
+function adopt_cut(target, cut) {
+  const next = { ...cut, is_handed_off: false };
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, next) ? next : void 0;
+}
+function end_cut(target) {
+  stamp_file.remove_stamp(target);
+}
+function hold_of(directory) {
+  if (directory === void 0) return void 0;
+  const read = run_hold.read_hold(run_hold.hold_path(directory));
+  return read.kind === "held" || read.kind === "stale" ? read.hold : void 0;
+}
+function fullrun_issue(hold) {
+  return hold?.is_fullrun === true ? hold.issue : void 0;
+}
+function held_issue_sync() {
+  return fullrun_issue(hold_of(worktree_git_directory_sync()));
+}
+async function current_state() {
+  const branch = await git_command.branch();
+  const is_dirty = await run_hold.is_tree_dirty();
+  const hold = hold_of(await worktree_directory2());
+  return { branch, is_dirty, is_held: hold !== void 0, held_issue: fullrun_issue(hold) };
+}
+function describe_cut(cut) {
+  return `${cut.invocation} cut at ${cut.cut_at} on ${cut.branch} (${cut.phase})`;
+}
+function busy_message(cut) {
+  return `Another process already resumed this cut \u2014 ${describe_cut(cut)}. Nothing was resumed here; a double launch was detected.`;
+}
+function handed_off_message(cut) {
+  return `This cut was already handed off to a successor \u2014 ${describe_cut(cut)}. Nothing was resumed here; the run is being carried on by the process that adopted it, so this one has nothing to do.`;
+}
+function stale_message2(cut) {
+  return `This cut does not match the current tree \u2014 ${describe_cut(cut)}. Resume failed; verify the branch and the uncommitted work, then clear it with \`${END_COMMAND}\` if the run is over.`;
+}
+function incomplete_message(cut) {
+  return `This cut carries no instruction to resume on \u2014 ${describe_cut(cut)}. Resume was refused rather than continuing without it; recover the run's instruction and work state before implementing, and clear the record with \`${END_COMMAND}\` if the run is over.`;
+}
+function unreadable_message2() {
+  return `A cut record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it. Read it with \`${READ_COMMAND}\`.`;
+}
+function unknown_message2() {
+  return "This working tree\u2019s git directory could not be read, so no cut record was acted on.";
+}
+var run_cut = {
+  CUT_MAX_AGE_HOURS,
+  CUT_MAX_AGE_MS,
+  END_COMMAND,
+  IMPLEMENTATION_CONTEXT_THRESHOLD,
+  IMPLEMENTATION_PHASE,
+  MAX_HANDOFF_BYTES,
+  PRE_GATE_PHASE,
+  adopt_cut,
+  begin_cut,
+  busy_message,
+  carried_cut_sync,
+  classify: classify2,
+  classify_resume,
+  current_state,
+  cut_path,
+  describe_cut,
+  end_cut,
+  fresh_cut,
+  fullrun_issue,
+  handed_off_message,
+  has_required_handoff,
+  held_issue_sync,
+  incomplete_message,
+  invocation_for,
+  is_expired: is_expired2,
+  is_relaunchable,
+  lane_cut_sync,
+  mark_merge_relaunched,
+  read_cut,
+  record_within_bound,
+  resumes_into_implementation,
+  stale_message: stale_message2,
+  unknown_message: unknown_message2,
+  unreadable_message: unreadable_message2,
+  within_handoff_bound,
+  worktree_directory: worktree_directory2,
+  worktree_git_directory_sync
+};
+
+// scripts/rules/run-tail-rule.ts
+var SEGMENT_PREFIX = String.raw`(?:\(\s*)?(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:npx\s+|pnpm\s+(?:exec\s+|run\s+)?)?`;
+var WORD_END = String.raw`(?=\s|$|\))`;
+var PUSH_STEP_SEGMENT = new RegExp(String.raw`^${SEGMENT_PREFIX}josh\s+(?:git|g)${WORD_END}`, "u");
+var CONFIRMED_FLAG = new RegExp(String.raw`(?:^|\s)(?:-y|--yes)${WORD_END}`, "u");
+var SKIPS_THE_PUSH = new RegExp(String.raw`(?:^|\s)--skip-push${WORD_END}`, "u");
+var BACKGROUND_KEY = "run_in_background";
+var QUOTED_SPAN = /"[^"]*"|'[^']*'/gu;
+function flags_of(segment) {
+  return segment.replaceAll(QUOTED_SPAN, " ");
+}
+function is_push_step_segment(segment) {
+  if (!PUSH_STEP_SEGMENT.test(segment)) return false;
+  const flags = flags_of(segment);
+  if (SKIPS_THE_PUSH.test(flags)) return false;
+  return CONFIRMED_FLAG.test(flags);
+}
+function is_push_step(command) {
+  return shell_segments.segments_of(command).some((segment) => is_push_step_segment(segment));
+}
+function is_backgrounded(input) {
+  if (!json_value.is_record(input)) return false;
+  return input[BACKGROUND_KEY] === true;
+}
+function is_push_step_call(call) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  return is_push_step(time_shell.bash_command(call.input));
+}
+function is_backgrounded_push_step(call) {
+  if (!is_backgrounded(call.input)) return false;
+  return is_push_step_call(call);
+}
+function is_foreground_push_step(call) {
+  if (is_backgrounded(call.input)) return false;
+  return is_push_step_call(call);
+}
+function decide2() {
+  return true;
+}
+var RUN_TAIL_REASON = '\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set. In `fullrun #1501` this call was given a 900-second timeout, the harness detached it at its own 600-second cap, and nothing read the output for a further 6m28s \u2014 45m03s of wall clock on about 17 minutes of work (joshuafolkken/kit#1510). **Never give a foreground call a timeout above the harness cap**: the cap decides, not the number. A backgrounded call re-invokes you when it exits, so the completion notification is what resumes the run. **When it arrives, the turn that reads it goes straight through any branch-2 filing and `pnpm josh epic:bundle` to `pnpm josh followup` \u2014 the turn never ends at the push.** CI went green 6m06s before the merge started in that run, and it started only because the person asked; joshuafolkken/kit#1333 had already settled that the merge is issued in the turn the review closes. While the push runs, do the work that writes nothing \u2014 drafting the completion body to a file, deciding the branch-2 disposition. `pnpm josh followup` itself stays in the **foreground** \u2014 nearly every step after it reads its result. But a tail does follow the merge, measured at 3.0 min and 5.9% of a run (joshuafolkken/kit#1462), so empty it beforehand: the steps that read the merge result stay after `followup`, and the rest are composed in the turn that issues it, bar the one exception background-commands.md names. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every foreground push, not once per run**, so reissuing the same call in the foreground will be refused again.';
+var run_tail_rule = {
+  RUN_TAIL_REASON,
+  decide: decide2,
+  is_backgrounded_push_step,
+  is_foreground_push_step,
+  is_push_step,
+  is_push_step_call
+};
+
+// scripts/rules/lane-background.ts
+var SHIP_COMMAND = `${time_shell.JOSH_PREFIX}ship`;
+var LONG_RUNNING_COMMANDS = /* @__PURE__ */ new Set([
+  ...["gate", "git", "followup"].map((name) => `${time_shell.JOSH_PREFIX}${name}`),
+  SHIP_COMMAND
+]);
+var BACKGROUND_KEY2 = "run_in_background";
+var TIMEOUT_KEY = "timeout";
+var FOREGROUND_TIMEOUT_MS = 6e5;
+function is_backgrounded2(input) {
+  return json_value.is_record(input) && input[BACKGROUND_KEY2] === true;
+}
+function long_commands_of(command) {
+  return time_shell.josh_commands_of(command).filter((name) => LONG_RUNNING_COMMANDS.has(name));
+}
+function ships_alone(command) {
+  const names = long_commands_of(command);
+  return names.length > 0 && names.every((name) => name === SHIP_COMMAND);
+}
+function backgrounded_bash_command(call) {
+  if (call.name !== cost_blocks.BASH_TOOL || !is_backgrounded2(call.input)) return void 0;
+  return time_shell.bash_command(call.input);
+}
+function is_backgrounded_ship(call) {
+  const command = backgrounded_bash_command(call);
+  return command !== void 0 && ships_alone(command);
+}
+function is_candidate(call) {
+  if (run_tail_rule.is_push_step_call(call)) return true;
+  const command = backgrounded_bash_command(call);
+  if (command === void 0 || is_backgrounded_ship(call)) return false;
+  return long_commands_of(command).length > 0;
+}
+function is_background_long_run(call, is_lane_child = () => lane_child_marker.is_child_of(process.cwd())) {
+  return is_candidate(call) && is_lane_child();
+}
+function foreground_input(call, is_lane_child = () => lane_child_marker.is_child_of(process.cwd())) {
+  if (!is_backgrounded_ship(call) || !json_value.is_record(call.input)) return void 0;
+  if (!is_lane_child()) return void 0;
+  return { ...call.input, [BACKGROUND_KEY2]: false, [TIMEOUT_KEY]: FOREGROUND_TIMEOUT_MS };
+}
+var FOREGROUND_NOTE = "lane background: this lane child backgrounded `josh ship`, which would die with the headless turn before its supervisor exists \u2014 so it was run in the foreground instead, where it detaches itself after the preflight. End the turn on `launched` / `busy` (joshuafolkken/kit#3154).";
+function unfinished_ids(tail, launched_ids) {
+  const lines = tail.split("\n").map((line) => time_transcript_line.parse_line(line));
+  const finished = new Set(lines.map((line) => line?.finished_background ?? ""));
+  const blocks = lines.flatMap((line) => line?.blocks ?? []);
+  const launched = blocks.flatMap((block) => launched_ids(block));
+  return launched.filter((id) => id !== "" && !finished.has(id));
+}
+function pending_background_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.background_id, block.agent_id]);
+}
+function pending_agent_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.agent_id]);
+}
+var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless `claude -p` process whose background Bash tasks are killed when the turn ends \u2014 so a backgrounded `josh gate` / `josh git` / `josh followup` / `josh ship` never re-invokes you; it dies at `exit code 143` (joshuafolkken/kit#2704, measured on the #2606 child: implementation, review and live verification done, the run parked instead of merged). Hand the gate-to-merge region to the detached supervisor instead: `pnpm josh ship --detach --review "<title> #<N>"` (add `--cite <N>`) issued in the foreground \u2014 its preflight runs in this process before the supervisor exists, so a backgrounded `ship` dies with the turn (joshuafolkken/kit#3027; a backgrounded `ship` issued alone is moved to the foreground for you, joshuafolkken/kit#3154) \u2014 then end the turn on `launched` / `busy`. `.claude/skills/workflow-commands/chain-rule.md` step 0 is the single source. A single check you must read before continuing runs in the foreground within the tool timeout; the commit-push step does not \u2014 in a child it too belongs to the detached ship, in either spelling. This rule fires on every occurrence, not once per run.';
+var LANE_BACKGROUND_STOP_REASON = "\u26D4 lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task it launched has not finished \u2014 ending this headless turn kills it, and nothing re-invokes you afterwards (joshuafolkken/kit#2704). Do not send a notification and do not stop: wait for the task in the foreground and act on its result, or re-issue the work through `pnpm josh ship --detach`, whose supervisor outlives the turn (`.claude/skills/workflow-commands/chain-rule.md` step 0). Do not repeat your previous reply.";
+var ROW2 = {
+  id: "lane-background",
+  is_trigger: (call) => is_background_long_run(call),
+  reason: LANE_BACKGROUND_REASON,
+  decide: () => true
+};
+var lane_background = {
+  FOREGROUND_NOTE,
+  LANE_BACKGROUND_REASON,
+  LANE_BACKGROUND_STOP_REASON,
+  ROW: ROW2,
+  foreground_input,
+  is_background_long_run,
+  pending_agent_ids,
+  pending_background_ids
+};
+
+// scripts/run/ship/run-ship-detach.ts
+import { randomUUID } from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// scripts/run/event/run-event-stream.ts
+import { z as z4 } from "zod";
+var EVENT_PREFIX = "josh-run-events-";
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 500;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR = "\n";
+var WORD_SEPARATOR = " ";
+var STAGE_PHASE_INDEX = 2;
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var EVENT_KIND = {
+  PLAN: "plan",
+  CHILD_LAUNCH: "child-launch",
+  MERGE: "merge",
+  PARK: "park",
+  SPLIT: "split",
+  OUTAGE: "outage",
+  CUT: "cut",
+  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
+  // resume clears the cut record, so without this the `cut` would stay the newest position and
+  // `run:step` would keep answering the resume command it had just run.
+  RESUME: "resume",
+  // The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
+  // at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
+  // the retrospective at the drain rather than after the watch runs its course. It is not itself a
+  // stop: the run watches on once the retrospective has run, and the real `STOP` follows when the watch
+  // expires.
+  DRAIN: "drain",
+  STOP: "stop",
+  PR_OPENED: "pr-opened",
+  REVIEW_ROUND: "review-round",
+  // The end-of-run retrospective's result, recorded when the run marks the retrospective done. A
+  // retrospective that files zero improvements and one that never ran look
+  // the same from outside — no new Issue either way — so the result is put on the stream the report is
+  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
+  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
+  // what it found are one action rather than two the run could do only one of.
+  RETROSPECTIVE: "retrospective",
+  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
+  // while. Emitted once per stall episode by the stop-time detector, it is both the dedup marker —
+  // `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes — and the line a terminal
+  // reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
+  // stalled is pointed straight at dispatching the work rather than left waiting.
+  STALL: "stall",
+  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
+  // is watching. Emitted once per strand episode by the stop-time detector,
+  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
+  // than once, and a terminal reader following the stream sees the line. The strand is the step before
+  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
+  STRANDED: "stranded",
+  // One `josh ship` stage starting, succeeding or failing. It is a trace of the
+  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
+  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
+  // — so it is one of the `TRACE_KINDS` the last-event read skips.
+  SHIP_STAGE: "ship-stage",
+  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints. Printed only to
+  // the watcher's own output, a headless successor's heartbeat would be buried in its log after a cut;
+  // on the stream it reaches the attached session's relay. It says
+  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
+  HEARTBEAT: "heartbeat",
+  // The post-implementation region handed to a detached `josh ship --detach` supervisor. Unlike a stage
+  // trace it is a position: the agent has ended and the
+  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
+  SHIP_LAUNCH: "ship-launch",
+  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
+  // The position that hands control back: `run:step` prints the command that
+  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
+  SHIP_STOP: "ship-stop",
+  // The idle watch's window — when the run began waiting on an empty backlog and when that wait ends
+  // `backlog:offer` writes it whenever the window changes, so `run:board` reads
+  // the deadline rather than guessing it. It is a trace: `emit_once`'s drain dedup and `run:step`'s
+  // position both read past it, so a watching loop never re-marks the drain it is waiting after.
+  IDLE: "idle",
+  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
+  // still surfaces what it found — `run:board`'s findings section reads it.
+  FILED: "filed",
+  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
+  // same section.
+  NOTE: "note",
+  // A lane child reached a phase no other event marks — its first implementation edit, written by the
+  // PreToolUse hook — so `run:board` draws how far the child has got. A trace,
+  // like `SHIP_STAGE`: it says where the child's work is, not where the run is.
+  LANE_PHASE: "lane-phase",
+  // An issue `run:add` put into the live run. The parent's `--wait` watcher
+  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
+  // trace: it says what the run was handed, not where the run is.
+  ADD: "add",
+  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
+  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
+  // already holds. A trace: it says the run gained room, not where the run is.
+  LANE_LIMIT: "lane-limit"
+};
+var EVENT_KINDS = Object.values(EVENT_KIND);
+var TRACE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.IDLE,
+  EVENT_KIND.FILED,
+  EVENT_KIND.NOTE,
+  EVENT_KIND.LANE_PHASE,
+  EVENT_KIND.ADD,
+  EVENT_KIND.LANE_LIMIT
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.IDLE
+]);
+var event_schema = z4.object({
+  pos: z4.number(),
+  at: z4.string(),
+  kind: z4.string(),
+  text: z4.string()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository) {
+  return stamp_file.stamp_path(EVENT_PREFIX, repository, EVENT_SUFFIX);
+}
+function is_present(event) {
+  return event !== void 0;
+}
+function parse_line(line) {
+  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function read_events(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
+}
+function last_position(events) {
+  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
+}
+function issue_of(event) {
+  return event.text.split(WORD_SEPARATOR)[FIRST_POSITION] ?? "";
+}
+function newest_stages(events) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind === EVENT_KIND.SHIP_STAGE) newest.set(issue_of(event), event);
+  }
+  return new Set(newest.values());
+}
+function is_stage_start(event) {
+  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
+  return event.text.split(WORD_SEPARATOR)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
+}
+function is_drawn(event) {
+  return event.kind === EVENT_KIND.IDLE || is_stage_start(event);
+}
+function droppable(events) {
+  const kept = newest_stages(events);
+  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
+  return [
+    ...disposable.filter((event) => !is_drawn(event)),
+    ...disposable.filter((event) => is_drawn(event))
+  ];
+}
+function bounded(events) {
+  const excess = events.length - EVENT_CAP;
+  if (excess <= 0) return events;
+  const dropped = new Set(droppable(events).slice(0, excess));
+  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
+}
+function serialize(events) {
+  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
+}
+function append_held(target, event) {
+  const existing = read_events(target);
+  const position = last_position(existing) + POSITION_INCREMENT;
+  const events = bounded([...existing, { pos: position, ...event }]);
+  stamp_file.replace_text_stamp(target, serialize(events));
+  return position;
+}
+function append(target, kind, text2, at) {
+  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
+  const lock = `${target}${LOCK_SUFFIX}`;
+  const position = repository_lock.with_lock_sync(
+    () => append_held(target, { at, kind, text: text2 }),
+    lock,
+    LOCK_WAIT_MS
+  );
+  if (position === void 0) {
+    const message = `run event stream: gave up waiting for the lock at ${lock}`;
+    process.stderr.write(`${message}
+`);
+    throw new Error(message);
+  }
+  return { appended: true, position };
+}
+function read_from(target, position) {
+  const events = read_events(target);
+  return {
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
+  };
+}
+function read_last(target) {
+  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
+}
+function has_since(events, kind, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT).some((event) => event.kind === kind);
+}
+var FIELD_SEPARATOR = " \xB7 ";
+function format_event(event) {
+  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
+}
+var run_event_stream = {
+  EVENT_CAP,
+  EVENT_KIND,
+  EVENT_KINDS,
+  TRACE_KINDS,
+  append,
+  format_event,
+  has_since,
+  is_stage_start,
+  read_events,
+  read_from,
+  read_last,
+  target_of
+};
+
+// scripts/run/event/run-event-scope.ts
+var SINCE_SCOPE = "since";
+var UNKNOWN_SCOPE = "unknown";
+var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
+function moment_of(at) {
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
+}
+function scoped_events(events, scope) {
+  if (scope.kind === UNKNOWN_SCOPE) return void 0;
+  const floor = moment_of(scope.started_at);
+  if (floor === void 0) return void 0;
+  return events.filter((event) => is_within(event, floor));
+}
+function scope_of(read) {
+  if (read.kind === "carried" || read.kind === "expired") {
+    return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
+  }
+  return UNKNOWN_EVENT_SCOPE;
+}
+function last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
+}
+var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+  run_event_stream.EVENT_KIND.SHIP_STOP
+]);
+var KIND = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.PARK,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue2) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue2)} `);
+}
+function is_own_ship_event(event, issue2) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue2);
+}
+function issue_named(event) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1];
+}
+function names_issue(event, issue2) {
+  return issue_named(event) === issue2;
+}
+function is_lane_position(event, issue2) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue2);
+}
+function since_own_launch(events, issue2) {
+  const launch2 = events.findLastIndex(
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue2)
+  );
+  return events.slice(launch2 + 1);
+}
+function is_foreign_event(event, issue2, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue2);
+  return is_foreign_ship_event(event, issue2);
+}
+function last_issue_event(events, scope, issue2, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue2) : events;
+  const own = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
+  return own.findLast((event) => is_own_ship_event(event, issue2));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.MERGE,
+  KIND.PARK,
+  KIND.SPLIT
+]);
+function is_merge_owed(events, scope, issue2) {
+  const newest = (scoped_events(events, scope) ?? []).findLast(
+    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue2)
+  );
+  return newest?.kind === KIND.CHILD_LAUNCH;
+}
+var run_event_scope = {
+  UNKNOWN_EVENT_SCOPE,
+  is_merge_owed,
+  issue_named,
+  last_issue_event,
+  last_scoped_event,
+  moment_of,
+  scope_of,
+  scoped_events,
+  since_own_launch
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function stream_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
+}
+async function emit(kind, text2) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return;
+    run_event_stream.append(target, kind, text2, now_iso());
+  } catch {
+  }
+}
+async function emit_once(kind, text2) {
+  try {
+    const target = await stream_target();
+    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
+    return run_event_stream.append(target, kind, text2, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+async function emit_changed(kind, text2) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return false;
+    const newest = run_event_stream.read_events(target).findLast((event) => event.kind === kind);
+    if (newest?.text === text2) return false;
+    return run_event_stream.append(target, kind, text2, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_changed", error);
+    return false;
+  }
+}
+function invocation_events(repository, target) {
+  const events = run_event_stream.read_events(target);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since(kind, text2, reset_kind) {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return false;
+    const target = run_event_stream.target_of(repository);
+    if (run_event_stream.has_since(invocation_events(repository, target), kind, reset_kind)) {
+      return false;
+    }
+    return run_event_stream.append(target, kind, text2, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
+    return false;
+  }
+}
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
+}
+async function current_events() {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return [];
+    const read = run_carry.read_carry(run_carry.carry_path(repository));
+    const scope = run_event_scope.scope_of(read);
+    const events = run_event_stream.read_events(run_event_stream.target_of(repository));
+    return run_event_scope.scoped_events(events, scope) ?? [];
+  } catch {
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
+  } catch {
+    return [];
+  }
+}
+async function all_events() {
+  try {
+    const target = await stream_target();
+    return target === void 0 ? [] : run_event_stream.read_events(target);
+  } catch {
+    return [];
+  }
+}
+var run_event_stream_emit = {
+  all_events,
+  current_events,
+  emit,
+  emit_changed,
+  emit_heartbeat,
+  emit_once,
+  emit_once_since,
+  invocation_or_all_events,
+  stream_target
+};
+
+// scripts/run/ship/run-ship-detach.ts
+import { z as z5 } from "zod";
+var LOG_PREFIX = "josh-ship-log-";
+var PID_PREFIX = "josh-ship-pid-";
+var BODY_PREFIX = "josh-ship-notify-";
+var KEY_SEPARATOR = "-";
+var LOG_SUFFIX = ".log";
+var BODY_SUFFIX = ".txt";
+var PNPM = "pnpm";
+var INLINE_NOTIFY = "--notify-message";
+var FILE_NOTIFY = "--notify-message-file";
+var NOTIFY_VALUE_INDEX = 1;
+var SUPERVISED_KEY = "JOSH_SHIP_SUPERVISED";
+var LAUNCH_ID_KEY = "JOSH_SHIP_LAUNCH_ID";
+var SUPERVISED_VALUE = "1";
+var LAUNCHED = "launched";
+var BUSY = "busy";
+var FAILED = "failed";
+var RESULT_PREFIX = "josh-ship-result-";
+var RECORD_POLL_MS = 25;
+var RECORD_WAIT_ATTEMPTS = 200;
+var CLAIM_WINDOW_MS = 12e4;
+var ship_record_schema = z5.object({
+  pid: z5.number().int().positive().optional(),
+  process_start: z5.string().optional(),
+  launched_at: z5.number().optional(),
+  launcher_pid: z5.number().int().positive().optional(),
+  launcher_start: z5.string().optional(),
+  launch_id: z5.string(),
+  result: z5.enum(["success", "failed"]).optional()
+});
+var LAUNCH_MARK = " \xB7 started by process ";
+var HEADER_START = "\n";
+function key(prefix, request) {
+  return stamp_file.stamp_path(`${prefix}${request.number}${KEY_SEPARATOR}`, request.repository);
+}
+function log_path(repository, number) {
+  return stamp_file.stamp_path(`${LOG_PREFIX}${number}${KEY_SEPARATOR}`, repository, LOG_SUFFIX);
+}
+function result_path(repository, number) {
+  return stamp_file.stamp_path(`${RESULT_PREFIX}${number}${KEY_SEPARATOR}`, repository);
+}
+function read_record(repository, number) {
+  try {
+    const raw = stamp_file.read_stamp_text(result_path(repository, number));
+    return raw === void 0 ? void 0 : json_value.parse_with(raw, ship_record_schema);
+  } catch {
+    return void 0;
+  }
+}
+function record_launch(request, pid, launch_id) {
+  stamp_file.write_text_stamp(key(PID_PREFIX, request), String(pid));
+  const process_start = process_identity.read_start(pid);
+  stamp_file.replace_stamp(result_path(request.repository, request.number), {
+    pid,
+    launch_id,
+    launched_at: Date.now(),
+    ...process_start !== void 0 && { process_start }
+  });
+}
+function supervisor_environment(launch_id) {
+  return {
+    ...agent_role_profile.handoff_environment(),
+    [SUPERVISED_KEY]: SUPERVISED_VALUE,
+    [LAUNCH_ID_KEY]: launch_id
+  };
+}
+function is_within_claim_window(record) {
+  return record.launched_at !== void 0 && Date.now() - record.launched_at < CLAIM_WINDOW_MS;
+}
+function has_live_identity(pid, record) {
+  if (record.process_start === void 0) {
+    return is_within_claim_window(record) && process_identity.is_live_pid(pid);
+  }
+  return process_identity.is_same_process(pid, record.process_start) !== false;
+}
+function result_of(record) {
+  if (record.pid === void 0) {
+    const is_launcher = process_identity.is_same_process(record.launcher_pid, record.launcher_start);
+    return is_launcher === false ? "abnormal" : "running";
+  }
+  if (has_live_identity(record.pid, record)) return "running";
+  return record.result ?? "abnormal";
+}
+function read_result(repository, number) {
+  const record = read_record(repository, number);
+  return record === void 0 ? void 0 : { launch_id: record.launch_id, result: result_of(record) };
+}
+function current_record(repository, number) {
+  const record = read_record(repository, number);
+  return record?.launch_id === process.env[LAUNCH_ID_KEY] ? record : void 0;
+}
+function is_pending(record) {
+  return record !== void 0 && record.pid === void 0;
+}
+async function ready_record(repository, number) {
+  let record = current_record(repository, number);
+  for (let attempt = 0; attempt < RECORD_WAIT_ATTEMPTS; attempt += 1) {
+    if (!is_pending(record)) return record;
+    await sleep(RECORD_POLL_MS);
+    record = current_record(repository, number);
+  }
+  return void 0;
+}
+async function update_record(repository, number, fields) {
+  const record = await ready_record(repository, number);
+  if (record === void 0) return;
+  stamp_file.replace_stamp(result_path(repository, number), { ...record, ...fields });
+}
+async function mark_result(repository, number, code) {
+  await update_record(repository, number, { result: code === 0 ? "success" : "failed" });
+}
+async function claim_identity(repository, number) {
+  const own = process_identity.own_fields();
+  if (own.process_start === void 0) return;
+  await update_record(repository, number, own);
+}
+function failed_launch(request, note) {
+  stamp_file.remove_stamp(result_path(request.repository, request.number));
+  return { verdict: FAILED, note };
+}
+function notify_arguments(request) {
+  const [flag, value] = [request.notify[0], request.notify[NOTIFY_VALUE_INDEX]];
+  if (flag !== INLINE_NOTIFY || value === void 0) return request.notify;
+  const body_path = stamp_file.stamp_path(
+    `${BODY_PREFIX}${request.number}${KEY_SEPARATOR}`,
+    request.repository,
+    BODY_SUFFIX
+  );
+  stamp_file.write_text_stamp(body_path, value);
+  return [FILE_NOTIFY, body_path];
+}
+function supervisor_argv(request) {
+  const review = request.is_review ? ["--review"] : [];
+  const cites = request.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    command: PNPM,
+    args: [
+      "josh",
+      "ship",
+      ...review,
+      ...notify_arguments(request),
+      ...request.body,
+      ...cites,
+      request.title
+    ]
+  };
+}
+function prepare_launch(request) {
+  const launch_id = randomUUID();
+  const launcher = process_identity.own_fields();
+  stamp_file.replace_stamp(result_path(request.repository, request.number), {
+    launch_id,
+    launcher_pid: launcher.pid,
+    ...launcher.process_start !== void 0 && { launcher_start: launcher.process_start }
+  });
+  return launch_id;
+}
+function launch(request) {
+  const notes = [];
+  const log = log_path(request.repository, request.number);
+  const launch_id = prepare_launch(request);
+  const result = detached_launch.launch(
+    {
+      argv: supervisor_argv(request),
+      cwd: request.cwd,
+      log_path: log,
+      // The provider travels as a mark because the launch strips the session keys that name it, and
+      // `ship --review` resolves its reviewer from it.
+      env: supervisor_environment(launch_id)
+    },
+    (note) => {
+      notes.push(note);
+    }
+  );
+  agent_role_profile.warn_of_default();
+  if (result.kind === "failed") return failed_launch(request, result.note);
+  record_launch(request, result.pid, launch_id);
+  return {
+    verdict: LAUNCHED,
+    note: [`supervisor ${String(result.pid)} \u2014 log: ${log}`, ...notes].join("\n")
+  };
+}
+async function detach(request) {
+  if (read_result(request.repository, request.number)?.result === "running") {
+    return {
+      verdict: BUSY,
+      note: `a ship supervisor for ${session_cite.issue(request.number)} is already running`
+    };
+  }
+  const result = launch(request);
+  if (result.verdict === LAUNCHED) {
+    await run_event_stream_emit.emit(
+      run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+      `${issue_cite.plain(request.number)} ship supervisor launched`
+    );
+  }
+  return result;
+}
+function last_launch(text2) {
+  const mark = text2.lastIndexOf(LAUNCH_MARK);
+  if (mark === -1) return text2;
+  return text2.slice(text2.lastIndexOf(HEADER_START, mark) + HEADER_START.length);
+}
+function read_log(repository, number) {
+  const text2 = stamp_file.read_stamp_text(log_path(repository, number));
+  return text2 === void 0 ? void 0 : last_launch(text2);
+}
+function is_supervised(source = process.env) {
+  return source[SUPERVISED_KEY] === SUPERVISED_VALUE;
+}
+var run_ship_detach = {
+  BUSY,
+  FAILED,
+  LAUNCHED,
+  LAUNCH_ID_KEY,
+  claim_identity,
+  mark_result,
+  read_result,
+  SUPERVISED_KEY,
+  detach,
+  is_supervised,
+  last_launch,
+  log_path,
+  read_log,
+  supervisor_argv
+};
+
+// scripts/lane/lane-handoff.ts
+function is_ship_running(issue2, directory) {
+  const repository = git_common_directory.repository(directory);
+  return repository !== void 0 && run_ship_detach.read_result(repository, issue2)?.result === "running";
+}
+function is_handed_off(directory, source = process.env) {
+  const issue2 = lane_child_marker.marked_issue(source);
+  if (issue2 === void 0 || !lane_child_marker.is_child_of(directory, source)) return false;
+  return is_ship_running(issue2, directory);
+}
+var lane_handoff = { is_handed_off, is_ship_running };
+
+// scripts/issue/issue-labels.ts
+var EPIC_LABEL = "epic";
+var ENHANCEMENT_LABEL = "enhancement";
+var BREAKING_CHANGE_LABEL = "breaking-change";
+var IN_PROGRESS_LABEL = "in-progress";
+var PLANNED_LABEL = "run:planned";
+var NEEDS_DECISION_LABEL = "needs-decision";
+var RUN_SOLO_LABEL = "run:solo";
+var RUN_LANE_LABEL = "run:lane";
+var PRIORITY_HIGH_LABEL = "priority:high";
+var NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
+var ALREADY_DONE_LABEL = "already-done";
+var RELEASE_LABEL = "release";
+var INTERRUPT_ROUTE_LABEL = "route:interrupt";
+var REVIEW_CAP_ROUTE_LABEL = "route:review-cap";
+var SPLIT_ROUTE_LABEL = "route:split";
+var TIER_A_ROUTE_LABEL = "route:tier-a";
+var FILING_ROUTE_LABELS = [
+  {
+    name: INTERRUPT_ROUTE_LABEL,
+    // Not `5319e7`, which is the `epic` label's purple: in a listing an interrupt would render as
+    // an epic, and the two are read at a glance rather than by name.
+    color: "1d76db",
+    // Keyed to the tests rather than to severity. "A serious defect" is the self-assessment
+    // `wip-cap.md` bans as a criterion, and this string is what a person reads in `gh label list`.
+    description: "Filed past the WIP cap \u2014 meets one of the three interrupt tests (wip-cap.md)"
+  },
+  {
+    name: REVIEW_CAP_ROUTE_LABEL,
+    color: "eab308",
+    description: "Filed by the review round cap's carry-forward (prompts/review.md \u2192 Review round cap)"
+  },
+  {
+    name: SPLIT_ROUTE_LABEL,
+    color: "0e8a16",
+    description: "A child issue created by a split (split-assessment.md)"
+  },
+  {
+    name: TIER_A_ROUTE_LABEL,
+    color: "d93f0b",
+    description: "Filed Tier A during implementation \u2014 an upstream defect or a prerequisite"
+  }
+];
+var DEPTH_0_LABEL = "depth:0";
+var DEPTH_1_LABEL = "depth:1";
+var DEPTH_2_LABEL = "depth:2";
+var DEPTH_LABELS = [
+  {
+    name: DEPTH_0_LABEL,
+    color: "0e8a16",
+    description: "Depth 0 \u2014 what a consumer of this package touches (observation-filing.md)"
+  },
+  {
+    name: DEPTH_1_LABEL,
+    color: "fbc02d",
+    description: "Depth 1 \u2014 the run orchestration that executes an Issue (observation-filing.md)"
+  },
+  {
+    name: DEPTH_2_LABEL,
+    color: "c5def5",
+    description: "Depth 2 \u2014 what measures a run (observation-filing.md)"
+  }
+];
+var WORKFLOW_LABELS = [
+  {
+    name: EPIC_LABEL,
+    color: "5319e7",
+    description: "Tracks a batch of child issues from one split"
+  },
+  { name: IN_PROGRESS_LABEL, color: "0075ca", description: "Work is actively in progress" },
+  { name: PLANNED_LABEL, color: "c2e0c6", description: "kickoff posted the plan" },
+  {
+    name: RUN_SOLO_LABEL,
+    color: "b60205",
+    description: "Runs alone in a backlogrun: nothing starts beside it"
+  },
+  {
+    name: RUN_LANE_LABEL,
+    color: "0e8a16",
+    description: "Judged safe to run beside others in a backlogrun"
+  },
+  {
+    name: PRIORITY_HIGH_LABEL,
+    color: "e99695",
+    description: "Offered first in a backlogrun; only a person removes it"
+  },
+  {
+    name: RELEASE_LABEL,
+    color: "fef2c0",
+    description: "Tracks the next release; its blockers are the merged work it publishes"
+  },
+  ...FILING_ROUTE_LABELS,
+  ...DEPTH_LABELS
+];
+var BUGFIX_LABEL = "bugfix";
+var OTHER_CHANGE_LABEL = "other-change";
+var IGNORE_FOR_RELEASE_LABEL = "ignore-for-release";
+var RELEASE_CLASSIFICATION_NAMES = [
+  BREAKING_CHANGE_LABEL,
+  ENHANCEMENT_LABEL,
+  BUGFIX_LABEL,
+  OTHER_CHANGE_LABEL,
+  IGNORE_FOR_RELEASE_LABEL
+];
+var RELEASE_CLASSIFICATION_METADATA = {
+  [BREAKING_CHANGE_LABEL]: { color: "d93f0b", description: "Release: a breaking change (major)" },
+  [ENHANCEMENT_LABEL]: { color: "84b6eb", description: "Release: a new feature (minor)" },
+  [BUGFIX_LABEL]: { color: "d73a4a", description: "Release: a bug fix (patch)" },
+  [OTHER_CHANGE_LABEL]: { color: "c2e0c6", description: "Release: any other change (patch)" },
+  [IGNORE_FOR_RELEASE_LABEL]: { color: "cfd3d7", description: "Release: left out of the notes" }
+};
+var RELEASE_CLASSIFICATION_LABELS = RELEASE_CLASSIFICATION_NAMES.map((name) => ({ name, ...RELEASE_CLASSIFICATION_METADATA[name] }));
+var REPOSITORY_LABELS = [
+  ...WORKFLOW_LABELS,
+  ...RELEASE_CLASSIFICATION_LABELS
+];
+function has_any_label(labels, wanted) {
+  return (labels ?? []).some((label) => wanted.has(label.name.toLowerCase()));
+}
+function label_name_of(labels, wanted) {
+  const target = wanted.toLowerCase();
+  return labels.find((label) => label.toLowerCase() === target);
+}
+function has_label_name(labels, wanted) {
+  return label_name_of(labels, wanted) !== void 0;
+}
+
+// scripts/rules/lane-park.ts
+var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
+var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
+function is_confirmation_notify(command) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
+  );
+}
+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(text2) {
+  if (text2.includes(COMMAND_NOTIFY_MARKER)) return true;
+  return NOTIFY_INVOCATION.test(text2) && CONFIRMATION_TASK_TYPE.test(text2);
+}
+function is_parking_child(directory = process.cwd()) {
+  return lane_child_marker.is_child_of(directory) && !lane_handoff.is_handed_off(directory);
+}
+function is_unparked_stop(command, is_child = is_parking_child) {
+  if (!is_confirmation_notify(command)) return false;
+  return is_child();
+}
+var APPLIES_NEEDS_DECISION = new RegExp(
+  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
+  "u"
+);
+function records_the_park(command) {
+  return APPLIES_NEEDS_DECISION.test(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 ROW3 = {
+  id: "lane-park",
+  is_trigger: bash_triggers.on_bash_command(is_unparked_stop),
+  reason: LANE_PARK_REASON,
+  keeps: bash_triggers.on_bash_command(records_the_park)
+};
+var lane_park = {
+  COMMAND_NOTIFY_MARKER,
+  LANE_PARK_REASON,
+  ROW: ROW3,
+  is_confirmation_notify,
+  is_parking_child,
+  is_unparked_stop,
+  mentions_confirmation_notify,
+  records_the_park
+};
+
+// scripts/discovery/repo-party.ts
+var FIRST_PARTY = "first-party";
+var THIRD_PARTY = "third-party";
+var UNKNOWN = "unknown";
+var GH_REPO_ENV_KEY = "GH_REPO";
+var GH_REPO_PATH_SEGMENTS = 2;
+function classify3(session_owner2, target) {
+  if (session_owner2 === void 0 || target === void 0) return UNKNOWN;
+  return session_owner2.toLowerCase() === target.toLowerCase() ? FIRST_PARTY : THIRD_PARTY;
+}
+function target_owner(owner_repo) {
+  return repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${owner_repo}`)?.owner;
+}
+function current_owner(repository_path = process.cwd()) {
+  return repo_discovery.resolve_current_owner(repository_path);
+}
+function gh_repo_owners(gh_repo) {
+  return [target_owner(gh_repo.split("/").slice(-GH_REPO_PATH_SEGMENTS).join("/"))];
+}
+function remote_owners(repository_path) {
+  return repo_discovery.read_remote_urls(repository_path).map((url) => repo_origin.parse_origin_url(url)?.owner);
+}
+function placeholder_owners(repository_path = process.cwd(), environment = process.env) {
+  const gh_repo = environment[GH_REPO_ENV_KEY];
+  return gh_repo === void 0 || gh_repo === "" ? remote_owners(repository_path) : gh_repo_owners(gh_repo);
+}
+var repo_party = {
+  FIRST_PARTY,
+  THIRD_PARTY,
+  UNKNOWN,
+  classify: classify3,
+  current_owner,
+  placeholder_owners,
+  target_owner
+};
+
+// scripts/gh/git-gh-api-path.ts
+var FULL_PAGE_QUERY = "?per_page=100";
+function repo_api_path(repo = "{owner}/{repo}") {
+  return `repos/${repo}`;
+}
+function issues_api_path(repo) {
+  return `${repo_api_path(repo)}/issues`;
+}
+function issue_api_path(issue_number, repo) {
+  return `${issues_api_path(repo)}/${issue_number}`;
+}
+function blocked_by_api_path(issue_number, repo) {
+  return `${issue_api_path(issue_number, repo)}/dependencies/blocked_by`;
+}
+function issue_comments_api_path(issue_number, repo) {
+  return `${issue_api_path(issue_number, repo)}/comments`;
+}
+function pulls_api_path(repo) {
+  return `${repo_api_path(repo)}/pulls`;
+}
+function pull_api_path(pr_number, repo) {
+  return `${pulls_api_path(repo)}/${pr_number}`;
+}
+function pull_merge_api_path(pr_number, repo) {
+  return `${pull_api_path(pr_number, repo)}/merge`;
+}
+function pull_comments_api_path(pr_number, repo) {
+  return `${pull_api_path(pr_number, repo)}/comments`;
+}
+function pull_reviews_api_path(pr_number, repo) {
+  return `${pull_api_path(pr_number, repo)}/reviews`;
+}
+function commit_api_path(commit_sha, repo) {
+  return `${repo_api_path(repo)}/commits/${commit_sha}`;
+}
+function commit_check_runs_api_path(commit_sha, repo) {
+  return `${commit_api_path(commit_sha, repo)}/check-runs`;
+}
+function commit_status_api_path(commit_sha, repo) {
+  return `${commit_api_path(commit_sha, repo)}/status`;
+}
+function tag_reference_api_path(tag, repo) {
+  return `${repo_api_path(repo)}/git/ref/tags/${tag}`;
+}
+function release_by_tag_api_path(tag, repo) {
+  return `${repo_api_path(repo)}/releases/tags/${tag}`;
+}
+var git_gh_api_path = {
+  FULL_PAGE_QUERY,
+  repo_api_path,
+  tag_ref_api_path: tag_reference_api_path,
+  release_by_tag_api_path,
+  issues_api_path,
+  issue_api_path,
+  blocked_by_api_path,
+  issue_comments_api_path,
+  pulls_api_path,
+  pull_api_path,
+  pull_merge_api_path,
+  pull_comments_api_path,
+  pull_reviews_api_path,
+  commit_api_path,
+  commit_check_runs_api_path,
+  commit_status_api_path
+};
+
+// scripts/gh/git-gh-exec.ts
+import { execa as execa2, execaSync } from "execa";
+
+// scripts/gh/git-gh-check.ts
+import { execa } from "execa";
+var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
+var gh_check = {};
+async function run_gh_check() {
+  try {
+    await execa("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
+  } catch {
+    delete gh_check.promise;
+    throw new Error(GH_NOT_INSTALLED_MSG);
+  }
+}
+async function check_gh_installed() {
+  gh_check.promise ??= run_gh_check();
+  await gh_check.promise;
+}
+
+// scripts/git/parse-json-array.ts
+function parse_json_loose(raw_json) {
+  return json_value.parse_or_undefined(raw_json);
+}
+function parse_json_array_or_undefined(raw_json, element_schema) {
+  const value = parse_json_loose(raw_json);
+  if (!Array.isArray(value)) return void 0;
+  return element_schema.array().parse(value);
+}
+function read_json_listing(raw_json, element_schema) {
+  try {
+    const rows = parse_json_array_or_undefined(raw_json, element_schema);
+    return rows === void 0 ? { kind: "unreadable" } : { kind: "read", rows };
+  } catch {
+    return { kind: "unexpected_shape" };
+  }
+}
+function parse_json_object_or_undefined(raw_json, schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === void 0) return void 0;
+  return schema.parse(value);
+}
+var parse_json = {
+  parse_json_object_or_undefined
+};
+
+// scripts/gh/git-gh-failure.ts
+import { z as z6 } from "zod";
+var error_document_schema = z6.object({ status: z6.union([z6.string(), z6.number()]).optional() }).catch({});
+var GH_FAILURE_FIELD = "gh_failure";
+function has_gh_failure(error) {
+  return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
+}
+function parse_response_status(stdout) {
+  const document = parse_json.parse_json_object_or_undefined(stdout, error_document_schema);
+  if (document?.status === void 0) return void 0;
+  const status = Number(document.status);
+  return Number.isSafeInteger(status) ? status : void 0;
+}
+function classify_stdout(stdout) {
+  return { status: parse_response_status(stdout) };
+}
+function attach(error, failure) {
+  Object.defineProperty(error, GH_FAILURE_FIELD, {
+    value: failure,
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+function failure_of(error) {
+  return has_gh_failure(error) ? error.gh_failure : void 0;
+}
+var gh_failure = { attach, classify_stdout, failure_of, parse_response_status };
+
+// scripts/gh/git-gh-exec.ts
+var BODY_FROM_STDIN = "-";
+var GH_REQUEST_TIMEOUT_MS = 6e4;
+function to_timeout_option(timeout_ms) {
+  return { timeout: timeout_ms ?? GH_REQUEST_TIMEOUT_MS };
+}
+function direct_environment() {
+  const removed = agent_session_environment.removed_proxy_environment();
+  return Object.keys(removed).length > 0 ? { env: removed } : {};
+}
+function to_spawn_options(timeout_ms, cwd) {
+  return {
+    ...to_timeout_option(timeout_ms),
+    ...direct_environment(),
+    ...cwd !== void 0 && { cwd }
+  };
+}
+var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
+function has_stderr_field(error) {
+  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
+}
+function has_stdout_field(error) {
+  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
+}
+function to_timeout_prefix(error) {
+  return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
+}
+function to_gh_error(error) {
+  const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
+  const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
+  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
+  const detail = stdout.length > 0 ? `${summary}
+${stdout}` : summary;
+  return gh_failure.attach(
+    new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
+    gh_failure.classify_stdout(stdout)
+  );
+}
+async function exec_gh_command(arguments_, timeout_ms, cwd) {
+  await check_gh_installed();
+  const options = to_spawn_options(timeout_ms, cwd);
+  try {
+    const { stdout } = await execa2("gh", arguments_, options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+async function exec_gh_command_with_stdin(input) {
+  await check_gh_installed();
+  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
+  try {
+    const { stdout } = await execa2("gh", input.args, options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
+function parse_status_line(output) {
+  const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
+  return status === void 0 ? void 0 : Number(status);
+}
+function status_of_failure(error) {
+  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+}
+async function exec_gh_api_status(path, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  try {
+    await check_gh_installed();
+    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return status_of_failure(error);
+  }
+}
+function exec_gh_api_status_sync(path, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  try {
+    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return status_of_failure(error);
+  }
+}
+var METHOD_FLAG = "--method";
+var INPUT_FLAG = "--input";
+var PAGINATE_FLAG = "--paginate";
+var SLURP_FLAG = "--slurp";
+var JQ_FLAG = "--jq";
+function optional_flag(flag, value) {
+  return value === void 0 ? [] : [flag, value];
+}
+function to_gh_api_args(request) {
+  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
+  const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
+  const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
+  return [
+    "api",
+    request.path,
+    ...optional_flag(METHOD_FLAG, request.method),
+    ...body_args,
+    ...paginate_args,
+    ...slurp_args,
+    ...optional_flag(JQ_FLAG, request.jq_filter)
+  ];
+}
+async function exec_gh_api(request) {
+  const args = to_gh_api_args(request);
+  if (request.body === void 0) {
+    return await exec_gh_command(args, request.timeout_ms, request.cwd);
+  }
+  return await exec_gh_command_with_stdin({
+    args,
+    stdin_body: request.body,
+    timeout_ms: request.timeout_ms,
+    cwd: request.cwd
+  });
+}
+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 } = execaSync("gh", to_gh_api_args(request), options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+function read_gh_api_sync(request) {
+  try {
+    return exec_gh_api_sync(request);
+  } catch {
+    return void 0;
+  }
+}
+var git_gh_exec = {
+  direct_environment,
+  exec_gh_command,
+  exec_gh_command_with_stdin,
+  exec_gh_api,
+  exec_gh_api_sync,
+  read_gh_api_sync,
+  exec_gh_api_status,
+  exec_gh_api_status_sync,
+  parse_status_line
+};
+
+// 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/gh/git-gh-issue-rest.ts
+import { z as z7 } 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 = z7.looseObject({
+  number: z7.number(),
+  issue_dependencies_summary: z7.looseObject({ total_blocked_by: z7.number().optional() }).nullish(),
+  // Present only on a pull request, which this endpoint serves as readily as an issue.
+  pull_request: z7.looseObject({ merged_at: z7.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"],
+  ["closedAt", "closed_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_or_undefined(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 issue2 = await read_issue_fields(issue_number, fields, repo);
+    return { kind: "read", json: JSON.stringify(issue2) };
+  } catch (error) {
+    return to_read_failure(error);
+  }
+}
+async function issue_view_field_classified(issue_number, field, repo) {
+  try {
+    const issue2 = await read_issue_fields(issue_number, field, repo);
+    return { kind: "read", text: git_gh_issue_rest.to_field_text(issue2[field]) };
+  } catch (error) {
+    return to_read_failure(error);
+  }
+}
+async function issue_view_field(issue_number, field, repo) {
+  const read = await issue_view_field_classified(issue_number, field, repo);
+  return read.kind === "read" ? read.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 read = await issue_view_json_classified(issue_number, fields, repo);
+  return read.kind === "read" ? read.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 path = `${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, 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 path = listing_path(request, page);
+  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path }));
+  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 LABEL_NAMES_FILTER = ".[].name";
+var LABELS_SEGMENT = "/labels";
+var COMMENTS_SEGMENT = "/comments";
+var CLOSED_STATE = "closed";
+var COLOR_HASH = "#";
+var UNPROCESSABLE_STATUS = 422;
+var ALREADY_EXISTS_CODE = "already_exists";
+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;
+}
+function is_label_already_exists(error) {
+  if (gh_failure.failure_of(error)?.status !== UNPROCESSABLE_STATUS) return false;
+  return error_text.message_of(error).includes(ALREADY_EXISTS_CODE);
+}
+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 (error) {
+    if (is_label_already_exists(error)) return;
+    const [gist = ""] = error_text.message_of(error).split("\n", 1);
+    console.warn(`\u26A0 could not create the \`${input.name}\` label \u2014 ${gist}`);
+  }
+}
+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 read_label_names(issue_number) {
+  try {
+    const raw = await git_gh_exec.exec_gh_api({
+      path: `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`,
+      should_paginate: true,
+      jq_filter: LABEL_NAMES_FILTER
+    });
+    return raw.split("\n").map((name) => name.trim());
+  } catch (error) {
+    error_text.trace_swallowed("git_gh_issue_write.read_label_names", error);
+    return void 0;
+  }
+}
+async function issue_apply_label(issue_number, label) {
+  const labels_path = `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`;
+  try {
+    await git_gh_exec.exec_gh_api({ path: labels_path, body: JSON.stringify({ labels: [label] }) });
+    return { is_applied: true };
+  } catch (error) {
+    const names = await read_label_names(issue_number);
+    if (names?.includes(label) === true) return { is_applied: true };
+    error_text.trace_swallowed("git_gh_issue_write.issue_apply_label", error);
+    const [gist = ""] = error_text.message_of(error).split("\n", 1);
+    return { is_applied: false, reason: gist };
+  }
+}
+async function issue_add_label(issue_number, label) {
+  const write = await issue_apply_label(issue_number, label);
+  return write.is_applied;
+}
+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_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 ${session_cite.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_apply_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,body`;
+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 readFileSync2 } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { z as z8 } 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 = z8.object({ name: z8.string() });
+var USER = z8.object({ login: z8.string() });
+var PULL_REQUEST = z8.object({ number: z8.number(), user: USER });
+var EVENT = z8.object({
+  pull_request: PULL_REQUEST,
+  repository: z8.object({ full_name: z8.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 issue2 = z8.object({ labels: z8.array(LABEL), body: z8.string().nullable() }).parse(JSON.parse(issue_json));
+  const names = issue2.labels.map((label) => label.name.toLowerCase());
+  const declared = [...(issue2.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 path = `repos/${repository}/issues/${String(pull_number)}/labels`;
+  try {
+    const names = git_gh_exec.exec_gh_api_sync({ path, 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(readFileSync2(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] === fileURLToPath(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 sleep2(duration_ms) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, 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 ?? sleep2;
+  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: sleep2 };
+
+// scripts/gh/git-gh-pr.ts
+import { z as z12 } from "zod";
+
+// scripts/gh/git-gh-pr-rest.ts
+import { z as z9 } from "zod";
+var rest_repo_schema = z9.looseObject({ full_name: z9.string().optional() }).nullish();
+var rest_pull_side_schema = z9.looseObject({ repo: rest_repo_schema });
+var rest_pull_schema = z9.looseObject({
+  number: z9.number(),
+  html_url: z9.string().optional(),
+  body: z9.string().nullish(),
+  state: z9.string().optional(),
+  merged: z9.boolean().nullish(),
+  merged_at: z9.string().nullish(),
+  mergeable: z9.boolean().nullish(),
+  mergeable_state: z9.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.
+  head: z9.looseObject({ ref: z9.string().optional(), sha: z9.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`.
+  node_id: z9.string().optional(),
+  auto_merge: z9.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_or_undefined(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();
+var pull_by_number = /* @__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();
+  pull_by_number.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 read = await read_pr_number(branch_name);
+  return read.kind === "read" ? read.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 read = await read_pr_number(branch_name);
+  if (read.kind === "read") return read.pr_number;
+  if (read.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
+  throw to_unreadable_error(branch_name, read.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_remembered_pull(pr_number) {
+  const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number);
+  pull_by_number.set(pr_number, pending);
+  try {
+    return await pending;
+  } catch (error) {
+    if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number);
+    throw error;
+  }
+}
+async function read_pull_of_branch(branch_name, read = read_remembered_pull) {
+  const number_read = await read_pr_number(branch_name);
+  if (number_read.kind !== "read") return number_read;
+  try {
+    return { kind: "read", pull: await read(number_read.pr_number) };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+async function read_pull_or_undefined(branch_name) {
+  const read = await read_pull_of_branch(branch_name);
+  return read.kind === "read" ? read.pull : void 0;
+}
+async function pr_exists(branch_name) {
+  const read = await read_pr_number(branch_name);
+  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
+  return read.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_or_undefined(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 read = await read_pull_of_branch(branch_name, read_pull);
+  if (read.kind !== "read") return void 0;
+  const { pull } = read;
+  return {
+    is_merged: git_gh_pr_rest.is_merged(pull),
+    merged_at: pull.merged_at ?? void 0,
+    head_sha: pull.head?.sha,
+    merge_state_status: to_gh_state(pull.mergeable_state)
+  };
+}
+async function pr_get_body(branch_name) {
+  const pull = await read_pull_or_undefined(branch_name);
+  const body = pull?.body;
+  return typeof body === "string" && body.length > 0 ? body : void 0;
+}
+async function pr_view(branch_name) {
+  const read = await read_pull_of_branch(branch_name, read_pull);
+  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
+  if (read.kind === "missing") return "";
+  return JSON.stringify(git_gh_pr_rest.to_pr_info(read.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 path = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
+  try {
+    return to_json(await git_gh_exec.exec_gh_api({ path, 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 z10 } 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 = z10.looseObject({
+  state: z10.string().optional(),
+  user: z10.looseObject({ login: z10.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 z11 } from "zod";
+var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
+var TYPE_NAME_KEY = "__typename";
+var rollup_element_schema = z11.looseObject({});
+var check_runs_page_schema = z11.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: z11.array(rollup_element_schema)
+});
+var id_holder_schema = z11.object({ id: z11.number() });
+var status_page_schema = z11.looseObject({
+  statuses: z11.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(run) {
+  const { name, app } = run;
+  if (typeof name !== "string") return void 0;
+  return JSON.stringify([name, read_id(app)]);
+}
+function read_rank(run) {
+  const id = read_id(run);
+  if (id === void 0) return void 0;
+  return { suite: read_id(run["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(run, newest) {
+  const key2 = check_run_group_key(run);
+  const rank = read_rank(run);
+  if (key2 === void 0 || rank === void 0) return;
+  if (should_replace(newest.get(key2), rank)) newest.set(key2, run);
+}
+function is_newest_run(run, newest) {
+  const key2 = check_run_group_key(run);
+  if (key2 === void 0 || read_rank(run) === void 0) return true;
+  return newest.get(key2) === run;
+}
+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 run of runs) remember_newest_run(run, newest);
+  return runs.filter((run) => is_newest_run(run, 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(path) {
+  return await git_gh_exec.exec_gh_api({
+    path: `${path}${FULL_PAGE_QUERY}`,
+    should_paginate: true,
+    should_slurp: true
+  });
+}
+async function read_array_pages(path) {
+  return await git_gh_exec.exec_gh_api({
+    path: `${path}${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 path = git_gh_api_path.pull_reviews_api_path(String(pr_number));
+  return git_gh_pr_review.to_review_decision(await read_array_pages(path));
+}
+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 = z12.array(z12.object({ name: z12.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);
+  forget_pr_numbers();
+  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) {
+  forget_pr_numbers();
+  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.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;
+}
+function should_always_read_review_decision() {
+  return 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 failure_error(message, snapshot) {
+  return is_merge_conflict(snapshot.merge_state_status) ? new PrConflictError(message) : new Error(message);
+}
+function classify_poll_result(input) {
+  const state = input.evaluator.evaluate(input.snapshot);
+  if (state === "failure") {
+    throw failure_error(input.evaluator.describe(input.snapshot), 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 read = await read_pr_state(input, evaluator);
+  if (read.kind === "unreadable") return await retry_after_unreadable(input, read.cause);
+  const classification = classify_poll_result({
+    snapshot: read.snapshot,
+    stable_count: input.stable_count,
+    required_stable_reads: input.options.required_stable_reads,
+    evaluator
+  });
+  if (classification.is_done) {
+    return { snapshot: read.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(", ")}`;
+}
+function should_never_read_review_decision() {
+  return 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,
+  run_event_stream,
+  run_event_scope,
+  run_event_stream_emit,
+  shell_segments,
+  bash_triggers,
+  tail_commands,
+  filing_cap,
+  CONTEXT_CUT_THRESHOLD,
+  issue_citation,
+  session_cite,
+  run_hold,
+  run_cut_handoff,
+  run_cut,
+  run_tail_rule,
+  lane_background,
+  IN_PROGRESS_LABEL,
+  NEEDS_DECISION_LABEL,
+  RUN_SOLO_LABEL,
+  RUN_LANE_LABEL,
+  NEEDS_HUMAN_REVIEW_LABEL,
+  ALREADY_DONE_LABEL,
+  has_any_label,
+  has_label_name,
+  lane_handoff,
+  lane_park,
+  repo_party,
+  git_gh_api_path,
+  read_json_listing,
+  parse_json_object_or_undefined,
+  git_gh_exec,
+  git_gh_issue_read,
+  git_gh_pr_read,
+  git_gh_command
+};