@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/hooks/chunk-SYOTDYCI.js

@@ -1,3533 +0,0 @@
-import {
-  FULL_PAGE_QUERY,
-  MERGED_STATE,
-  detached_launch,
-  forget_pr_numbers,
-  gh_failure,
-  git_common_directory,
-  git_gh_api_path,
-  git_gh_exec,
-  git_gh_helpers,
-  git_gh_pr_read,
-  git_gh_pr_rest,
-  issue_cite,
-  lane_child_invocation,
-  parse_json_array_or_undefined,
-  parse_json_object_or_undefined,
-  read_json_listing,
-  read_pull,
-  repo_discovery,
-  repo_origin,
-  require_pr_number,
-  run_event_stream,
-  run_event_stream_emit,
-  run_hold,
-  session_cite,
-  stamp_record,
-  to_gh_state
-} from "./chunk-WK6SMBIC.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  agent_role_profile,
-  agent_session_role
-} from "./chunk-UPUZF3AN.js";
-import {
-  CHECK_STATUS_FAIL,
-  CHECK_STATUS_PENDING,
-  PrConflictError,
-  cost_attribute,
-  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,
-  time_density_hook,
-  time_shell,
-  time_transcript_line
-} from "./chunk-TNUMY6NL.js";
-import {
-  lane_child_marker
-} from "./chunk-LAOV7NLM.js";
-import {
-  backlog_budget,
-  blocking_issue_schema,
-  cli_flags,
-  cost_transcript,
-  cost_usage,
-  git_command,
-  issue_number_shape,
-  json_value,
-  lane_paths,
-  own_session,
-  process_identity
-} from "./chunk-APUO6U4J.js";
-import {
-  PLATFORM_TEMP_ROOT,
-  PROJECT_ROOT,
-  stamp_file
-} from "./chunk-DGT54IH5.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/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));
-}
-function answered(text, is_call, token) {
-  const blocks = time_transcript_line.parse_text(text).flatMap((line) => line.blocks);
-  const call_ids = new Set(
-    blocks.filter((block) => is_call(time_shell.bash_command(block.input))).map((block) => block.id)
-  );
-  return blocks.some((block) => call_ids.has(block.result_id) && block.token_lines.includes(token));
-}
-var tail_commands = { answered, is_bash_use, prior_bash_commands };
-
-// scripts/rules/shell-segments.ts
-var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
-var SEGMENT_PARTS = new RegExp(`(${SEGMENT_SEPARATOR.source})`, "u");
-function segments_of(command) {
-  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
-}
-function parts_of(command) {
-  return command.split(SEGMENT_PARTS);
-}
-function first_of(command) {
-  const plain = time_shell.blanked(command);
-  if (plain === void 0) return void 0;
-  const cut = plain.search(SEGMENT_SEPARATOR);
-  return (cut === -1 ? command : command.slice(0, cut)).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 = {
-  first_of,
-  is_josh_command,
-  parts_of,
-  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/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, run2) {
-  return prior_filing_count(time_density_hook.read_tail(run2.transcript)) >= CAP_REACHED;
-}
-var FILING_CAP_REASON = `\u26D4 filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling. Stop filing and report; a further Issue is a person's call. It fires on every occurrence (\`.claude/skills/workflow-commands/observation-filing.md\`).`;
-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,
-  current_turn,
-  is_prompt_line,
-  prior_filing_count,
-  turn_filing_count
-};
-
-// scripts/cost-runtime/cost-pricing.ts
-var CACHE_WRITE_5M_MULTIPLIER = 1.25;
-var CACHE_WRITE_1H_MULTIPLIER = 2;
-var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
-var HALVED_CACHE_READ_MULTIPLIER = 0.05;
-var QUARTERED_CACHE_READ_MULTIPLIER = 0.025;
-var TOKENS_PER_MILLION = 1e6;
-var LONG_PROMPT_SUFFIX = ":long-prompt";
-var LONG_PROMPT_THRESHOLD = 1e5;
-var MODEL_PRICES = {
-  "claude-fable-5-1": {
-    input: 10,
-    output: 50,
-    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
-  },
-  "claude-mythos-5-1": {
-    input: 10,
-    output: 50,
-    cache_read_multiplier: QUARTERED_CACHE_READ_MULTIPLIER
-  },
-  "claude-fable-5": { input: 10, output: 50 },
-  "claude-mythos-5": { input: 10, output: 50 },
-  "claude-opus-5-5": { input: 4, output: 20, cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER },
-  "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-5": {
-    input: 2,
-    output: 10,
-    cache_read_multiplier: HALVED_CACHE_READ_MULTIPLIER
-  },
-  "claude-sonnet-5": { input: 2, output: 10 },
-  "claude-sonnet-4-6": { input: 3, output: 15 },
-  "claude-haiku-5-5": { input: 0.1, output: 0.5 },
-  [`claude-haiku-5-5${LONG_PROMPT_SUFFIX}`]: { input: 0.5, output: 2.5 },
-  "claude-haiku-4-5": { input: 1, output: 5 }
-};
-var CONTEXT_MARKER = "[";
-var DATE_SUFFIX = /-\d{8}$/u;
-function known_id(model) {
-  const base = model.split(CONTEXT_MARKER)[0] ?? model;
-  return [base, base.replace(DATE_SUFFIX, "")].find((id) => Object.hasOwn(MODEL_PRICES, id));
-}
-function resolve_price(model) {
-  const id = known_id(model);
-  return id === void 0 ? void 0 : MODEL_PRICES[id];
-}
-function cache_read_multiplier(price) {
-  return price.cache_read_multiplier ?? DEFAULT_CACHE_READ_MULTIPLIER;
-}
-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(price);
-  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), 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 billed_model(usage) {
-  const long_id = `${known_id(usage.model) ?? usage.model}${LONG_PROMPT_SUFFIX}`;
-  const is_long = cost_usage.billed_input(usage.totals) > LONG_PROMPT_THRESHOLD;
-  return is_long && Object.hasOwn(MODEL_PRICES, long_id) ? long_id : usage.model;
-}
-function cost_by_model(records) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const model = billed_model(record);
-    const running = grouped.get(model) ?? cost_usage.EMPTY_TOTALS;
-    grouped.set(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,
-  DEFAULT_CACHE_READ_MULTIPLIER,
-  LONG_PROMPT_THRESHOLD,
-  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.DEFAULT_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 z2 } from "zod";
-
-// scripts/run/cut/run-cut-handoff.ts
-import { readFileSync } from "node:fs";
-import { z } from "zod";
-var handoff_schema = z.object({
-  instruction: z.string(),
-  completed: z.array(z.string()),
-  remaining: z.array(z.string()),
-  untouched: z.array(z.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 z.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.DEFAULT_IDLE_MS;
-var CUT_MAX_AGE_HOURS = backlog_budget.IDLE_WAIT_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 = z2.object({
-  invocation: z2.string(),
-  issue: z2.string(),
-  branch: z2.string(),
-  phase: z2.string(),
-  cut_at: z2.string(),
-  is_handed_off: z2.boolean().optional(),
-  handoff: run_cut_handoff.handoff_schema.optional(),
-  is_merge_relaunched: z2.boolean().optional()
-});
-function cut_path(git_directory) {
-  return stamp_file.stamp_path(CUT_PREFIX, git_directory);
-}
-var { worktree_directory } = run_hold;
-function invocation_for(issue) {
-  return lane_child_invocation.child_invocation(issue);
-}
-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_expired(cut, now) {
-  return stamp_record.is_older_than(cut_at_of(cut), CUT_MAX_AGE_MS, now);
-}
-function classify(raw, now) {
-  const read2 = stamp_record.classify(raw, CUT_SPEC, now);
-  if (!("record" in read2)) return read2;
-  return { kind: read2.kind, cut: read2.record };
-}
-function read_cut(target, now = /* @__PURE__ */ new Date()) {
-  return classify(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 read2 = read_cut(cut_path(directory), now);
-  return read2.kind === "carried" ? read2.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, issue) {
-  return cut.is_handed_off === true && cut.invocation === invocation_for(issue);
-}
-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, issue) {
-  return cut.is_handed_off === false && cut.invocation === invocation_for(issue);
-}
-function has_required_handoff(cut) {
-  return !resumes_into_implementation(cut.phase) || run_cut_handoff.is_complete_handoff(cut.handoff);
-}
-function is_relaunchable(cut, issue) {
-  return is_declared_cut(cut, issue) && 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 read2 = run_hold.read_hold(run_hold.hold_path(directory));
-  return read2.kind === "held" || read2.kind === "stale" ? read2.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_directory());
-  return {
-    branch,
-    is_dirty,
-    is_held: hold !== void 0,
-    held_issue: fullrun_issue(hold),
-    hold_taken_at: hold?.taken_at
-  };
-}
-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_message(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_message() {
-  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_message() {
-  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,
-  classify_resume,
-  current_state,
-  cut_path,
-  describe_cut,
-  end_cut,
-  fresh_cut,
-  fullrun_issue,
-  handed_off_message,
-  has_required_handoff,
-  held_issue_sync,
-  hold_of,
-  incomplete_message,
-  invocation_for,
-  is_expired,
-  is_relaunchable,
-  lane_cut_sync,
-  mark_merge_relaunched,
-  read_cut,
-  record_within_bound,
-  resumes_into_implementation,
-  stale_message,
-  unknown_message,
-  unreadable_message,
-  within_handoff_bound,
-  worktree_directory,
-  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; when it exits, go straight on to `pnpm josh followup` in the foreground \u2014 the turn never ends at the push (`.claude/skills/workflow-commands/background-commands.md`). It fires on every foreground push, not once per run.";
-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) || !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`.";
-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 process whose background tasks die when the turn ends. Hand over to `pnpm josh ship --detach --review "<title> #<N>"`, issued in the foreground, then end the turn on `launched` / `busy`. It fires on every occurrence (`.claude/skills/workflow-commands/chain-rule.md` step 0).';
-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, and ending this turn kills it. Wait for it in the foreground, or re-issue the work through `pnpm josh ship --detach` \u2014 do not notify, stop or repeat your 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";
-import { z as z3 } 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 = z3.object({
-  pid: z3.number().int().positive().optional(),
-  process_start: z3.string().optional(),
-  launched_at: z3.number().optional(),
-  launcher_pid: z3.number().int().positive().optional(),
-  launcher_start: z3.string().optional(),
-  launch_id: z3.string(),
-  result: z3.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 running_since(repository, number) {
-  const record = read_record(repository, number);
-  return record !== void 0 && result_of(record) === "running" ? record.launched_at : 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(text) {
-  const mark = text.lastIndexOf(LAUNCH_MARK);
-  if (mark === -1) return text;
-  return text.slice(text.lastIndexOf(HEADER_START, mark) + HEADER_START.length);
-}
-function read_log(repository, number) {
-  const text = stamp_file.read_stamp_text(log_path(repository, number));
-  return text === void 0 ? void 0 : last_launch(text);
-}
-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,
-  running_since,
-  supervisor_argv
-};
-
-// scripts/lane/lane-handoff.ts
-function is_ship_running(issue, directory) {
-  const repository = git_common_directory.repository(directory);
-  return repository !== void 0 && run_ship_detach.read_result(repository, issue)?.result === "running";
-}
-function ship_running_since(issue, directory) {
-  const repository = git_common_directory.repository(directory);
-  return repository === void 0 ? void 0 : run_ship_detach.running_since(repository, issue);
-}
-function is_handed_off(directory, source = process.env) {
-  const issue = lane_child_marker.marked_issue(source);
-  if (issue === void 0 || !lane_child_marker.is_child_of(directory, source)) return false;
-  return is_ship_running(issue, directory);
-}
-var lane_handoff = { is_handed_off, is_ship_running, ship_running_since };
-
-// scripts/issue/issue-labels.ts
-var EPIC_LABEL = "epic";
-var BUG_LABEL = "bug";
-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 AUTO_OK_LABEL = "auto-ok";
-var NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
-var ALREADY_DONE_LABEL = "already-done";
-var RELEASE_LABEL = "release";
-var REVIEW_ROUND2_SKIPPED_LABEL = "review-round2-skipped";
-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"
-  },
-  {
-    name: AUTO_OK_LABEL,
-    color: "0e8a16",
-    description: "Opted in to unattended execution outside an epic"
-  },
-  {
-    name: NEEDS_DECISION_LABEL,
-    color: "d93f0b",
-    description: "Parked: needs a decision before it can run"
-  },
-  {
-    name: NEEDS_HUMAN_REVIEW_LABEL,
-    color: "d93f0b",
-    description: "Implement and verify, but stop before committing so a person can look"
-  },
-  {
-    name: ALREADY_DONE_LABEL,
-    color: "6f42c1",
-    description: "Verified already merged \u2014 a person closes it"
-  },
-  {
-    name: REVIEW_ROUND2_SKIPPED_LABEL,
-    color: "c5def5",
-    description: "Review round 2 was skipped under the condition in prompts/review.md"
-  },
-  { name: BUG_LABEL, color: "d73a4a", description: "Something isn't working" },
-  ...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(text) {
-  if (text.includes(COMMAND_NOTIFY_MARKER)) return true;
-  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
-}
-function is_parking_child(directory = process.cwd()) {
-  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, so a stop for a person parks first: `gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'`; `pnpm josh issue:comment <N> --body-file <path>` (question, options, stash); a `needs-human-review` / `already-done` stop already is. Reissue this notify, once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
-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/cost-runtime/cost-cli.ts
-import { fileURLToPath } from "node:url";
-
-// scripts/cost-runtime/codex-usage.ts
-import { globSync, readFileSync as readFileSync2 } from "node:fs";
-import path from "node:path";
-import { z as z4 } from "zod";
-var THREAD_ID_PATTERN = /^[A-Za-z0-9-]+$/u;
-var SESSION_META_SCHEMA = z4.looseObject({
-  type: z4.literal("session_meta"),
-  payload: z4.looseObject({ id: z4.string(), cwd: z4.string() })
-});
-var TOTAL_USAGE_SCHEMA = z4.looseObject({ input_tokens: z4.number().nonnegative() });
-var TOKEN_COUNT_SCHEMA = z4.looseObject({
-  type: z4.literal("event_msg"),
-  payload: z4.looseObject({
-    type: z4.literal("token_count"),
-    info: z4.looseObject({
-      total_token_usage: TOTAL_USAGE_SCHEMA,
-      last_token_usage: TOTAL_USAGE_SCHEMA
-    })
-  })
-});
-function same_project(cwd, target) {
-  return cost_transcript.session_cwd(cwd) === cost_transcript.session_cwd(target);
-}
-function billed_per_request(usages) {
-  return usages.map((usage) => usage.last_token_usage.input_tokens);
-}
-function measurement_from(content, target, thread_id) {
-  const values = content.split("\n").map((line) => json_value.parse_or_undefined(line));
-  const metadata = values.flatMap((value) => {
-    const parsed = SESSION_META_SCHEMA.safeParse(value);
-    return parsed.success ? [parsed.data] : [];
-  });
-  const usages = values.flatMap((value) => {
-    const parsed = TOKEN_COUNT_SCHEMA.safeParse(value);
-    return parsed.success ? [parsed.data.payload.info] : [];
-  });
-  const session = metadata.find((entry) => entry.payload.id === thread_id);
-  if (session === void 0 || usages.length === 0 || !same_project(session.payload.cwd, target)) {
-    return void 0;
-  }
-  return { billed_input_per_request: billed_per_request(usages) };
-}
-function rollout_files(home, thread_id) {
-  if (!THREAD_ID_PATTERN.test(thread_id)) return [];
-  return globSync(`sessions/**/*${thread_id}.jsonl`, { cwd: home }).map(
-    (file) => path.join(home, file)
-  );
-}
-function read_measurement(file, target, thread_id) {
-  try {
-    return measurement_from(readFileSync2(file, "utf8"), target, thread_id);
-  } catch {
-    return void 0;
-  }
-}
-function latest_measurement(files, target, thread_id) {
-  for (const file of files.toReversed()) {
-    const measured = read_measurement(file, target, thread_id);
-    if (measured !== void 0) return measured;
-  }
-  return void 0;
-}
-function measurement(target, default_home, environment = process.env) {
-  const thread_id = environment["CODEX_THREAD_ID"];
-  if (thread_id === void 0) return void 0;
-  const home = environment["CODEX_HOME"] ?? path.join(default_home, ".codex");
-  return latest_measurement(rollout_files(home, thread_id), target, thread_id);
-}
-var codex_usage = { measurement };
-
-// scripts/cost-runtime/cost-corpus.ts
-function accumulate_missing(sessions) {
-  return {
-    no_usage_lines: sessions.reduce((sum, session) => sum + session.no_usage_lines, 0),
-    malformed_lines: sessions.reduce((sum, session) => sum + session.malformed_lines, 0),
-    unreadable_sessions: sessions.filter((session) => !session.is_readable).length,
-    // Filled by the attribution, which is the only step that knows a unit could not follow its
-    // parent; a per-session tally cannot see it, so it is zero here and set for an issue scope below.
-    unattributed_sessions: 0
-  };
-}
-function load_corpus(cwd) {
-  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(cwd));
-  const sessions = files.map((file) => cost_transcript.read_session(file));
-  return { sessions, files, missing: accumulate_missing(sessions) };
-}
-function session_meta(corpus) {
-  return new Map(
-    corpus.files.map((file) => [
-      file.session_id,
-      { is_delegated: file.is_delegated, owner: cost_transcript.owning_session_id(file) }
-    ])
-  );
-}
-function issue_set(records) {
-  const issues = cost_attribute.group_by_issue(records).map((group) => group.issue).filter((issue) => issue !== cost_attribute.UNATTRIBUTED_KEY);
-  return new Set(issues);
-}
-function sole_of(issues) {
-  if (issues.size !== 1) return cost_attribute.UNATTRIBUTED_KEY;
-  return [...issues][0] ?? cost_attribute.UNATTRIBUTED_KEY;
-}
-function owner_sets(corpus, meta) {
-  const own = corpus.sessions.filter(
-    (session) => meta.get(session.session_id)?.is_delegated !== true
-  );
-  return new Map(own.map((session) => [session.session_id, issue_set(session.records)]));
-}
-function pairs_with_inherited(session, inherited, is_delegated) {
-  return cost_attribute.group_by_issue(session.records).flatMap(
-    (group) => group.records.map((record) => ({
-      record,
-      issue: group.issue === cost_attribute.UNATTRIBUTED_KEY ? inherited : group.issue,
-      baseline_tokens: session.baseline_tokens,
-      session_id: session.session_id,
-      is_delegated
-    }))
-  );
-}
-var NO_ISSUES = /* @__PURE__ */ new Set();
-function parent_issues(session, meta, owners) {
-  const entry = meta.get(session.session_id);
-  if (entry?.is_delegated !== true) return NO_ISSUES;
-  return owners.get(entry.owner) ?? NO_ISSUES;
-}
-function pairs_of_session(session, meta, owners) {
-  const is_delegated = meta.get(session.session_id)?.is_delegated === true;
-  const candidates = parent_issues(session, meta, owners);
-  const inherited = is_delegated ? sole_of(candidates) : cost_attribute.UNATTRIBUTED_KEY;
-  const pairs = pairs_with_inherited(session, inherited, is_delegated);
-  const has_unattributed = pairs.some((pair) => pair.issue === cost_attribute.UNATTRIBUTED_KEY);
-  if (!is_delegated || !has_unattributed) return { pairs };
-  return { pairs, unattributed_candidates: candidates };
-}
-function attribute_corpus(corpus) {
-  const meta = session_meta(corpus);
-  const owners = owner_sets(corpus, meta);
-  const per_session = corpus.sessions.map((session) => pairs_of_session(session, meta, owners));
-  return {
-    pairs: per_session.flatMap((one) => one.pairs),
-    unattributed: per_session.flatMap(
-      (one) => one.unattributed_candidates === void 0 ? [] : [one.unattributed_candidates]
-    )
-  };
-}
-function floor_for_issue(unattributed, issue_number) {
-  return unattributed.filter((set) => set.size === 0 || set.has(issue_number)).length;
-}
-function is_better(candidate, existing) {
-  const { UNATTRIBUTED_KEY } = cost_attribute;
-  return existing.issue === UNATTRIBUTED_KEY && candidate.issue !== UNATTRIBUTED_KEY;
-}
-function values_of(best) {
-  const collected = [];
-  for (const [, pair] of best) collected.push(pair);
-  return collected;
-}
-function dedupe_across_sessions(pairs) {
-  const best = /* @__PURE__ */ new Map();
-  for (const pair of pairs) {
-    const existing = best.get(pair.record.request_id);
-    if (existing === void 0 || is_better(pair, existing)) {
-      best.set(pair.record.request_id, pair);
-    }
-  }
-  return values_of(best);
-}
-function attributed(corpus) {
-  return dedupe_across_sessions(attribute_corpus(corpus).pairs);
-}
-function mainline_records(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const pair of pairs) {
-    if (pair.is_delegated) continue;
-    groups.set(pair.session_id, [...groups.get(pair.session_id) ?? [], pair.record]);
-  }
-  return [...groups.values()];
-}
-var cost_corpus = {
-  load_corpus,
-  attribute_corpus,
-  floor_for_issue,
-  attributed,
-  mainline_records
-};
-
-// scripts/cost-runtime/cost-verdict.ts
-var FAILURE_EXIT_CODE = 1;
-var OVER_VERDICT = "over";
-var UNDER_VERDICT = "under";
-function per_request_cost(measurement2) {
-  return measurement2.billed_input_per_request.at(-1) ?? 0;
-}
-function classify2(measurement2, limit) {
-  return per_request_cost(measurement2) > limit ? OVER_VERDICT : UNDER_VERDICT;
-}
-function over_summary(measurement2, limit) {
-  const total = measurement2.billed_input_per_request.length;
-  return `${String(per_request_cost(measurement2))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`;
-}
-function report_over(measurement2, limit) {
-  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
-    console.error("No requests in this session; there is nothing to hand off.");
-    return FAILURE_EXIT_CODE;
-  }
-  console.info(classify2(measurement2, limit));
-  console.error(over_summary(measurement2, limit));
-  return 0;
-}
-var cost_verdict = {
-  OVER_VERDICT,
-  UNDER_VERDICT,
-  classify: classify2,
-  per_request_cost,
-  report_over
-};
-
-// scripts/cost-runtime/transcript-cwd.ts
-import path2 from "node:path";
-function resolve(target, cwd) {
-  return target === void 0 ? cwd : path2.resolve(target);
-}
-var transcript_cwd = { resolve };
-
-// scripts/cost-runtime/cost-cli.ts
-var ARGV_OFFSET = 2;
-var FAILURE_EXIT_CODE2 = 1;
-var USAGE = "Usage: josh cost (--cut | --over <tokens-per-request>) [--path <dir>]";
-var UNMEASURABLE_VERDICT = "unmeasurable";
-function to_threshold(raw) {
-  if (raw === void 0 || raw.trim() === "") return void 0;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
-}
-function is_unparsed(raw, parsed) {
-  return parsed === void 0 && raw !== void 0;
-}
-function selected_threshold(values) {
-  if (values.cut === true) return CONTEXT_CUT_THRESHOLD;
-  return to_threshold(values.over);
-}
-function threshold_option(over) {
-  return over === void 0 ? {} : { over };
-}
-function path_option(path4) {
-  return path4 === void 0 ? {} : { path: path4 };
-}
-function to_options(values) {
-  if (values.cut === true && values.over !== void 0) return void 0;
-  const over = selected_threshold(values);
-  if (is_unparsed(values.over, over)) return void 0;
-  return { ...threshold_option(over), ...path_option(values.path) };
-}
-var PARSE_ARGS_OPTIONS = {
-  cut: { type: "boolean" },
-  over: { type: "string" },
-  path: { type: "string" }
-};
-function parse_options(argv) {
-  const values = cli_flags.values_of(argv, PARSE_ARGS_OPTIONS);
-  return values === void 0 ? void 0 : to_options(values);
-}
-function report_empty(cwd, session_id) {
-  const searched = cost_transcript.searched_directories(cost_transcript.transcript_directories(cwd));
-  for (const line of cost_transcript.missing_message(searched, session_id)) console.error(line);
-  return FAILURE_EXIT_CODE2;
-}
-function provider_of(environment) {
-  const resolved = agent_role_profile.resolve_provider(environment);
-  if (resolved.kind !== "provider" || resolved.is_default === true) return void 0;
-  return resolved.provider;
-}
-function measurement_of(session) {
-  return {
-    billed_input_per_request: session.records.map(
-      (record) => cost_usage.billed_input(record.totals)
-    )
-  };
-}
-function anthropic_own(target, environment) {
-  const corpus = cost_corpus.load_corpus(target);
-  const selection = own_session.select_own_session(corpus.files, environment);
-  if (selection.kind === "absent") return { kind: "absent", session_id: selection.session_id };
-  const session = corpus.sessions[selection.index];
-  if (session === void 0) return { kind: "empty" };
-  return { kind: "measured", measurement: measurement_of(session) };
-}
-function anthropic_measurement(target, environment) {
-  const own = anthropic_own(target, environment);
-  return own.kind === "measured" ? own.measurement : void 0;
-}
-function same_openai_project(target, cwd) {
-  return cost_transcript.session_cwd(target) === cost_transcript.session_cwd(cwd);
-}
-function reject_openai_cross_project(context, target, cwd) {
-  if (context.provider !== "openai" || context.path === void 0 || same_openai_project(target, cwd)) {
-    return false;
-  }
-  console.error(
-    "OpenAI --path cannot select a thread from another project; run josh cost in that project."
-  );
-  return true;
-}
-function measure(target, provider, environment) {
-  return provider === "openai" ? codex_usage.measurement(target, cost_transcript.home_directory(), environment) : anthropic_measurement(target, environment);
-}
-function run_over_anthropic(own, target, limit) {
-  if (own.kind === "measured") return cost_verdict.report_over(own.measurement, limit);
-  return report_empty(target, own.kind === "absent" ? own.session_id : void 0);
-}
-function run_over_codex(target, limit, environment) {
-  const measurement2 = measure(target, "openai", environment);
-  if (measurement2 !== void 0) return cost_verdict.report_over(measurement2, limit);
-  console.error(`No Codex usage found for the current OpenAI thread under ${target}.`);
-  return FAILURE_EXIT_CODE2;
-}
-function run_over(target, limit, provider, environment) {
-  if (provider === "anthropic") {
-    return run_over_anthropic(anthropic_own(target, environment), target, limit);
-  }
-  return run_over_codex(target, limit, environment);
-}
-function verdict_of(measurement2) {
-  if (measurement2 === void 0 || measurement2.billed_input_per_request.length === 0) {
-    return UNMEASURABLE_VERDICT;
-  }
-  return cost_verdict.classify(measurement2, CONTEXT_CUT_THRESHOLD);
-}
-function session_verdict(cwd = process.cwd(), environment = process.env) {
-  const provider = provider_of(environment);
-  if (provider === void 0) return UNMEASURABLE_VERDICT;
-  return verdict_of(measure(cwd, provider, environment));
-}
-function run_context(argv, environment) {
-  const options = parse_options(argv);
-  if (options?.over === void 0) return void 0;
-  const provider = provider_of(environment);
-  if (provider === void 0) return void 0;
-  return { over: options.over, path: options.path, provider };
-}
-function run(argv, cwd = process.cwd(), environment = process.env) {
-  const context = run_context(argv, environment);
-  if (context === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  const target = transcript_cwd.resolve(context.path, cwd);
-  if (reject_openai_cross_project(context, target, cwd)) return FAILURE_EXIT_CODE2;
-  return run_over(target, context.over, context.provider, environment);
-}
-function main(argv) {
-  process.exitCode = run(argv);
-}
-var cost_cli = {
-  UNMEASURABLE_VERDICT,
-  USAGE,
-  parse_options,
-  to_threshold,
-  run,
-  session_verdict
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET));
-
-// scripts/rules/pre-gate-cut.ts
-var GATE_COMMANDS = /* @__PURE__ */ new Set(["gate"]);
-var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
-var CUT_MODE_FLAG = /(?:^|\s)--(?:resume|end|json)(?:[=\s]|$)/u;
-var HOLD_COMMANDS = /* @__PURE__ */ new Set(["run:hold"]);
-var HOLD_MODE_FLAG = /(?:^|\s)--release(?:[=\s]|$)/u;
-function invokes_josh(command, names, mode_flag) {
-  return shell_segments.segments_of(command).some(
-    (segment) => shell_segments.is_josh_command(segment, names) && mode_flag?.test(segment) !== true
-  );
-}
-function runs_the_gate(command) {
-  return invokes_josh(command, GATE_COMMANDS);
-}
-function takes_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS, CUT_MODE_FLAG);
-}
-function claims_the_hold(command) {
-  return invokes_josh(command, HOLD_COMMANDS, HOLD_MODE_FLAG);
-}
-function asks_about_the_cut(command) {
-  return invokes_josh(command, CUT_COMMANDS);
-}
-function current_state2() {
-  return {
-    directory: process.cwd(),
-    carried: run_cut.carried_cut_sync,
-    marked_issue: lane_child_marker.marked_issue(),
-    is_reviewer: agent_session_role.is_reviewer(),
-    context_verdict: cost_cli.session_verdict
-  };
-}
-function dispatched_issue(state) {
-  return state.is_reviewer ? void 0 : state.marked_issue;
-}
-function uncut_lane_issue(state) {
-  const issue = lane_paths.lane_issue_of(state.directory);
-  if (issue === void 0 || dispatched_issue(state) !== issue) return void 0;
-  return state.carried()?.issue === issue ? void 0 : issue;
-}
-function warrants_the_cut(verdict) {
-  return verdict !== cost_verdict.UNDER_VERDICT;
-}
-function is_uncut_gate(command, state = current_state2()) {
-  if (!runs_the_gate(command) || uncut_lane_issue(state) === void 0) return false;
-  return warrants_the_cut(state.context_verdict());
-}
-var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at. Issue `pnpm josh run:cut <N>`: on `cut`, end the turn immediately \u2014 no Telegram is owed; on any other verdict (`not-a-lane`, `busy`, \u2026), reissue the gate \u2014 this fires once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
-function reaches_the_pre_gate_boundary(call, _turn, run2) {
-  if (!bash_triggers.on_bash_command(asks_about_the_cut)(call)) return false;
-  return run2.some((issued) => bash_triggers.on_bash_command(claims_the_hold)(issued));
-}
-var pre_gate_cut = {
-  PRE_GATE_CUT_REASON,
-  asks_about_the_cut,
-  claims_the_hold,
-  is_uncut_gate,
-  reaches_the_pre_gate_boundary,
-  runs_the_gate,
-  takes_the_cut,
-  uncut_lane_issue
-};
-
-// 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_owner, target) {
-  if (session_owner === void 0 || target === void 0) return UNKNOWN;
-  return session_owner.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-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-gh-issue-rest.ts
-import { z as z5 } from "zod";
-var rest_issue_schema = z5.looseObject({
-  number: z5.number(),
-  issue_dependencies_summary: z5.looseObject({ total_blocked_by: z5.number().optional() }).nullish(),
-  // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z5.looseObject({ merged_at: z5.string().nullish() }).nullish()
-});
-var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
-var REPOSITORY_URL_GROUP = 1;
-var BLOCKED_BY_FIELD = "blockedBy";
-var BLOCKED_BY_COUNT_FIELD = "blocked_by_count";
-var STATE_FIELD = "state";
-var BODY_FIELD = "body";
-var FIELD_SEPARATOR = ",";
-var EMPTY_BODY = "";
-var REST_FIELD_NAMES = /* @__PURE__ */ new Map([
-  ["url", "html_url"],
-  ["createdAt", "created_at"],
-  ["closedAt", "closed_at"],
-  ["stateReason", "state_reason"],
-  ["updatedAt", "updated_at"]
-]);
-var NOT_AN_ISSUE_MESSAGE = "gh api answered something other than an issue object";
-var NOT_AN_ISSUE_LISTING_MESSAGE = "gh api answered something other than an issue listing";
-var NOT_A_BLOCKER_LISTING_MESSAGE = "gh api answered something other than a blocked-by listing";
-function rest_field_name(field) {
-  return REST_FIELD_NAMES.get(field) ?? field;
-}
-function split_fields(fields) {
-  return fields.split(FIELD_SEPARATOR).map((field) => field.trim()).filter((field) => field.length > 0);
-}
-function to_issue_state(rest, value) {
-  if (typeof rest.pull_request?.merged_at === "string") return MERGED_STATE;
-  return typeof value === "string" ? to_gh_state(value) : value;
-}
-function total_blocked_by(rest) {
-  return rest.issue_dependencies_summary?.total_blocked_by;
-}
-function to_gh_field_value(field, rest) {
-  if (field === BLOCKED_BY_COUNT_FIELD) return total_blocked_by(rest);
-  const value = rest[rest_field_name(field)];
-  if (field === STATE_FIELD) return to_issue_state(rest, value);
-  return field === BODY_FIELD ? value ?? EMPTY_BODY : value;
-}
-function parse_rest_issue(rest_json) {
-  const parsed = parse_json_object_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 issue = await read_issue_fields(issue_number, fields, repo);
-    return { kind: "read", json: JSON.stringify(issue) };
-  } catch (error) {
-    return to_read_failure(error);
-  }
-}
-async function issue_view_field_classified(issue_number, field, repo) {
-  try {
-    const issue = await read_issue_fields(issue_number, field, repo);
-    return { kind: "read", text: git_gh_issue_rest.to_field_text(issue[field]) };
-  } catch (error) {
-    return to_read_failure(error);
-  }
-}
-async function issue_view_field(issue_number, field, repo) {
-  const read2 = await issue_view_field_classified(issue_number, field, repo);
-  return read2.kind === "read" ? read2.text : void 0;
-}
-async function issue_get_title(issue_number, repo) {
-  const result = await issue_view_field(issue_number, "title", repo);
-  return result === void 0 ? void 0 : git_gh_helpers.parse_pr_state_string(result);
-}
-async function issue_get_body(issue_number, repo) {
-  return await issue_view_field(issue_number, "body", repo);
-}
-async function issue_get_body_classified(issue_number, repo) {
-  return await issue_view_field_classified(issue_number, "body", repo);
-}
-async function issue_view_json(issue_number, fields, repo) {
-  const read2 = await issue_view_json_classified(issue_number, fields, repo);
-  return read2.kind === "read" ? read2.json : void 0;
-}
-var STATE_AND_RELATIONS_FIELDS = "number,state,labels,blockedBy";
-async function issue_get_state_and_relations(issue_number, repo) {
-  return await issue_view_json(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
-}
-async function issue_get_state_and_relations_classified(issue_number, repo) {
-  return await issue_view_json_classified(issue_number, STATE_AND_RELATIONS_FIELDS, repo);
-}
-function is_unreachable_read(failure) {
-  return failure.kind === "unreadable" && failure.reason === "unreachable";
-}
-var PLAN_FIELDS = "number,title,body,state,url,labels,blockedBy";
-async function issue_get_plan_fields(issue_number) {
-  return await issue_view_json(issue_number, PLAN_FIELDS);
-}
-async function issue_get_plan_fields_classified(issue_number) {
-  return await issue_view_json_classified(issue_number, PLAN_FIELDS);
-}
-async function issue_get_labels_and_body(issue_number) {
-  return await issue_view_json(issue_number, "number,state,labels,body");
-}
-async function issue_list_comments(issue_number, timeout_ms) {
-  const path4 = `${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: path4, should_paginate: true, timeout_ms });
-  } 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 path4 = listing_path(request, page);
-  const rows = git_gh_issue_rest.parse_rest_issues(await git_gh_exec.exec_gh_api({ path: path4 }));
-  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/issue/issue-watch-diff.ts
-import { z as z6 } from "zod";
-var RUN_MARKER = "<!-- josh:run -->";
-var BOT_TYPE = "Bot";
-var BOT_SUFFIX = "[bot]";
-var NO_COMMENT_ID = 0;
-var UNKNOWN_AUTHOR = "(unknown)";
-var UNKNOWN_TIME = "(undated)";
-var BODY_HEADING = "Body edited:";
-var REMOVED_PREFIX = "- ";
-var ADDED_PREFIX = "+ ";
-var COMMENT_HEADING = "New comment by ";
-var AT = " at ";
-var SECTION_SEPARATOR = "\n\n";
-var LINE_SEPARATOR = "\n";
-var CRLF = "\r\n";
-var comment_schema = z6.looseObject({
-  id: z6.number(),
-  user: z6.looseObject({ login: z6.string(), type: z6.string().optional() }).nullish(),
-  created_at: z6.string().optional(),
-  body: z6.string().nullish()
-});
-function is_bot(user) {
-  return user?.type === BOT_TYPE || (user?.login.endsWith(BOT_SUFFIX) ?? false);
-}
-function is_automated(user, body) {
-  return is_bot(user) || body.includes(RUN_MARKER);
-}
-function to_comment(raw) {
-  const body = raw.body ?? "";
-  const author = raw.user?.login ?? UNKNOWN_AUTHOR;
-  const created_at = raw.created_at ?? UNKNOWN_TIME;
-  return { id: raw.id, author, is_automated: is_automated(raw.user, body), created_at, body };
-}
-function parse_comments(json) {
-  if (json === void 0) return void 0;
-  const listing = read_json_listing(json, comment_schema);
-  return listing.kind === "read" ? listing.rows.map((row) => to_comment(row)) : void 0;
-}
-function last_comment_id(comments) {
-  return Math.max(NO_COMMENT_ID, ...comments.map((comment) => comment.id));
-}
-function baseline_of(snapshot) {
-  return { body: snapshot.body, last_comment_id: last_comment_id(snapshot.comments) };
-}
-function lines_missing_from(source, other) {
-  const present = new Set(other.split(LINE_SEPARATOR));
-  return source.split(LINE_SEPARATOR).filter((line) => line.trim() !== "" && !present.has(line));
-}
-function to_lf(body) {
-  return body.split(CRLF).join(LINE_SEPARATOR);
-}
-function body_section(previous_raw, current_raw) {
-  const previous = to_lf(previous_raw);
-  const current = to_lf(current_raw);
-  if (previous === current) return void 0;
-  const removed = lines_missing_from(previous, current).map((line) => `${REMOVED_PREFIX}${line}`);
-  const added = lines_missing_from(current, previous).map((line) => `${ADDED_PREFIX}${line}`);
-  return [BODY_HEADING, ...removed, ...added].join(LINE_SEPARATOR);
-}
-function comment_section(comment) {
-  return `${COMMENT_HEADING}${comment.author}${AT}${comment.created_at}${LINE_SEPARATOR}${comment.body}`;
-}
-function new_person_comments(baseline, snapshot) {
-  return snapshot.comments.filter(
-    (comment) => comment.id > baseline.last_comment_id && !comment.is_automated
-  );
-}
-function unread_diff(baseline, snapshot) {
-  const body = body_section(baseline.body, snapshot.body);
-  const comments = new_person_comments(baseline, snapshot).map(
-    (comment) => comment_section(comment)
-  );
-  const sections = [...body === void 0 ? [] : [body], ...comments];
-  return sections.length === 0 ? void 0 : sections.join(SECTION_SEPARATOR);
-}
-var issue_watch_diff = {
-  RUN_MARKER,
-  baseline_of,
-  parse_comments,
-  unread_diff
-};
-
-// 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 NOT_PLANNED_REASON = "not_planned";
-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: `${body}
-
-${issue_watch_diff.RUN_MARKER}` }),
-    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 close_with(issue_number, comment, state) {
-  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)
-    });
-  });
-}
-async function issue_close(issue_number, comment) {
-  return await close_with(issue_number, comment, { state: CLOSED_STATE });
-}
-async function issue_close_not_planned(issue_number, comment) {
-  return await close_with(issue_number, comment, {
-    state: CLOSED_STATE,
-    state_reason: NOT_PLANNED_REASON
-  });
-}
-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,
-  issue_close_not_planned,
-  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,labels,${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 JUDGEMENT_FIELDS = "number,title,body,labels,updatedAt";
-async function issue_list_open_for_judgement(limit) {
-  return await issue_list2({ json_fields: JUDGEMENT_FIELDS, limit });
-}
-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_open_for_judgement,
-  issue_list_recently_closed
-};
-
-// scripts/ci/pr-classification.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { z as z7 } 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 = z7.object({ name: z7.string() });
-var USER = z7.object({ login: z7.string() });
-var PULL_REQUEST = z7.object({ number: z7.number(), user: USER });
-var EVENT = z7.object({
-  pull_request: PULL_REQUEST,
-  repository: z7.object({ full_name: z7.string() })
-});
-function classification_error(labels, author) {
-  const legacy = labels.filter((label) => LEGACY_LABELS.has(label.toLowerCase()));
-  if (legacy.length > 0) return `Remove legacy release labels: ${legacy.join(", ")}`;
-  const selected = labels.filter((label) => CLASSIFICATION_SET.has(label.toLowerCase()));
-  if (selected.length > 1) {
-    return `Choose exactly one release classification; found: ${selected.join(", ")}`;
-  }
-  if (selected.length === 1 || author.endsWith("[bot]")) return void 0;
-  return `Choose one release classification: ${RELEASE_CLASSIFICATION_NAMES.join(", ")}`;
-}
-function declaration(label) {
-  return `${DECLARATION_PREFIX}${label}`;
-}
-function is_classification(value) {
-  return CLASSIFICATION_SET.has(value);
-}
-function release_candidates(candidates) {
-  if (!candidates.includes(BREAKING_CHANGE_LABEL)) return candidates;
-  return candidates.filter((candidate) => candidate !== ENHANCEMENT_LABEL);
-}
-function issue_candidates(issue_json) {
-  const issue = z7.object({ labels: z7.array(LABEL), body: z7.string().nullable() }).parse(JSON.parse(issue_json));
-  const names = issue.labels.map((label) => label.name.toLowerCase());
-  const declared = [...(issue.body ?? "").matchAll(DECLARATION)].map((match) => match[1] ?? "");
-  const candidates = [...release_candidates([...names, ...declared].filter(is_classification))];
-  const unknown = declared.filter((value) => !is_classification(value));
-  if (unknown.length > 0) throw new Error(`Unknown release classification: ${unknown.join(", ")}`);
-  if (names.includes(ISSUE_BUG_LABEL) && !candidates.includes(BREAKING_CHANGE_LABEL)) {
-    candidates.push(BUGFIX_LABEL);
-  }
-  return candidates;
-}
-function select_issue_classification(issue_json) {
-  const candidates = issue_candidates(issue_json);
-  const selected = [...new Set(candidates)];
-  const [label] = selected;
-  if (label === void 0 || selected.length > 1) {
-    throw new Error(
-      `Choose one release classification before opening the PR: ${RELEASE_CLASSIFICATION_NAMES.join(", ")}; found: ${selected.join(", ") || "none"}. Add "${DECLARATION_PREFIX}<label>" to the Issue body.`
-    );
-  }
-  return label;
-}
-function fetch_current_labels(repository, pull_number) {
-  const path4 = `repos/${repository}/issues/${String(pull_number)}/labels`;
-  try {
-    const names = git_gh_exec.exec_gh_api_sync({ path: path4, 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(readFileSync3(event_path, "utf8")));
-  const labels = read_labels(event.repository.full_name, event.pull_request.number);
-  return classification_error(labels, event.pull_request.user.login);
-}
-if (process.argv[1] === fileURLToPath2(import.meta.url)) {
-  const event_path = process.env["GITHUB_EVENT_PATH"];
-  if (!event_path) throw new Error("GITHUB_EVENT_PATH is required");
-  const error = check_event(event_path);
-  if (error) {
-    console.error(`::error::${error}`);
-    process.exitCode = 1;
-  }
-}
-var pr_classification = {
-  classification_error,
-  check_event,
-  fetch_current_labels,
-  declaration,
-  is_classification,
-  select_issue_classification
-};
-
-// scripts/lib/poll.ts
-async function sleep2(duration_ms) {
-  await new Promise((resolve2) => {
-    setTimeout(resolve2, duration_ms);
-  });
-}
-async function wait_between(wait, interval_ms, attempt, attempts) {
-  if (attempt < attempts - 1) await wait(interval_ms);
-}
-async function poll_until(is_done, options) {
-  const wait = options.sleeper ?? 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 z10 } from "zod";
-
-// scripts/gh/git-gh-pr-review.ts
-import { z as z8 } 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 = z8.looseObject({
-  state: z8.string().optional(),
-  user: z8.looseObject({ login: z8.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 z9 } from "zod";
-var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
-var TYPE_NAME_KEY = "__typename";
-var rollup_element_schema = z9.looseObject({});
-var check_runs_page_schema = z9.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: z9.array(rollup_element_schema)
-});
-var id_holder_schema = z9.object({ id: z9.number() });
-var status_page_schema = z9.looseObject({
-  statuses: z9.array(rollup_element_schema)
-});
-var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
-var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
-function read_pages(raw_json, schema, message) {
-  const pages = parse_json_array_or_undefined(raw_json, schema);
-  if (pages === void 0) throw new Error(message);
-  return pages;
-}
-var NO_SUITE = -1;
-function read_id(value) {
-  const parsed = id_holder_schema.safeParse(value);
-  return parsed.success ? parsed.data.id : void 0;
-}
-function check_run_group_key(run2) {
-  const { name, app } = run2;
-  if (typeof name !== "string") return void 0;
-  return JSON.stringify([name, read_id(app)]);
-}
-function read_rank(run2) {
-  const id = read_id(run2);
-  if (id === void 0) return void 0;
-  return { suite: read_id(run2["check_suite"]) ?? NO_SUITE, run: id };
-}
-function is_ranked_above(candidate, current) {
-  if (candidate.suite !== current.suite) return candidate.suite > current.suite;
-  return candidate.run > current.run;
-}
-function should_replace(previous, rank) {
-  const previous_rank = previous === void 0 ? void 0 : read_rank(previous);
-  return previous_rank === void 0 || is_ranked_above(rank, previous_rank);
-}
-function remember_newest_run(run2, newest) {
-  const key2 = check_run_group_key(run2);
-  const rank = read_rank(run2);
-  if (key2 === void 0 || rank === void 0) return;
-  if (should_replace(newest.get(key2), rank)) newest.set(key2, run2);
-}
-function is_newest_run(run2, newest) {
-  const key2 = check_run_group_key(run2);
-  if (key2 === void 0 || read_rank(run2) === void 0) return true;
-  return newest.get(key2) === run2;
-}
-function to_check_run_items(check_runs_json) {
-  const pages = read_pages(check_runs_json, check_runs_page_schema, NOT_A_CHECK_RUNS_LISTING);
-  const runs = pages.flatMap((page) => page.check_runs);
-  const newest = /* @__PURE__ */ new Map();
-  for (const run2 of runs) remember_newest_run(run2, newest);
-  return runs.filter((run2) => is_newest_run(run2, newest));
-}
-function to_status_context_items(status_json) {
-  const pages = read_pages(status_json, status_page_schema, NOT_A_STATUS_LISTING);
-  return pages.flatMap((page) => page.statuses).map((status) => ({ ...status, [TYPE_NAME_KEY]: STATUS_CONTEXT_TYPE_NAME }));
-}
-function to_status_check_rollup(input) {
-  return [
-    ...to_check_run_items(input.check_runs_json),
-    ...to_status_context_items(input.status_json)
-  ];
-}
-var git_gh_pr_rollup = {
-  to_status_check_rollup
-};
-
-// scripts/gh/git-gh-pr-snapshot.ts
-var NO_HEAD_SHA_MESSAGE = "gh api answered a pull request with no head commit";
-async function read_object_pages(path4) {
-  return await git_gh_exec.exec_gh_api({
-    path: `${path4}${FULL_PAGE_QUERY}`,
-    should_paginate: true,
-    should_slurp: true
-  });
-}
-async function read_array_pages(path4) {
-  return await git_gh_exec.exec_gh_api({
-    path: `${path4}${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 path4 = git_gh_api_path.pull_reviews_api_path(String(pr_number));
-  return git_gh_pr_review.to_review_decision(await read_array_pages(path4));
-}
-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 = z10.array(z10.object({ name: z10.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_merged = await read_merge_state(pr_number);
-    if (is_merged !== void 0) return is_merged;
-    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-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 read2 = await read_pr_state(input, evaluator);
-  if (read2.kind === "unreadable") return await retry_after_unreadable(input, read2.cause);
-  const classification = classify_poll_result({
-    snapshot: read2.snapshot,
-    stable_count: input.stable_count,
-    required_stable_reads: input.options.required_stable_reads,
-    evaluator
-  });
-  if (classification.is_done) {
-    return { snapshot: read2.snapshot, next_stable_count: 0, next_failure_count: 0 };
-  }
-  await sleep_before_next_attempt(input);
-  return { next_stable_count: classification.next_stable_count, next_failure_count: 0 };
-}
-async function wait_for_pr_success(options) {
-  let carried = { next_stable_count: 0, next_failure_count: 0 };
-  for (let attempt = 0; attempt < options.max_attempts; attempt += 1) {
-    console.info(`Checking PR status\u2026 (${String(attempt + 1)}/${String(options.max_attempts)})`);
-    await options.before_poll?.();
-    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) };
-}
-function observed_fetcher(observe) {
-  if (observe === void 0) return default_fetch_pr_state;
-  return async function fetch_observed(branch_name, should_read_review_decision) {
-    const snapshot = await default_fetch_pr_state(branch_name, should_read_review_decision);
-    await observe(snapshot);
-    return snapshot;
-  };
-}
-
-// 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(check2) {
-  return !is_coderabbit_check(check2.name) || is_required_check(check2.name);
-}
-function evaluate_checks_settled(snapshot) {
-  const awaited = snapshot.rollup.filter((check2) => is_awaited_check(check2));
-  const considered = awaited.length === 0 ? snapshot.rollup : awaited;
-  if (considered.length === 0 || considered.some((check2) => check2.status === CHECK_STATUS_PENDING)) {
-    return "pending";
-  }
-  return snapshot.rollup.some((check2) => check2.status === CHECK_STATUS_FAIL) ? "failure" : "success";
-}
-function describe_checks_failure(snapshot) {
-  const failed = snapshot.rollup.filter((check2) => check2.status === CHECK_STATUS_FAIL);
-  return `${CHECKS_FAILED_MESSAGE}: ${failed.map((check2) => check2.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, observe) {
-  await wait_for_pr_success({
-    branch_name,
-    fetcher: observed_fetcher(observe),
-    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, observe) {
-  try {
-    await watch_until_settled(branch_name, observe);
-    return { timed_out: false };
-  } catch (error) {
-    if (!is_pr_checks_timeout(error)) throw error;
-    await fail_when_no_checks(branch_name);
-    console.info(WATCH_TIMED_OUT_NOTE);
-    return { timed_out: true };
-  }
-}
-var git_pr_checks_watch = { pr_checks_watch };
-
-// scripts/gh/git-gh-command.ts
-var git_gh_command = {
-  ...git_gh_pr,
-  ...git_gh_pr_auto_merge,
-  pr_checks_watch: git_pr_checks_watch.pr_checks_watch,
-  ...git_gh_issue,
-  ...git_gh_repo
-};
-
-// scripts/gh/gh-spawn.ts
-var NO_BUDGET = 0;
-function fetch_repo_name(timeout_ms) {
-  const stdout = git_gh_exec.read_gh_api_sync({
-    path: git_gh_api_path.repo_api_path(),
-    jq_filter: ".full_name",
-    cwd: PROJECT_ROOT,
-    timeout_ms: timeout_ms ?? NO_BUDGET
-  });
-  const name = stdout?.trim();
-  return name === "" ? void 0 : name;
-}
-function get_repo_name_with_owner() {
-  return fetch_repo_name(void 0);
-}
-function get_repo_name_with_owner_within(timeout_ms) {
-  return fetch_repo_name(timeout_ms);
-}
-var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
-
-// scripts/issue/issue-state.ts
-import { z as z11 } from "zod";
-var NO_LABELS = "(none)";
-var LABEL_SEPARATOR = ", ";
-var STATE_LABEL = "state: ";
-var LABELS_LABEL = "labels: ";
-var HUMAN_REVIEW_LABEL_LINE = "human_review: ";
-var YES = "yes";
-var NO = "no";
-var ISSUE_LABEL = "issue: ";
-var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
-var label_schema = z11.looseObject({ name: z11.string() });
-var issue_state_schema = z11.looseObject({
-  state: z11.string(),
-  labels: label_schema.array().optional()
-});
-function parse_issue_state(json) {
-  try {
-    const parsed = parse_json_object_or_undefined(json, issue_state_schema);
-    if (parsed === void 0) return void 0;
-    const labels = parsed.labels ?? [];
-    return {
-      state: parsed.state,
-      labels: labels.map((label) => label.name),
-      is_human_review: has_any_label(labels, HUMAN_REVIEW_LABELS)
-    };
-  } catch {
-    return void 0;
-  }
-}
-function format_labels(labels) {
-  return labels.length === 0 ? NO_LABELS : labels.join(LABEL_SEPARATOR);
-}
-function format_issue_state(state) {
-  const human_review = `${HUMAN_REVIEW_LABEL_LINE}${state.is_human_review ? YES : NO}`;
-  return `${STATE_LABEL}${state.state}
-${LABELS_LABEL}${format_labels(state.labels)}
-${human_review}`;
-}
-function format_attributed_issue_state(issue_number, state) {
-  return `${ISSUE_LABEL}${issue_number}
-${format_issue_state(state)}`;
-}
-var issue_state = {
-  NO_LABELS,
-  parse_issue_state,
-  format_issue_state,
-  format_attributed_issue_state
-};
-
-// scripts/run/run-liveness.ts
-import { readFileSync as readFileSync4, realpathSync, statSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import path3 from "node:path";
-import { setTimeout as sleep3 } from "node:timers/promises";
-
-// scripts/agent/agent-event.ts
-import { z as z14 } from "zod";
-
-// scripts/agent/claude-result-event.ts
-import { z as z13 } from "zod";
-
-// scripts/agent/interactive-ask.ts
-import { z as z12 } from "zod";
-var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion"]);
-function is_interactive_tool(name) {
-  return INTERACTIVE_TOOLS.has(name);
-}
-var OPTION_SCHEMA = z12.looseObject({ label: z12.string().optional() });
-var QUESTION_SCHEMA = z12.looseObject({
-  question: z12.string().optional(),
-  options: z12.array(OPTION_SCHEMA).optional()
-});
-var ASK_INPUT_SCHEMA = z12.looseObject({ questions: z12.array(QUESTION_SCHEMA).optional() });
-var DENIAL_SCHEMA = z12.looseObject({
-  tool_name: z12.string().optional(),
-  tool_input: z12.unknown().optional()
-});
-var UNKNOWN_QUESTION = "(question text unavailable)";
-var OPTION_SEPARATOR = " / ";
-var QUESTION_SEPARATOR = "; ";
-function labels_of(question) {
-  return (question.options ?? []).map((option) => option.label ?? "").filter((label) => label !== "");
-}
-function render_question(question) {
-  const labels = labels_of(question);
-  const text = question.question ?? UNKNOWN_QUESTION;
-  return labels.length === 0 ? text : `${text} [${labels.join(OPTION_SEPARATOR)}]`;
-}
-function interactive_input(raw) {
-  const denial = DENIAL_SCHEMA.safeParse(raw);
-  if (!denial.success || !is_interactive_tool(denial.data.tool_name ?? "")) return void 0;
-  const input = ASK_INPUT_SCHEMA.safeParse(denial.data.tool_input);
-  return input.success ? input.data : void 0;
-}
-function refused_ask_of(permission_denials) {
-  if (!Array.isArray(permission_denials)) return void 0;
-  const input = permission_denials.map((raw) => interactive_input(raw)).find((one) => one !== void 0);
-  const questions = input?.questions ?? [];
-  if (questions.length === 0) return void 0;
-  return questions.map((question) => render_question(question)).join(QUESTION_SEPARATOR);
-}
-var interactive_ask = { is_interactive_tool, refused_ask_of };
-
-// scripts/agent/claude-result-event.ts
-var RESULT_EVENT_SCHEMA = z13.looseObject({
-  type: z13.literal("result"),
-  is_error: z13.unknown().optional(),
-  subtype: z13.unknown().optional(),
-  num_turns: z13.unknown().optional(),
-  permission_denials: z13.unknown().optional(),
-  result: z13.unknown().optional(),
-  session_id: z13.unknown().optional(),
-  usage: z13.unknown().optional()
-});
-var USAGE_SCHEMA = z13.looseObject({
-  input_tokens: z13.unknown().optional(),
-  cache_read_input_tokens: z13.unknown().optional(),
-  output_tokens: z13.unknown().optional()
-});
-function usable_reason(value) {
-  return typeof value === "string" && value.trim() !== "" ? value : void 0;
-}
-function numeric_value(value) {
-  return typeof value === "number" ? value : void 0;
-}
-function denial_count(value) {
-  return Array.isArray(value) ? value.length : 0;
-}
-function usage_of(value) {
-  const parsed = USAGE_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const usage = {
-    input_tokens: numeric_value(parsed.data.input_tokens),
-    cached_input_tokens: numeric_value(parsed.data.cache_read_input_tokens),
-    output_tokens: numeric_value(parsed.data.output_tokens)
-  };
-  return Object.values(usage).some((count) => count !== void 0) ? usage : void 0;
-}
-function decode(value) {
-  const parsed = RESULT_EVENT_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const is_error = parsed.data.is_error === true;
-  return {
-    is_error,
-    subtype: usable_reason(parsed.data.subtype),
-    num_turns: numeric_value(parsed.data.num_turns),
-    permission_denials: denial_count(parsed.data.permission_denials),
-    refused_ask: interactive_ask.refused_ask_of(parsed.data.permission_denials),
-    reason: is_error ? usable_reason(parsed.data.result) ?? usable_reason(parsed.data.subtype) : void 0,
-    session_id: usable_reason(parsed.data.session_id),
-    usage: usage_of(parsed.data.usage)
-  };
-}
-var claude_result_event = { decode };
-
-// scripts/agent/agent-event.ts
-var TEXT_BLOCK_SCHEMA = z14.looseObject({ type: z14.literal("text"), text: z14.string() });
-var CLAUDE_MESSAGE_SCHEMA = z14.looseObject({ content: z14.array(z14.unknown()).optional() });
-var CLAUDE_INIT_SCHEMA = z14.looseObject({ type: z14.literal("system"), subtype: z14.literal("init") });
-var CLAUDE_ASSISTANT_SCHEMA = z14.looseObject({
-  type: z14.literal("assistant"),
-  message: CLAUDE_MESSAGE_SCHEMA
-});
-var USAGE_SCHEMA2 = z14.looseObject({
-  input_tokens: z14.number().optional(),
-  cached_input_tokens: z14.number().optional(),
-  output_tokens: z14.number().optional()
-});
-var CODEX_START_SCHEMA = z14.looseObject({ type: z14.enum(["thread.started", "turn.started"]) });
-var CODEX_PROGRESS_SCHEMA = z14.looseObject({
-  type: z14.enum(["item.started", "item.updated", "item.completed"]),
-  item: z14.looseObject({ type: z14.string(), text: z14.string().optional() }).optional()
-});
-var CODEX_COMPLETE_SCHEMA = z14.looseObject({
-  type: z14.literal("turn.completed"),
-  usage: USAGE_SCHEMA2.optional()
-});
-var CODEX_FAILURE_SCHEMA = z14.looseObject({
-  type: z14.enum(["turn.failed", "error"]),
-  error: z14.looseObject({ message: z14.string().optional() }).optional(),
-  message: z14.string().optional()
-});
-var EMPTY_STATE = {
-  provider: void 0,
-  launch: "pending",
-  progress: void 0,
-  result: "running",
-  reason: void 0,
-  usage: void 0
-};
-var LAUNCH_HEADER_PREFIX = "=== ";
-var LAUNCH_HEADER_MARKER = " \xB7 started by process ";
-function usable_text(value) {
-  return typeof value === "string" && value.trim() !== "" ? value : void 0;
-}
-function claude_progress(content) {
-  return content.map((block) => TEXT_BLOCK_SCHEMA.safeParse(block)).filter((parsed) => parsed.success).map((parsed) => parsed.data.text).findLast((text) => text.trim() !== "");
-}
-function claude_result(value, state) {
-  const result = claude_result_event.decode(value);
-  if (result === void 0) return void 0;
-  return {
-    ...state,
-    provider: "anthropic",
-    result: result.is_error ? "failed" : "completed",
-    reason: result.is_error ? result.reason ?? state.reason : state.reason,
-    usage: result.usage
-  };
-}
-function claude_assistant(value, state) {
-  const assistant = CLAUDE_ASSISTANT_SCHEMA.safeParse(value);
-  if (!assistant.success) return void 0;
-  const progress = claude_progress(assistant.data.message.content ?? []) ?? state.progress;
-  return { ...state, provider: "anthropic", progress };
-}
-function claude_terminal(value, state) {
-  return claude_result(value, state);
-}
-function claude_event(value, state) {
-  if (CLAUDE_INIT_SCHEMA.safeParse(value).success) {
-    return { ...state, provider: "anthropic", launch: "started" };
-  }
-  return claude_assistant(value, state) ?? claude_terminal(value, state);
-}
-function codex_progress(value, state) {
-  const parsed = CODEX_PROGRESS_SCHEMA.safeParse(value);
-  if (!parsed.success) return void 0;
-  const progress = usable_text(parsed.data.item?.text) ?? state.progress;
-  return { ...state, provider: "openai", progress };
-}
-function codex_completed(value, state) {
-  const completed = CODEX_COMPLETE_SCHEMA.safeParse(value);
-  if (!completed.success) return void 0;
-  return { ...state, provider: "openai", result: "completed", usage: completed.data.usage };
-}
-function codex_failed(value, state) {
-  const failed = CODEX_FAILURE_SCHEMA.safeParse(value);
-  if (!failed.success) return void 0;
-  const reason = usable_text(failed.data.error?.message) ?? usable_text(failed.data.message);
-  return { ...state, provider: "openai", result: "failed", reason: reason ?? state.reason };
-}
-function codex_terminal(value, state) {
-  return codex_completed(value, state) ?? codex_failed(value, state);
-}
-function codex_event(value, state) {
-  if (CODEX_START_SCHEMA.safeParse(value).success) {
-    return { ...state, provider: "openai", launch: "started" };
-  }
-  return codex_progress(value, state) ?? codex_terminal(value, state);
-}
-function normalized(value, state) {
-  return claude_event(value, state) ?? codex_event(value, state) ?? state;
-}
-function next_state(line, state) {
-  const is_header = line.startsWith(LAUNCH_HEADER_PREFIX) && line.includes(LAUNCH_HEADER_MARKER);
-  if (is_header) return EMPTY_STATE;
-  return normalized(json_value.parse_or_undefined(line), state);
-}
-function read(transcript) {
-  let state = EMPTY_STATE;
-  for (const line of transcript.split("\n")) state = next_state(line, state);
-  return state;
-}
-function describe(state) {
-  const progress = state.progress === void 0 ? "" : ` progress=${state.progress}`;
-  const reason = state.reason === void 0 ? "" : ` reason=${state.reason}`;
-  return `launch=${state.launch} result=${state.result}${progress}${reason}`;
-}
-var agent_event = { describe, read };
-
-// scripts/run/run-liveness.ts
-var ALIVE_VERDICT = "alive";
-var SETTLED_VERDICT = "settled";
-var STOPPED_VERDICT = "stopped";
-var UNDETERMINED_VERDICT = "undetermined";
-var PROCESS_ALIVE = "alive";
-var PROCESS_NONE = "none";
-var PROCESS_UNKNOWN = "unknown";
-var DEFAULT_SILENT_MINUTES = 30;
-var DEFAULT_GAP_SECONDS = 5;
-var MS_PER_MINUTE = 6e4;
-var MS_PER_SECOND = 1e3;
-var OPEN_STATE = "OPEN";
-var STATE_FIELDS = "state,labels";
-var REASONS = {
-  [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
-  [SETTLED_VERDICT]: "The child is closed, parked with `needs-decision`, or marked `already-done`, so there is nothing here to recover.",
-  [STOPPED_VERDICT]: "The output has been frozen past the silent window and no process of the child is alive in that checkout.",
-  [UNDETERMINED_VERDICT]: "A trace could not be read, so this says nothing about the unit. A trace that could not be read answers `undetermined`, never `stopped`."
-};
-var ALIVE_ADVICE = "Keep waiting on `pnpm josh lane:await`; do not touch the child.";
-var SETTLED_ADVICE = "Read the child with `pnpm josh issue:state <N>` and take the branch its state says.";
-var STOPPED_CLEAN_ADVICE = 'The unit ended \u2014 classify how before booking it. Run `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it reads the child\'s exit record without waiting for the unit to return, re-dispatches a child that could not reach the API (counting the outage; a run of them trips the environment guard and stops the run), and parks an abandoned child with `needs-decision` against the consecutive-failure guard. The checkout is clean, so there is nothing to stash.';
-var STOPPED_DIRTY_ADVICE = 'Stash the half-finished work with `git stash push -u -m "backlogrun: stopped unit for #<N>"` and record it on the Issue, then classify how the unit ended with `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo> --owner "$PPID"` for a named epic): it re-dispatches an API-outage child (counting the outage; a run of them trips the environment guard) and parks an abandoned child with `needs-decision` against the consecutive-failure guard, without waiting for the unit to return.';
-var UNDETERMINED_ADVICE = "Read the trace that failed and ask again. Where the process trace was given as `unknown`, leave `--process` out so the command reads it. Two of these in a row is a fault in the check itself rather than a slow unit: stop polling and report it.";
-function is_output_moving(traces) {
-  return traces.is_output_frozen === false;
-}
-function is_agent_state_finished(state) {
-  return state?.result === "completed" || state?.result === "failed";
-}
-function is_agent_finished(traces) {
-  return is_agent_state_finished(traces.agent_state);
-}
-function definitive_verdict(traces) {
-  if (traces.is_child_settled === true) return SETTLED_VERDICT;
-  if (is_agent_finished(traces)) return STOPPED_VERDICT;
-  if (is_output_moving(traces)) return ALIVE_VERDICT;
-  return void 0;
-}
-function is_check_running(traces) {
-  return traces.process_trace === PROCESS_ALIVE;
-}
-function has_unreadable_trace(traces) {
-  return traces.is_child_settled === void 0 || traces.is_output_frozen === void 0 || traces.process_trace === PROCESS_UNKNOWN;
-}
-function to_verdict(traces) {
-  const definitive = definitive_verdict(traces);
-  if (definitive !== void 0) return definitive;
-  if (has_unreadable_trace(traces)) return UNDETERMINED_VERDICT;
-  return is_check_running(traces) ? ALIVE_VERDICT : STOPPED_VERDICT;
-}
-function to_advice(verdict, has_work_to_stash) {
-  if (verdict === ALIVE_VERDICT) return ALIVE_ADVICE;
-  if (verdict === SETTLED_VERDICT) return SETTLED_ADVICE;
-  if (verdict === UNDETERMINED_VERDICT) return UNDETERMINED_ADVICE;
-  return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
-}
-function decide3(traces) {
-  const verdict = to_verdict(traces);
-  const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
-  return {
-    advice: to_advice(verdict, has_work_to_stash),
-    has_work_to_stash,
-    reason: traces.agent_state?.reason ?? REASONS[verdict],
-    verdict
-  };
-}
-function to_resolved_root(root) {
-  try {
-    return realpathSync(root);
-  } catch {
-    return root;
-  }
-}
-var ALLOWED_ROOTS = [
-  ...new Set(
-    [homedir(), tmpdir(), PLATFORM_TEMP_ROOT].flatMap((root) => [root, to_resolved_root(root)])
-  )
-];
-function is_within(candidate, root) {
-  const relative = path3.relative(root, candidate);
-  return relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
-}
-function to_safe_path(output_path) {
-  const normalized2 = path3.normalize(output_path);
-  if (!path3.isAbsolute(normalized2)) return void 0;
-  return ALLOWED_ROOTS.some((root) => is_within(normalized2, root)) ? normalized2 : void 0;
-}
-function sample_output(output_path) {
-  const safe_path = to_safe_path(output_path);
-  if (safe_path === void 0) return void 0;
-  const stats = statSync(safe_path, { throwIfNoEntry: false });
-  if (!stats?.isFile()) return void 0;
-  return { mtime_ms: stats.mtimeMs, size: stats.size };
-}
-function read_agent_state(output_path) {
-  const safe_path = to_safe_path(output_path);
-  if (safe_path === void 0) return void 0;
-  try {
-    const state = agent_event.read(readFileSync4(safe_path, "utf8"));
-    return state.provider === void 0 ? void 0 : state;
-  } catch {
-    return void 0;
-  }
-}
-function describe_agent_state(output_path) {
-  const state = read_agent_state(output_path);
-  return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
-}
-async function read_output_frozen(request) {
-  const first = sample_output(request.output_path);
-  if (first === void 0) return void 0;
-  if (request.now_ms - first.mtime_ms < request.silent_window_ms) return false;
-  await sleep3(request.gap_ms);
-  const second = sample_output(request.output_path);
-  if (second === void 0) return void 0;
-  return second.mtime_ms === first.mtime_ms && second.size === first.size;
-}
-function carries_label(labels, wanted) {
-  return labels.some((label) => label.toLowerCase() === wanted);
-}
-var SETTLED_LABELS = [NEEDS_DECISION_LABEL, ALREADY_DONE_LABEL];
-function carries_settled_label(labels) {
-  return SETTLED_LABELS.some((label) => carries_label(labels, label));
-}
-async function read_child_settled(issue, repo) {
-  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELDS, repo);
-  if (json === void 0) return void 0;
-  const state = issue_state.parse_issue_state(json);
-  if (state === void 0) return void 0;
-  return state.state !== OPEN_STATE || carries_settled_label(state.labels);
-}
-async function read_traces(request) {
-  const [is_initial_child_settled, is_output_frozen, is_tree_dirty] = await Promise.all([
-    read_child_settled(request.issue, request.repo),
-    read_output_frozen({
-      gap_ms: request.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND,
-      now_ms: Date.now(),
-      output_path: request.output_path,
-      silent_window_ms: request.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE
-    }),
-    run_hold.is_tree_dirty()
-  ]);
-  const agent_state = read_agent_state(request.output_path);
-  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request.issue, request.repo) : void 0;
-  const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
-  return {
-    agent_state,
-    is_child_settled,
-    is_output_frozen,
-    is_tree_dirty,
-    process_trace: request.process_trace
-  };
-}
-async function check(request) {
-  issue_number_shape.require_issue_number(request.issue);
-  return decide3(await read_traces(request));
-}
-var run_liveness = {
-  check,
-  decide: decide3,
-  describe_agent_state,
-  read_child_settled,
-  read_output_frozen,
-  sample_output,
-  to_safe_path
-};
-
-export {
-  bounded_pool,
-  git_gh_issue_read,
-  issue_watch_diff,
-  shell_segments,
-  bash_triggers,
-  tail_commands,
-  filing_cap,
-  CONTEXT_CUT_THRESHOLD,
-  cost_verdict,
-  cost_cli,
-  run_cut_handoff,
-  run_cut,
-  run_tail_rule,
-  lane_background,
-  interactive_ask,
-  IN_PROGRESS_LABEL,
-  NEEDS_DECISION_LABEL,
-  RUN_SOLO_LABEL,
-  RUN_LANE_LABEL,
-  ALREADY_DONE_LABEL,
-  has_any_label,
-  label_name_of,
-  has_label_name,
-  lane_handoff,
-  lane_park,
-  pre_gate_cut,
-  gh_spawn,
-  repo_party,
-  git_gh_repo,
-  git_gh_command,
-  issue_state,
-  PROCESS_ALIVE,
-  PROCESS_NONE,
-  PROCESS_UNKNOWN,
-  run_liveness
-};