@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-EOPRRSCY.js

@@ -0,0 +1,1891 @@
+import {
+  lane_breakdown_text
+} from "./chunk-NZ2UKIY5.js";
+import {
+  api_outage,
+  run_ending
+} from "./chunk-GL3VOBWB.js";
+import {
+  lane_investigation_switch,
+  run_event_overrun
+} from "./chunk-ZBRUCKLP.js";
+import {
+  lane_withdraw_closed
+} from "./chunk-RLWK2CP3.js";
+import {
+  lane_preserve
+} from "./chunk-64II6P7B.js";
+import {
+  issue_merged
+} from "./chunk-ORFXTHXU.js";
+import {
+  lane_reap_settle
+} from "./chunk-MKIHWQ65.js";
+import {
+  lane_residents
+} from "./chunk-GX5XHW2F.js";
+import {
+  run_ship_stop_text
+} from "./chunk-U5HQQWRE.js";
+import {
+  run_merge_driver
+} from "./chunk-RVKFX3FD.js";
+import {
+  gh_core_rate_limit,
+  run_merge_token,
+  run_merge_usage_limit
+} from "./chunk-TBIX42IT.js";
+import {
+  lane_vacant
+} from "./chunk-YR5RS4YT.js";
+import {
+  run_event_filed
+} from "./chunk-PYOK73QE.js";
+import {
+  lane_relaunch
+} from "./chunk-TSS2RKBC.js";
+import {
+  api_auth
+} from "./chunk-NUR4FQHM.js";
+import {
+  agent_exit_record
+} from "./chunk-GPTO6IZG.js";
+import {
+  lane_dispatch_dependency
+} from "./chunk-ELZQL6M3.js";
+import {
+  issue_state_cli
+} from "./chunk-6TOWGIY2.js";
+import {
+  git_followup_issue_close,
+  settled_together
+} from "./chunk-FFLZPLWC.js";
+import {
+  epic_close
+} from "./chunk-VWNVKWLV.js";
+import {
+  lane_ledger_archive
+} from "./chunk-2TI22UNK.js";
+import {
+  run_label
+} from "./chunk-6NXTP5JT.js";
+import {
+  issue_not_before
+} from "./chunk-JUXKVN77.js";
+import {
+  issue_closing_pr,
+  issue_sample_prime
+} from "./chunk-FBZD6LOK.js";
+import {
+  josh_command
+} from "./chunk-72LAYP5S.js";
+import {
+  issue_priority
+} from "./chunk-FBWNL3UA.js";
+import {
+  telegram_notify
+} from "./chunk-MQNKIKJ6.js";
+import {
+  lane_breakdown_implement
+} from "./chunk-UWLANGIR.js";
+import {
+  lane_breakdown
+} from "./chunk-2MDLCJZ4.js";
+import {
+  lane_net_time
+} from "./chunk-LAUKNN57.js";
+import {
+  lane_yield
+} from "./chunk-SIPHEZXP.js";
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  stop_decision
+} from "./chunk-3ZEO3KOM.js";
+import {
+  lane_park
+} from "./chunk-B4OZF4XL.js";
+import {
+  agent_argv
+} from "./chunk-IV6ETHVB.js";
+import {
+  lane_tail_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_await
+} from "./chunk-YSDBY2G7.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  bash_triggers
+} from "./chunk-25LVQDOF.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  issue_park
+} from "./chunk-NHXMWRBI.js";
+import {
+  run_stalled
+} from "./chunk-IBOCPSPK.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  run_cut,
+  run_cut_adoption
+} from "./chunk-OTCWA4QE.js";
+import {
+  time_reported_failure
+} from "./chunk-ZW6DLYS4.js";
+import {
+  cost_blocks,
+  time_josh_names,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  lane_handoff
+} from "./chunk-5QICRFVL.js";
+import {
+  agent_event
+} from "./chunk-LULJUD6P.js";
+import {
+  run_ship_detach
+} from "./chunk-Z7C2O5JC.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  transcript_record
+} from "./chunk-O3NDWYNT.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  EPIC_LABEL,
+  NEEDS_DECISION_LABEL,
+  NEEDS_HUMAN_MERGE_LABEL,
+  NOT_BEFORE_LABEL,
+  PRIORITY_CRITICAL_LABEL,
+  RUN_SOLO_LABEL,
+  RUN_STALLED_LABEL,
+  has_label_name,
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  lane_reap
+} from "./chunk-VFW6XZH7.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  run_carry,
+  run_carry_conversation
+} from "./chunk-JSJS3OT7.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/event/run-event-baseline.ts
+var MERGES_PATTERN = /^baseline @(?<merges>\d+) merges: (?<rest>.*)$/u;
+var STARTED_PREFIX = "started \u2014 ";
+var FAILED_PREFIX = "baseline investigation failed: ";
+function merges_text(merges, rest) {
+  return `baseline @${String(merges)} merges: ${rest}`;
+}
+function started_text(merges, outcome) {
+  return merges_text(merges, `${STARTED_PREFIX}${outcome}`);
+}
+function ended_text(merges, result) {
+  return merges_text(merges, result);
+}
+function failed_text(note) {
+  return `${FAILED_PREFIX}${note}`;
+}
+function merges_note(merges, rest) {
+  if (rest.startsWith(STARTED_PREFIX)) {
+    return { kind: "started", merges, outcome: rest.slice(STARTED_PREFIX.length) };
+  }
+  return { kind: "ended", merges, result: rest };
+}
+function parse(text) {
+  const note = text.slice(FAILED_PREFIX.length);
+  if (text.startsWith(FAILED_PREFIX)) return { kind: "failed", note };
+  const groups = MERGES_PATTERN.exec(text)?.groups;
+  return groups ? merges_note(Number(groups["merges"]), groups["rest"] ?? "") : void 0;
+}
+var run_event_baseline = { ended_text, failed_text, parse, started_text };
+
+// scripts/lane/lane-overrun-prompt.ts
+var MAX_FILINGS = 5;
+var MIN_MINUTES = 1;
+var PRIORITY_COMMAND = "pnpm josh issue:priority <N>";
+function duplicate_lines(loss_lines) {
+  return [
+    "On a duplicate refusal, read each candidate with `pnpm josh issue:read <N>`: one that only fixes",
+    "another mechanism, or is only cited, is distinct \u2014 reissue with `--distinct <N,\u2026>`; an open one that",
+    "fixes the same mechanism is not filed again but gets a comment recording the recurrence with those four",
+    `and ${loss_lines}, and gets those lines added under its background heading too, the cause-loss line`,
+    `appended beside the ones already there, since ranking sums every \`${issue_priority.CAUSE_PREFIX}\` line`,
+    "and reads only the body (`gh api -X PATCH repos/{owner}/{repo}/issues/<N> -F body=@<file>`). Then",
+    `run \`${PRIORITY_COMMAND}\`, which labels it once the sum reaches the high floor. One`,
+    "closed before this lane yet recurring here is filed anew as a recurrence, its number in `--distinct`.",
+    "A cap refusal is final: stop filing."
+  ];
+}
+function file_command(origin) {
+  if (origin === void 0) return "pnpm josh issue:file";
+  return `pnpm josh issue:file --found-during ${String(origin)}`;
+}
+function grouping(origin, loss_lines) {
+  return [
+    "Causes whose fixes touch the same file or mechanism are one issue, an acceptance criterion per",
+    "cause; causes fixed in different places are separate issues. Before filing one, look for an open",
+    'issue that touches the same files (`pnpm josh issue:scout "<title>" --body-file <draft.md>`, each',
+    "candidate read with `pnpm josh issue:read <N>`): when one does, fold its causes into it by",
+    "`.claude/skills/workflow-commands/issue-fold-existing.md` instead of filing, the appended part",
+    `carrying ${loss_lines}; on a verdict other than \`fold\`, file as below.`,
+    "File each other issue with",
+    `\`${file_command(origin)}\`, its body carrying those four per cause, and`,
+    `${loss_lines} under its background heading, the cause-loss minutes being what that issue's own`,
+    "causes would cut \u2014 backlog ranking orders one priority by them, else by the lane's minutes, which every",
+    "cause of the lane shares, so a filing without either falls behind every declared one."
+  ].join(" ");
+}
+function selection_lines(scope) {
+  const limit = `${String(MAX_FILINGS)} causes`;
+  return [
+    `Estimate each cause's reducible minutes: what its fix would cut from ${scope}. Time the work`,
+    "inherently takes (a CI wait the pipeline requires, a review) counts only for the part a fix removes,",
+    "and not at all when no fix removes any.",
+    `Take at most the ${limit} with the most reducible minutes, largest first, each cutting`,
+    `${String(MIN_MINUTES)} minute or more, and drop the rest: file or fold only those.`,
+    "File a defect \u2014 a tool did something unneeded or wrong (a rerun on an unchanged tree, a lost scope)",
+    `\u2014 as \`${issue_body_keys.line("kind", "bug")}\`, any other cause as \`${issue_body_keys.line("purpose", "time_saving")}\`.`
+  ];
+}
+var MEASUREMENT_LINES = [
+  "Measure a reach test count \u2014 the test files `pnpm josh test:related` runs for a changed file \u2014 with",
+  "`pnpm josh test:reach <file\u2026>`.",
+  "Put a measurement criterion (a before / after recorded as an Issue comment) in a prior `--route split`",
+  "issue, never in the issue that carries the fix."
+];
+function result_lines(template) {
+  return [
+    `Then record the result: \`pnpm josh run:event --append note "${template}"\`,`,
+    `the result being \`${run_event_overrun.folded_result(["<A>", "<B>"])}\` naming every issue you folded into`,
+    `when you folded any, else \`${run_event_overrun.FILED_RESULT}\` when you filed any, \`${run_event_overrun.recurred_result("<N>")}\``,
+    `when you only commented a recurrence on #<N>, else \`${run_event_overrun.none_result("<why, in about 15 characters>")}\`.`
+  ];
+}
+function cause_handling(rules) {
+  return [
+    ...selection_lines(rules.scope),
+    grouping(rules.origin, rules.loss_lines),
+    ...MEASUREMENT_LINES,
+    ...duplicate_lines(rules.loss_lines),
+    ...result_lines(rules.template)
+  ].join(" ");
+}
+function loss_lines_of(issue, minutes) {
+  const cite = issue_cite.plain_for("program", issue);
+  return `\`${issue_priority.LANE_PREFIX} ${minutes} \u5206\uFF08${cite}\uFF09\` and \`${issue_priority.CAUSE_PREFIX} <\u5206> \u5206\``;
+}
+var STAGE_ORDER = [
+  "Search for causes stage by stage, in the order of the net time by stage above, longest first.",
+  `For each stage you judge not reducible, end the result with \`${run_event_overrun.NOT_REDUCIBLE_LEAD}<stage> (<why>)\`.`
+].join(" ");
+function handling(issue, minutes) {
+  const rules = cause_handling({
+    origin: issue,
+    loss_lines: loss_lines_of(issue, String(minutes)),
+    template: run_event_overrun.ended_text(issue, "<result>"),
+    scope: "this lane alone, judged from its own record"
+  });
+  return `${STAGE_ORDER} ${rules}`;
+}
+var lane_overrun_prompt = { cause_handling, handling, loss_lines_of };
+
+// scripts/lane/lane-overrun.ts
+var { EVENT_KIND } = run_event_stream;
+var { DISABLED_REASON } = run_event_overrun;
+var LOG_PREFIX = "josh-lane-overrun-";
+var LOG_SUFFIX = ".log";
+var NO_LEDGER = "no ledger";
+var MAX_LAUNCH_FAILURES = 2;
+function overrun_notes(events) {
+  return events.flatMap(
+    (event) => event.kind === EVENT_KIND.NOTE ? run_event_overrun.parse(event.text) ?? [] : []
+  );
+}
+function is_thrown(note) {
+  return note.kind === "failed" && note.minutes === void 0;
+}
+function is_launch_failure(note) {
+  return note.kind === "failed" && note.minutes !== void 0;
+}
+function is_final(note) {
+  return !is_thrown(note) && !is_launch_failure(note);
+}
+function is_noted(events, issue) {
+  const notes = overrun_notes(events).filter((note) => note.issue === issue);
+  const failures = notes.filter((note) => is_launch_failure(note)).length;
+  return failures >= MAX_LAUNCH_FAILURES || notes.some((note) => is_final(note));
+}
+function retried_lanes(events, issue) {
+  const latest = new Map(overrun_notes(events).map((note) => [note.issue, note]));
+  latest.delete(issue);
+  return [...latest.values()].filter((note) => is_launch_failure(note) && !is_noted(events, note.issue)).map((note) => note.issue);
+}
+function is_commented(events, issue) {
+  return overrun_notes(events).some((note) => note.issue === issue);
+}
+function net_in(path2, events, issue) {
+  const entries = lane_ledger_archive.history_at(path2);
+  const minutes = lane_net_time.net_minutes(entries, events, issue);
+  const breakdown = lane_breakdown.of(entries, events, issue);
+  if (minutes === void 0 || breakdown === void 0) {
+    return { kind: "missing", reason: lane_net_time.missing_reason(entries, issue) };
+  }
+  return {
+    kind: "minutes",
+    minutes,
+    breakdown,
+    entries,
+    events,
+    is_commented: is_commented(events, issue)
+  };
+}
+async function net_of(issue) {
+  const events = await run_event_stream_emit.all_events();
+  if (is_noted(events, issue)) return void 0;
+  const path2 = await lane_ledger.target();
+  return path2 === void 0 ? { kind: "missing", reason: NO_LEDGER } : net_in(path2, events, issue);
+}
+function reading(issue, cite, minutes) {
+  const directories = lane_breakdown_implement.transcript_directories(issue).join(", ") || "none found";
+  return [
+    `Investigate why lane ${cite} took ${String(minutes)} minutes of net time (dispatch to merge, less`,
+    "its waits on a person and on outages). Leave this checkout as it is: write any file, an issue body",
+    "included, under the system temp directory, and never stage, commit or push.",
+    `Read the lane's transcripts (${directories}), its ship log (\`pnpm josh ship --log ${String(issue)}\`)`,
+    "and the run events (`pnpm josh run:event --from 0`), and find the causes that spent time other than",
+    "waiting. Trace each cause to what can fix it: the span it spent, the signal that led to the wrong call",
+    "or the wait (which command printed what), the `file:line` of the code or document that decided it, and",
+    "where to fix it."
+  ].join(" ");
+}
+function prompt(issue, minutes, report) {
+  const reads = reading(issue, issue_cite.plain_for("program", issue), minutes);
+  const stages = lane_breakdown_text.line(report);
+  return `${stages} ${reads} ${lane_overrun_prompt.handling(issue, minutes)}`;
+}
+function note_failure(issue) {
+  return (note) => {
+    void run_event_stream_emit.emit(EVENT_KIND.NOTE, run_event_overrun.failed_text(issue, note));
+  };
+}
+function launch(investigation) {
+  const cwd = process.cwd();
+  const built = agent_argv.resolve_in(investigation.prompt, agent_profile_schema.WORKER, cwd);
+  if (built.kind === "rejected") return `not investigated: ${built.note}`;
+  const request = {
+    argv: built.argv,
+    cwd,
+    env: investigation.env,
+    log_path: stamp_file.stamp_path(investigation.log_prefix, PROJECT_ROOT, LOG_SUFFIX),
+    profile: built.profile
+  };
+  const result = detached_launch.launch(request, investigation.on_failure);
+  return result.kind === "launched" ? run_event_overrun.investigating(result.pid, process_identity.read_start(result.pid)) : `not investigated: ${result.note}`;
+}
+function launched(issue, minutes, report) {
+  return launch({
+    env: lane_child_marker.overrun_env_for(String(issue)),
+    prompt: prompt(issue, minutes, report),
+    log_prefix: `${LOG_PREFIX}${String(issue)}-`,
+    on_failure: note_failure(issue)
+  });
+}
+async function overran_text(issue, net) {
+  const breakdown = lane_breakdown_implement.breakdown_of(net.entries, net.events, issue) ?? net.breakdown;
+  const report = lane_breakdown_text.report_of(issue, breakdown, net.entries, net.events);
+  const comment = lane_breakdown_text.comment(issue, net.minutes, report);
+  if (!net.is_commented) await git_gh_issue_write.issue_try_comment(String(issue), comment);
+  const outcome = launched(issue, net.minutes, report);
+  const longest = lane_breakdown.longest_of(breakdown);
+  return run_event_overrun.started_text(issue, net.minutes, outcome, longest);
+}
+async function note_text(issue, net) {
+  if (net.kind === "missing") return run_event_overrun.skipped_text(issue, net.reason);
+  const is_over = lane_tail_stats.is_overrun(net.minutes);
+  if (!is_over) return run_event_overrun.within_text(issue, net.minutes);
+  if (!lane_investigation_switch.is_on()) {
+    return run_event_overrun.skipped_text(issue, DISABLED_REASON);
+  }
+  return await overran_text(issue, net);
+}
+async function investigate_lane(issue) {
+  const net = await net_of(issue);
+  if (net === void 0) return;
+  await run_event_stream_emit.emit(EVENT_KIND.NOTE, await note_text(issue, net));
+}
+async function guarded(issue, pass) {
+  try {
+    await pass(issue);
+  } catch (error) {
+    note_failure(issue)(detached_launch.note_of(error));
+  }
+}
+async function investigate_with_retries(issue) {
+  await investigate_lane(issue);
+  const retried = retried_lanes(await run_event_stream_emit.all_events(), issue);
+  for (const lane of retried) {
+    await guarded(lane, investigate_lane);
+  }
+}
+async function investigate(issue) {
+  const pass = lane_investigation_switch.is_on() ? investigate_with_retries : investigate_lane;
+  await guarded(issue, pass);
+}
+var lane_overrun = { investigate, launch };
+
+// scripts/lane/lane-baseline.ts
+var { EVENT_KIND: EVENT_KIND2 } = run_event_stream;
+var BASELINE_MERGES = 30;
+var LOG_PREFIX2 = "josh-lane-baseline-";
+var STATS_PERIOD_DAYS = 3;
+var MEDIAN_PLACEHOLDER = "<median lane minutes>";
+var SCOPE = "the median merge, judged from the per-merge minutes `lane:stats` prints";
+function due_bucket(merges) {
+  return Math.floor(merges / BASELINE_MERGES) * BASELINE_MERGES;
+}
+function is_noted2(events, merges) {
+  return events.some((event) => {
+    const note = event.kind === EVENT_KIND2.NOTE ? run_event_baseline.parse(event.text) : void 0;
+    return note !== void 0 && note.kind !== "failed" && note.merges === merges;
+  });
+}
+async function due_merges() {
+  const path2 = await lane_ledger.target();
+  if (path2 === void 0) return void 0;
+  const merges = lane_ledger.read_entries(path2).filter((entry) => lane_stage_stats.is_merge(entry));
+  const bucket = due_bucket(merges.length);
+  return bucket > 0 ? bucket : void 0;
+}
+function reading2(merges) {
+  return [
+    `Investigate the median lane after ${String(merges)} merges: not an overrun, but the time every lane`,
+    "spends. Leave this checkout as it is: write any file, an issue body included, under the system temp",
+    "directory, and never stage, commit or push.",
+    `Read \`pnpm josh lane:stats --period ${String(STATS_PERIOD_DAYS)}\` \u2014 its stage table and its`,
+    "implement sub-stage table \u2014 and take the several stages and sub-stages with the largest per-merge",
+    "time, not just the one largest. Read the period lanes' transcripts (the lane directories `lane:stats`",
+    "reads) and the run events (`pnpm josh run:event --from 0`) for where each one's time goes, and find",
+    "the causes a fix could cut.",
+    "Trace each cause to what can fix it: the minutes it spends per merge, the signal that led to the",
+    "spend (which command printed what), the `file:line` of the code or document that decided it, and",
+    "where to fix it."
+  ].join(" ");
+}
+function prompt2(issue, merges) {
+  const handling2 = lane_overrun_prompt.cause_handling({
+    origin: void 0,
+    loss_lines: lane_overrun_prompt.loss_lines_of(issue, MEDIAN_PLACEHOLDER),
+    template: run_event_baseline.ended_text(merges, "<result>"),
+    scope: SCOPE
+  });
+  return `${reading2(merges)} ${handling2}`;
+}
+function note_failure2(note) {
+  void run_event_stream_emit.emit(EVENT_KIND2.NOTE, run_event_baseline.failed_text(note));
+}
+function launched2(issue, merges) {
+  return lane_overrun.launch({
+    env: {},
+    prompt: prompt2(issue, merges),
+    log_prefix: `${LOG_PREFIX2}${String(merges)}-`,
+    on_failure: note_failure2
+  });
+}
+async function investigate_baseline(issue) {
+  const merges = await due_merges();
+  if (merges === void 0 || is_noted2(await run_event_stream_emit.all_events(), merges)) return;
+  await run_event_stream_emit.emit(
+    EVENT_KIND2.NOTE,
+    run_event_baseline.started_text(merges, launched2(issue, merges))
+  );
+}
+async function investigate2(issue) {
+  if (!lane_investigation_switch.is_on()) return;
+  try {
+    await investigate_baseline(issue);
+  } catch (error) {
+    note_failure2(detached_launch.note_of(error));
+  }
+}
+var lane_baseline = { due_bucket, investigate: investigate2 };
+
+// scripts/run/merge/run-merge.ts
+var CLOSED_STATE = "CLOSED";
+var CONSECUTIVE_FAILURE_LIMIT = 3;
+var CONSECUTIVE_OUTAGE_LIMIT = 3;
+var OUTAGE_WAIT_BASE_MS = 3e5;
+var OUTAGE_WAIT_CAP_MS = 36e5;
+var DOUBLING = 2;
+var ONE = 1;
+var NO_SIGNALS = { is_outage: false, is_cut: false };
+function is_closed(state) {
+  return state.state.toUpperCase() === CLOSED_STATE;
+}
+function is_parked(state) {
+  return has_parked_label(state.labels);
+}
+function environment_outcome(signals) {
+  if (signals.is_auth_failure === true) return "unauthenticated";
+  if (signals.resume_ms !== void 0) return "usage-limit";
+  return signals.is_outage ? "outage" : "failed";
+}
+function unfinished_outcome(signals) {
+  if (signals.merged_pr !== void 0) return "merged";
+  if (signals.is_cut) return "cut";
+  return environment_outcome(signals);
+}
+function open_outcome(state, signals) {
+  if (state.is_human_review || has_label_name(state.labels, NEEDS_HUMAN_MERGE_LABEL)) {
+    return "human-review";
+  }
+  if (has_label_name(state.labels, EPIC_LABEL)) return "split";
+  if (is_parked(state)) return "parked";
+  return unfinished_outcome(signals);
+}
+function state_outcome(state, signals) {
+  return is_closed(state) ? "merged" : open_outcome(state, signals);
+}
+function classify_child(state, signals = NO_SIGNALS) {
+  if (signals.is_yielded === true) return "yielded";
+  if (signals.is_withdrawn === true) return "withdrawn";
+  return state === void 0 ? "unresolved" : state_outcome(state, signals);
+}
+function change_of(outcome) {
+  if (outcome === "merged") return { merged: ONE };
+  if (outcome === "failed") return { failures: ONE };
+  if (outcome === "outage") return { outages: ONE };
+  return void 0;
+}
+function is_guard_tripped(failures) {
+  return failures > 0 && failures % CONSECUTIVE_FAILURE_LIMIT === 0;
+}
+function is_outage_guard_tripped(outages2) {
+  return outages2 >= CONSECUTIVE_OUTAGE_LIMIT;
+}
+function outage_wait_ms(outages2) {
+  const doublings = Math.max(0, outages2 - CONSECUTIVE_OUTAGE_LIMIT);
+  return Math.min(OUTAGE_WAIT_BASE_MS * DOUBLING ** doublings, OUTAGE_WAIT_CAP_MS);
+}
+function counters_comment(carry) {
+  return [
+    "Run progress (generated from the carry record):",
+    `- started: ${carry.started_at}`,
+    `- merged: ${String(carry.merged)}`,
+    `- filed: ${String(carry.filed)}`,
+    `- consecutive failures: ${String(carry.failures)}`,
+    `- consecutive outages: ${String(carry.outages)}`,
+    `- cuts crossed: ${String(carry.cuts)}`
+  ].join("\n");
+}
+function streak_line(carry) {
+  if (carry === void 0) return "- Consecutive failures: not recorded (no carry record).";
+  return `- Consecutive failures: ${String(carry.failures)} of ${String(CONSECUTIVE_FAILURE_LIMIT)} (every ${String(CONSECUTIVE_FAILURE_LIMIT)} in a row checks \`main\`).`;
+}
+function park_comment(reason) {
+  const transcript = reason.output === void 0 ? "" : ` (\`${reason.output}\`)`;
+  return [
+    `Parked with \`${RUN_STALLED_LABEL}\` by \`pnpm josh run:merge\`, the \`backlogrun\` driver \u2014 a mechanical failure, with no decision to make.`,
+    `- Why: ${reason.cause}`,
+    "- Read: the issue is OPEN, carries no park label, `needs-human-review` or `epic`, no merged pull request\u2019s `closes #N` names it, and it declares no open blocker, start date still ahead or sample condition not yet met.",
+    streak_line(reason.carry),
+    `- Next: read the child\u2019s transcript${transcript}, ${run_stalled.next_step(reason.child, reason.cause)}.`
+  ].join("\n");
+}
+function waiting_comment(waits) {
+  return [
+    "Released to wait by `pnpm josh run:merge`, the `backlogrun` driver \u2014 not parked, and not counted as a failure.",
+    `- Why: the child\u2019s session ended unfinished while it waits on: ${waits.join(", ")}.`,
+    "- Next: when it runs is already recorded \u2014 it becomes runnable again once its blockers merge, its start date arrives and its sample condition is met; a blocker outside the backlog still needs a person to land it."
+  ].join("\n");
+}
+var run_merge = {
+  CONSECUTIVE_FAILURE_LIMIT,
+  CONSECUTIVE_OUTAGE_LIMIT,
+  change_of,
+  classify_child,
+  counters_comment,
+  park_comment,
+  waiting_comment,
+  is_guard_tripped,
+  is_outage_guard_tripped,
+  outage_wait_ms
+};
+
+// scripts/run/merge/run-merge-auth.ts
+var LIMIT = "authentication failure";
+var RECHECK_MS = 6e5;
+var RECHECK_TEXT = "10 minutes";
+var RECOVERY = "If this did not arrive, `pnpm josh run:wake --list` relays the last progress line.";
+async function is_first_hold() {
+  const events = await run_event_stream_emit.current_events();
+  return run_event_stream.since(events, run_event_stream.EVENT_KIND.MERGE).every(
+    (event) => !(event.kind === run_event_stream.EVENT_KIND.USAGE_LIMIT && event.text.includes(LIMIT))
+  );
+}
+async function notify(child) {
+  const cite = issue_cite.plain_for("telegram", child);
+  const text = `${cite} could not authenticate \u2014 run /login; the run resumes by itself`;
+  await telegram_notify.confirm({
+    issue_title: "backlogrun waiting: Claude authentication failed",
+    body: `${text}. Launches are held and re-tried every ${RECHECK_TEXT}; the child was released, neither parked nor counted as a failure.`,
+    recovery: RECOVERY,
+    recommended: "Run /login",
+    alternatives: ["Stop the run with `pnpm josh backlogrun --stop`"]
+  });
+}
+async function hold(child, now_ms) {
+  const is_first = await is_first_hold();
+  await run_merge_usage_limit.record(child, now_ms + RECHECK_MS, LIMIT);
+  if (is_first) await notify(child);
+}
+var run_merge_auth = { hold };
+
+// scripts/run/merge/run-merge-dated.ts
+var KIND = run_event_stream.EVENT_KIND;
+function is_own(event, cite) {
+  return event.text.startsWith(`${cite} `);
+}
+function is_report_done(event) {
+  if (event.kind !== KIND.SHIP_STAGE) return false;
+  const { stage, phase } = run_ship_stage.words_of(event.text);
+  return stage === run_ship_stage.STAGE.REPORT && phase === run_ship_stage.PHASE.DONE;
+}
+function is_bound(event) {
+  return event.kind === KIND.CHILD_LAUNCH || is_report_done(event);
+}
+function reported_at(events, child) {
+  const cite = issue_cite.plain_for("program", child);
+  const bound = events.findLast((event) => is_own(event, cite) && is_bound(event));
+  return bound !== void 0 && is_report_done(bound) ? Date.parse(bound.at) : void 0;
+}
+function dated(events, child, confirmed_at) {
+  const reported = reported_at(events, child);
+  if (reported === void 0 || reported >= confirmed_at.getTime()) return confirmed_at;
+  return new Date(reported);
+}
+async function put_on_record(child, confirmed_at) {
+  const text = `${issue_cite.plain_for("program", child)} merged`;
+  const events = await run_event_stream_emit.invocation_or_all_events();
+  if (events.some((event) => event.kind === KIND.MERGE && event.text === text)) return;
+  const at = dated(events, child, confirmed_at);
+  await run_event_stream_emit.emit(KIND.MERGE, text, at);
+  await lane_ledger_write.record_merge(Number(child), at);
+}
+var run_merge_dated = { dated, put_on_record };
+
+// scripts/run/merge/run-merge-decision.ts
+import { z } from "zod";
+var HOOK_CONFIRMATION = "\u{1F4F1} stop:guard sent the confirmation notify (";
+var INPUT_SCHEMA = z.object({ command: z.string() });
+var AWAITING_CONFIRMATION = /(?:確認|回答|返答|承認)(?:[をの]?待っています|待ちです|後に(?:続行|再開)します)/u;
+var COMMAND_SCHEMA = z.looseObject({
+  type: z.literal("item.completed"),
+  item: z.looseObject({
+    type: z.literal("command_execution"),
+    command: z.string(),
+    exit_code: z.literal(0),
+    aggregated_output: z.string().optional()
+  })
+});
+function confirms(line) {
+  if (line.startsWith(HOOK_CONFIRMATION)) return true;
+  const command = COMMAND_SCHEMA.safeParse(json_value.parse_or_undefined(line));
+  return command.success && lane_park.is_confirmation_notify(command.data.item.command);
+}
+function asks(message) {
+  return AWAITING_CONFIRMATION.test(message) || stop_decision.contains_question(message);
+}
+function successful_last(command) {
+  const joined = shell_segments.joined_continuations(command);
+  const plain = time_shell.blanked(joined);
+  if (plain === void 0 || plain.includes("\n")) return void 0;
+  const comment = plain.search(/(?:^|[\s;|&])#/u);
+  const end = comment === -1 ? joined.length : comment;
+  const syntax = plain.slice(0, end);
+  if (/[;|&\n]/u.test(syntax.replaceAll("&&", ""))) return void 0;
+  return shell_segments.quote_aware_commands_of(joined.slice(0, end)).at(-1);
+}
+function is_entry(command) {
+  for (let next = command; next !== ""; ) {
+    const last = successful_last(next) ?? "";
+    const script = bash_triggers.shell_script_of(last);
+    if (script === void 0) {
+      return time_josh_names.josh_command_of_segment(time_shell.unquoted(last)) === "josh run:entry";
+    }
+    next = script;
+  }
+  return false;
+}
+function entry_ids(latest) {
+  const records = latest.split("\n").flatMap((line) => transcript_record.parse(line) ?? []);
+  const calls = records.filter((record) => record.type === "assistant").flatMap((record) => transcript_record.tool_calls_of(record));
+  const entries = calls.filter(
+    (block) => block.name === "Bash" && is_entry(INPUT_SCHEMA.safeParse(block.input).data?.command ?? "")
+  );
+  return new Set(entries.flatMap((block) => block.id ?? []));
+}
+function is_entry_result(block, ids) {
+  return block?.type === transcript_record.TOOL_RESULT_TYPE && block.is_error !== true && ids.has(block.tool_use_id ?? "");
+}
+function claude_output(line, ids) {
+  const record = transcript_record.parse(line);
+  if (record?.type !== "user") return "";
+  const blocks = transcript_record.blocks_of(record);
+  return cost_blocks.parse_line(line).filter((_block, index) => is_entry_result(blocks[index], ids)).map((block) => block.text).join("\n");
+}
+function tool_output(line, ids) {
+  const command = COMMAND_SCHEMA.safeParse(json_value.parse_or_undefined(line));
+  if (!command.success) return claude_output(line, ids);
+  return is_entry(command.data.item.command) ? command.data.item.aggregated_output ?? "" : "";
+}
+function unfinished(latest, message) {
+  const ids = entry_ids(latest);
+  const outputs = latest.split("\n").map((line) => tool_output(line, ids)).join("\n");
+  const resumes = [...outputs.matchAll(/^entry [^\n]+ — resume: ([\w-]+)$/gmu)];
+  return resumes.at(-1)?.[1] === "handed-off" ? run_stalled.STALE_HANDOFF : run_stalled.session_unfinished(message);
+}
+function judged(transcript) {
+  const latest = run_ship_detach.last_launch(transcript);
+  const message = agent_event.read(latest).last_message ?? "";
+  const is_confirmed = latest.split("\n").some((line) => confirms(line));
+  if (!is_confirmed && !asks(message)) return unfinished(latest, message);
+  return {
+    short: NEEDS_DECISION_LABEL,
+    why: message || "The child sent a confirmation notification."
+  };
+}
+function cause(output) {
+  const transcript = output === void 0 ? void 0 : run_ending.read_transcript(output);
+  return transcript === void 0 ? run_stalled.SESSION_UNFINISHED : judged(transcript);
+}
+function is_decision(short) {
+  return short === NEEDS_DECISION_LABEL;
+}
+function park_event(child, short) {
+  return is_decision(short) ? `${issue_cite.plain_for("program", child)} parked (${NEEDS_DECISION_LABEL})` : run_stalled.park_event(child, short);
+}
+function park_comment2(judgment) {
+  return [
+    `Parked with \`${NEEDS_DECISION_LABEL}\` by \`pnpm josh run:merge\`: the child waits for your answer.`,
+    `- Decision: ${judgment.why}`,
+    "- Consecutive failures: unchanged.",
+    "- Next: answer the question on this issue, then remove `needs-decision` to resume."
+  ].join("\n");
+}
+function park_options(judgment, reason) {
+  return is_decision(judgment.short) ? { label: NEEDS_DECISION_LABEL, comment: park_comment2(judgment) } : { label: RUN_STALLED_LABEL, comment: run_merge.park_comment(reason) };
+}
+function is_guard_tripped2(short, carry) {
+  if (is_decision(short)) return false;
+  return carry !== void 0 && run_merge.is_guard_tripped(carry.failures);
+}
+var run_merge_decision = { cause, is_decision, is_guard_tripped: is_guard_tripped2, park_event, park_options };
+
+// scripts/run/merge/run-merge-health.ts
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { execa } from "execa";
+var TITLE = "Repair the verification gate failing on main";
+var OUTPUT_TAIL_LINES = 20;
+var STATIC_CHECK = { args: ["josh", "gate", "--no-unit"], env: { CI: "true" } };
+var UNIT_CHECK = { args: ["josh", "test:unit"], env: {} };
+var COMMANDS = "`CI=true pnpm josh gate --no-unit` and `pnpm josh test:unit`";
+function is_filed(events) {
+  return run_event_stream.since(events, run_event_stream.EVENT_KIND.MERGE).some(
+    (event) => event.kind === run_event_stream.EVENT_KIND.FILED && run_event_filed.parse(event.text)?.title === TITLE
+  );
+}
+var DECLARATIONS = [
+  issue_body_keys.heading("summary"),
+  "",
+  "**The verification gate fails on `main`, so every lane is held until it is repaired.**",
+  "",
+  "Several lanes failed one after another, and the same verification then failed on `main` twice in a row, so the cause is on `main` rather than in any one lane. Fix whatever makes the verification fail on `main`; the output is under the reproduction below.",
+  "",
+  issue_body_keys.heading("background"),
+  "",
+  issue_body_keys.line("kind", "bug"),
+  issue_body_keys.line("purpose", "bug_fix"),
+  issue_body_keys.line("judgement", "not_needed"),
+  `${issue_body_keys.line("origin", "unknown")}\uFF08found by the backlogrun health check, not traced yet\uFF09`,
+  `${issue_body_keys.prefix("size")} ${issue_body_keys.size_value("1", "20")}`
+];
+var SYMPTOM = [
+  issue_body_keys.heading("symptom"),
+  "",
+  `${COMMANDS} fail on \`main\`, twice in a row.`
+];
+var EXPECTED = [
+  issue_body_keys.heading("expected"),
+  "",
+  `${COMMANDS} pass on \`main\`.`,
+  "",
+  issue_body_keys.heading("criteria"),
+  "",
+  `- [ ] ${COMMANDS} pass on \`main\`.`
+];
+function body_of(child, output) {
+  const tail = output.split("\n").slice(-OUTPUT_TAIL_LINES).join("\n");
+  const origin = `Filed by \`pnpm josh run:merge\` after ${issue_cite.plain_for("github", child)}: a streak of children failed, and the whole-tree verification on \`main\` failed too, so it is broken for every lane.`;
+  const reproduction = [
+    issue_body_keys.heading("reproduction"),
+    "",
+    `${COMMANDS} on \`main\`:`,
+    "",
+    "```text",
+    tail,
+    "```"
+  ];
+  return [...DECLARATIONS, "", origin, "", ...SYMPTOM, "", ...reproduction, "", ...EXPECTED].join(
+    "\n"
+  );
+}
+async function file_solo(child, output) {
+  const directory = await mkdtemp(path.join(tmpdir(), "josh-health-"));
+  const body_file = path.join(directory, "body.md");
+  const answers = ["--defect", "yes", "--verification", "yes", "--every-run", "yes"];
+  const labels = ["--label", RUN_SOLO_LABEL, "--label", PRIORITY_CRITICAL_LABEL];
+  await writeFile(body_file, body_of(child, output));
+  const filing = await execa(
+    "pnpm",
+    ["josh", "issue:file", TITLE, "--body-file", body_file, ...labels, ...answers, "--over-cap"],
+    { reject: false, all: true, stdin: "ignore" }
+  );
+  if (filing.exitCode !== 0) {
+    console.error(`run:merge: the run:solo Issue was not filed:
+${filing.all}`);
+  }
+}
+async function red_output(health_check) {
+  const result = await execa("pnpm", health_check.args, {
+    reject: false,
+    all: true,
+    stdin: "ignore",
+    env: health_check.env
+  });
+  return result.exitCode === 0 ? void 0 : result.all;
+}
+async function verification_red() {
+  return await red_output(STATIC_CHECK) ?? await red_output(UNIT_CHECK);
+}
+async function check(child) {
+  if (await verification_red() === void 0) return true;
+  const output = await verification_red();
+  if (output === void 0) return true;
+  if (!is_filed(await run_event_stream_emit.current_events())) await file_solo(child, output);
+  return false;
+}
+var run_merge_health = { TITLE, body_of, check };
+
+// scripts/run/merge/run-merge-cut-release.ts
+async function release(child) {
+  const lane = await lane_registry.find_open_lane(child);
+  if (lane === void 0) return;
+  const carried = run_cut.lane_cut_sync(lane.directory);
+  if (carried === void 0) return;
+  run_cut_adoption.release(carried.target, carried.cut, child);
+}
+var run_merge_cut_release = { release };
+
+// scripts/run/merge/run-merge-human-review.ts
+async function retain(issue) {
+  const retained = await lane_state.record_change({
+    issue,
+    state: "human-review",
+    command: "run:merge"
+  });
+  if (retained.kind !== "written") return false;
+  if (lane_await.process_trace_default(issue) === "none") {
+    await run_merge_cut_release.release(issue);
+  }
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.HUMAN_REVIEW,
+    `${issue_cite.plain_for("program", issue)} waiting for human review`
+  );
+  return true;
+}
+var run_merge_human_review = { retain };
+
+// scripts/agent/usage-limit-reset.ts
+var RESET_PATTERN = /resets (?<when>[^(]*)\((?<zone>[^)]*)\)/iu;
+var TIME_PATTERN = /\b(?<hour>\d{1,2})(?::(?<minute>\d{2}))? ?(?<meridiem>am|pm)\b/iu;
+var DATE_PATTERN = /\b(?<month>[a-z]+)\.? (?<day>\d{1,2})\b/iu;
+var MONTH_PREFIX = 3;
+var EPOCH_PATTERN = /\|(?<epoch>\d{10})\b/u;
+var MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = 6e4;
+var HALF_YEAR_MS = 157788e5;
+var HOURS_PER_HALF_DAY = 12;
+var PM = "pm";
+var NOT_FOUND = -1;
+function epoch_ms(text) {
+  const epoch = EPOCH_PATTERN.exec(text)?.groups?.["epoch"];
+  return epoch === void 0 ? void 0 : Number(epoch) * MS_PER_SECOND;
+}
+function dated2(groups) {
+  const month = MONTHS.indexOf(String(groups["month"]).slice(0, MONTH_PREFIX).toLowerCase());
+  return month === NOT_FOUND ? void 0 : { month, day: Number(groups["day"]) };
+}
+function date_of(when) {
+  const groups = DATE_PATTERN.exec(when)?.groups;
+  return groups === void 0 ? void 0 : dated2(groups);
+}
+function hour_of(time) {
+  const half = time["meridiem"]?.toLowerCase() === PM ? HOURS_PER_HALF_DAY : 0;
+  return Number(time["hour"]) % HOURS_PER_HALF_DAY + half;
+}
+function wall_of(when, zone) {
+  const time = TIME_PATTERN.exec(when)?.groups;
+  if (time === void 0) return void 0;
+  return { date: date_of(when), hour: hour_of(time), minute: Number(time["minute"] ?? 0), zone };
+}
+function zone_format(zone) {
+  return new Intl.DateTimeFormat("en-US", {
+    timeZone: zone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric"
+  });
+}
+function zone_fields(at_ms, zone) {
+  const parts = zone_format(zone).formatToParts(at_ms);
+  const read2 = new Map(parts.map((part) => [part.type, Number(part.value)]));
+  function field(type) {
+    return read2.get(type) ?? 0;
+  }
+  return {
+    year: field("year"),
+    month: field("month") - 1,
+    day: field("day"),
+    hour: field("hour"),
+    minute: field("minute")
+  };
+}
+function utc_of(fields) {
+  return Date.UTC(fields.year, fields.month, fields.day, fields.hour, fields.minute);
+}
+function offset_ms(at_ms, zone) {
+  return utc_of(zone_fields(at_ms, zone)) - (at_ms - at_ms % MS_PER_MINUTE);
+}
+function instant_of(fields, zone) {
+  const guess = utc_of(fields);
+  return guess - offset_ms(guess - offset_ms(guess, zone), zone);
+}
+function year_shift(at_ms, now_ms) {
+  if (now_ms - at_ms > HALF_YEAR_MS) return 1;
+  return at_ms - now_ms > HALF_YEAR_MS ? -1 : 0;
+}
+function dated_instant(fields, zone, now_ms) {
+  const at_ms = instant_of(fields, zone);
+  const shift = year_shift(at_ms, now_ms);
+  return shift === 0 ? at_ms : instant_of({ ...fields, year: fields.year + shift }, zone);
+}
+function undated_instant(fields, zone, now_ms) {
+  const at_ms = instant_of(fields, zone);
+  return at_ms > now_ms ? at_ms : instant_of({ ...fields, day: fields.day + 1 }, zone);
+}
+function next_instant(wall, now_ms) {
+  const today = zone_fields(now_ms, wall.zone);
+  const fields = { ...today, ...wall.date, hour: wall.hour, minute: wall.minute };
+  if (wall.date === void 0) return undated_instant(fields, wall.zone, now_ms);
+  return dated_instant(fields, wall.zone, now_ms);
+}
+function wall_in(text) {
+  const groups = RESET_PATTERN.exec(text)?.groups;
+  if (groups === void 0) return void 0;
+  return wall_of(String(groups["when"]), String(groups["zone"]).trim());
+}
+function known_instant(wall, now_ms) {
+  try {
+    return next_instant(wall, now_ms);
+  } catch {
+    return void 0;
+  }
+}
+function clock_ms(text, now_ms) {
+  const wall = wall_in(text);
+  return wall === void 0 ? void 0 : known_instant(wall, now_ms);
+}
+function reset_ms(text, now_ms) {
+  return epoch_ms(text) ?? clock_ms(text, now_ms);
+}
+var usage_limit_reset = { reset_ms };
+
+// scripts/agent/api-usage-limit.ts
+var LIMIT_PATTERN = /hit your (?:\w+ )?limit|usage limit reached/u;
+var RECHECK_MS2 = 18e5;
+function limit_reason(record) {
+  if (record === void 0 || !record.is_error || record.reason === void 0) return void 0;
+  return LIMIT_PATTERN.test(record.reason.toLowerCase()) ? record.reason : void 0;
+}
+function is_usage_limit(record) {
+  return limit_reason(record) !== void 0;
+}
+function or_recheck(reset_ms3, now_ms) {
+  return reset_ms3 === void 0 || reset_ms3 <= now_ms ? now_ms + RECHECK_MS2 : reset_ms3;
+}
+function resume_ms(record, now_ms, stopped_ms = now_ms) {
+  const reason = limit_reason(record);
+  if (reason === void 0) return void 0;
+  return or_recheck(usage_limit_reset.reset_ms(reason, stopped_ms), now_ms);
+}
+function transcript_resume_ms(log, now_ms, stopped_ms = now_ms) {
+  if (log === void 0 || !agent_exit_record.ends_on_exit_record(log)) return void 0;
+  return resume_ms(agent_exit_record.read_exit_record(log), now_ms, stopped_ms);
+}
+var api_usage_limit = { RECHECK_MS: RECHECK_MS2, is_usage_limit, resume_ms, transcript_resume_ms };
+
+// scripts/run/merge/run-merge-ship.ts
+var ENDED_RESULTS = /* @__PURE__ */ new Set(["failed", "abnormal"]);
+function since_ship_launch(events, child) {
+  const attempt = run_event_scope.since_own_launch(events, child);
+  const own = attempt.filter((event) => run_event_scope.issue_named(event) === child);
+  const launched_at = own.findLastIndex(
+    (event) => event.kind === run_event_stream.EVENT_KIND.SHIP_LAUNCH
+  );
+  return launched_at === -1 ? void 0 : own.slice(launched_at + 1);
+}
+function stop_cause(stop2) {
+  const stage = run_ship_stop_text.reason_of(stop2.text);
+  return {
+    short: stage === void 0 ? "ship stopped" : `${stage} failed`,
+    why: `its detached ship stopped and was not fixed: ${stop2.text}.`
+  };
+}
+function cause_of(ending, events, child) {
+  if (ending === void 0 || !ENDED_RESULTS.has(ending.result)) return void 0;
+  const attempt = since_ship_launch(events, child);
+  if (attempt === void 0) return void 0;
+  const stop2 = attempt.findLast((event) => event.kind === run_event_stream.EVENT_KIND.SHIP_STOP);
+  if (stop2 !== void 0) return stop_cause(stop2);
+  return {
+    short: `ship ${ending.result}`,
+    why: `its detached ship ended ${ending.result} before recording a stopped stage \u2014 pnpm josh ship --log ${child}.`
+  };
+}
+function cause2(child, directory = process.cwd()) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return void 0;
+  const events = run_event_stream.read_events(run_event_stream.target_of(repository));
+  return cause_of(run_ship_detach.read_result(repository, child), events, child);
+}
+function is_relaunch_failed(event) {
+  return event.kind === run_event_stream.EVENT_KIND.RELAUNCH_FAILED;
+}
+function is_stop_unanswered(ending, attempt, written_at) {
+  const index = attempt.findLastIndex(
+    (event) => event.kind === run_event_stream.EVENT_KIND.SHIP_STOP
+  );
+  const stop2 = attempt[index];
+  if (stop2 === void 0) return ending?.result === "abnormal";
+  if (attempt.slice(index + 1).some((event) => is_relaunch_failed(event))) return true;
+  return written_at !== void 0 && written_at < Date.parse(stop2.at);
+}
+function interrupted_of(ending, events, child, written_at) {
+  if (ending === void 0 || !ENDED_RESULTS.has(ending.result)) return false;
+  const attempt = since_ship_launch(events, child);
+  return attempt !== void 0 && is_stop_unanswered(ending, attempt, written_at);
+}
+function is_interrupted(child, written_at, directory = process.cwd()) {
+  const repository = git_common_directory.repository(directory);
+  if (repository === void 0) return false;
+  const events = run_event_stream.read_events(run_event_stream.target_of(repository));
+  return interrupted_of(run_ship_detach.read_result(repository, child), events, child, written_at);
+}
+async function is_unanswered(child, output) {
+  if (output === void 0 || !is_interrupted(child, run_ending.written_at(output))) return false;
+  const lane = await lane_registry.find_open_lane(child);
+  return lane !== void 0 && !lane_relaunch.is_openai_lane(lane);
+}
+var run_merge_ship = { cause: cause2, cause_of, interrupted_of, is_unanswered };
+
+// scripts/run/merge/run-merge-cap.ts
+var NO_RELAUNCH_FAILURE = "none was recorded";
+function is_own2(event, kind, child) {
+  return event.kind === kind && run_event_scope.issue_named(event) === child;
+}
+function outages(events, child) {
+  return events.filter((event) => is_own2(event, run_event_stream.EVENT_KIND.OUTAGE, child)).length;
+}
+function last_relaunch_failure(events, child) {
+  const kind = run_event_stream.EVENT_KIND.RELAUNCH_FAILED;
+  const failed = events.findLast((event) => is_own2(event, kind, child));
+  return failed === void 0 ? NO_RELAUNCH_FAILURE : failed.text;
+}
+function note_of(events, child, limit) {
+  const count = outages(events, child);
+  const failure = last_relaunch_failure(events, child);
+  return `it reached the re-dispatch cap (${String(limit)}) after ${String(count)} re-dispatches; the last failed relaunch: ${failure}.`;
+}
+function park_cause(child, cause3, note, output) {
+  if (cause3 !== void 0) return cause3;
+  const judged2 = run_merge_decision.cause(output);
+  const stopped = run_merge_decision.is_decision(judged2.short) ? judged2 : run_merge_ship.cause(child) ?? judged2;
+  if (note === void 0) return stopped;
+  return { short: stopped.short, why: `${note} ${stopped.why}` };
+}
+var run_merge_cap = { note_of, outages, park_cause };
+
+// scripts/run/merge/run-merge-github-limit.ts
+var RATE_LIMIT = "rate-limit";
+var TAIL_LINES = 20;
+var RATE_LIMIT_PATTERN = /^(?:gh|graphql|http 403|http 429): .*(?:api rate limit (?:already )?exceeded|secondary rate limit)/mu;
+var AUTH_PATTERN = /^http 401: |^(?:try authenticating with|to get started with github cli, please run): +gh auth login/mu;
+function error_texts(line) {
+  const record = transcript_record.parse(line);
+  if (record?.type !== "user") return [];
+  return transcript_record.blocks_of(record).filter((block) => block.type === transcript_record.TOOL_RESULT_TYPE && block.is_error === true).map((block) => time_reported_failure.result_text(block.content));
+}
+function tail_errors(log) {
+  const lines = log.trimEnd().split("\n").slice(-TAIL_LINES);
+  return lines.flatMap((line) => error_texts(line)).join("\n").toLowerCase();
+}
+function stop_of(log) {
+  if (log === void 0 || !agent_exit_record.ends_on_exit_record(log)) return void 0;
+  const tail = tail_errors(log);
+  if (RATE_LIMIT_PATTERN.test(tail)) return RATE_LIMIT;
+  return AUTH_PATTERN.test(tail) ? "auth" : void 0;
+}
+function read_stop(output) {
+  if (output === void 0) return void 0;
+  return stop_of(run_ending.read_transcript(output));
+}
+function is_exhausted(limit, now_ms) {
+  return limit?.remaining === 0 && limit.reset_ms > now_ms;
+}
+async function reset_ms2(now_ms) {
+  const resources = await gh_core_rate_limit.read_resources();
+  const limits = [resources?.core, resources?.graphql];
+  const exhausted = limits.find((limit) => is_exhausted(limit, now_ms));
+  return exhausted?.reset_ms ?? now_ms + api_usage_limit.RECHECK_MS;
+}
+async function hold2(child, output) {
+  if (read_stop(output) !== RATE_LIMIT) return;
+  await run_merge_usage_limit.record(child, await reset_ms2(Date.now()), "GitHub rate limit");
+}
+var run_merge_github_limit = { hold: hold2, read_stop, reset_ms: reset_ms2, stop_of };
+
+// scripts/run/merge/run-merge-restart.ts
+import { uptime } from "node:os";
+var MS_PER_SECOND2 = 1e3;
+function booted_ms() {
+  try {
+    return Date.now() - uptime() * MS_PER_SECOND2;
+  } catch {
+    return void 0;
+  }
+}
+function has_exit_record(output) {
+  const transcript = output === void 0 ? void 0 : run_ending.read_transcript(output);
+  return transcript !== void 0 && agent_exit_record.ends_on_exit_record(transcript);
+}
+async function is_host_restart(child, output) {
+  if (has_exit_record(output)) return false;
+  const lane = await lane_registry.find_open_lane(child);
+  const dispatched_ms = lane?.dispatched_ms;
+  if (dispatched_ms === void 0) return false;
+  const boot_ms = booted_ms();
+  return boot_ms !== void 0 && dispatched_ms < boot_ms;
+}
+var run_merge_restart = { is_host_restart };
+
+// scripts/lane/lane-seat-stop.ts
+async function stop(issue) {
+  const lane = await lane_registry.lane_location(issue);
+  const reaped = lane_reap.reap_child(lane);
+  lane_residents.end_residents(lane, reaped);
+  const survivors = await lane_reap_settle.settle(lane);
+  if (survivors?.length === 0) return;
+  const details = lane_reap_settle.survivor_texts(survivors).join(", ");
+  throw new Error(`Lane ${issue} port ownership has not settled: ${details}`);
+}
+var lane_seat_stop = { stop };
+
+// scripts/run/merge/run-merge-close.ts
+var MERGE_CLOSER = "pnpm josh run:merge";
+var SINGLE_READ = { attempts: 1, interval_ms: 0 };
+async function close_merged_open(merged) {
+  if (merged.merged_pr === void 0) return true;
+  try {
+    await git_followup_issue_close.ensure_issue_closed(
+      { issue_number: merged.child, pr_url: merged.merged_pr, closer: MERGE_CLOSER },
+      SINGLE_READ
+    );
+    return true;
+  } catch {
+    console.error(
+      `${session_cite.issue(merged.child)}: could not be closed \u2014 ${git_followup_issue_close.CLOSE_RECOVERY}`
+    );
+    return false;
+  }
+}
+function divert_info_to_stderr() {
+  const { info } = console;
+  console.info = console.error;
+  return function restore() {
+    console.info = info;
+  };
+}
+async function with_notes_on_stderr(step) {
+  const restore = divert_info_to_stderr();
+  try {
+    await step();
+  } finally {
+    restore();
+  }
+}
+async function close_merged(merged) {
+  if (!await close_merged_open(merged)) return;
+  await with_notes_on_stderr(async () => {
+    await epic_close.close_completed_epics({ issue_number: merged.child, is_merged: true });
+  });
+}
+var run_merge_close = { close_merged };
+
+// scripts/run/merge/run-merge-waits.ts
+var NOT_BEFORE_WAIT = "a start date still ahead (`not-before`)";
+async function open_blockers(child) {
+  try {
+    const references = await git_gh_command.issue_blocked_by_references(child, "");
+    return references.filter((blocker) => blocker.state === "OPEN").map((blocker) => issue_cite.plain_for("github", blocker.number, blocker.repo));
+  } catch {
+    return [];
+  }
+}
+async function has_not_before_label(ctx) {
+  const state = await issue_state_cli.read_issue(ctx.child, ctx.repo);
+  return state.kind === "state" && has_label_name(state.state.labels, NOT_BEFORE_LABEL);
+}
+async function start_date_wait(ctx) {
+  const body = await git_gh_command.issue_get_body(ctx.child, ctx.repo);
+  if (body === void 0) {
+    return [await has_not_before_label(ctx) ? NOT_BEFORE_WAIT : "issue body confirmation"];
+  }
+  await issue_sample_prime.prime([body]);
+  const reason = issue_not_before.waiting_reason(body);
+  return reason === void 0 ? [] : [reason];
+}
+async function read(ctx) {
+  const deferred = await lane_dispatch_dependency.deferred(ctx.child);
+  if (deferred.length > 0) return deferred;
+  return [...await open_blockers(ctx.child), ...await start_date_wait(ctx)];
+}
+var run_merge_waits = { read };
+
+// scripts/run/merge/run-merge-steps.ts
+var OVER = "over";
+var LANES = "--lanes";
+var REPO_FLAG = "--repo";
+var CLOSE_CAUSE = "`run:merge` closed it";
+var STOPPED_CAUSE = "the unit stopped and `run:merge --stash` classified it";
+var SYNC_RETRY = { attempts: 3, interval_ms: 5e3 };
+var NO_WAITS = [];
+async function josh(args) {
+  return await josh_command.josh_run(args);
+}
+async function read_record() {
+  const directory = await run_carry.repository_directory();
+  if (directory === void 0) return void 0;
+  const target = run_carry.carry_path(directory);
+  const read2 = run_carry.read_carry(target);
+  if (read2.kind !== "carried") return void 0;
+  return { target, carry: read2.carry };
+}
+async function apply_carry(ctx, change) {
+  const record = await read_record();
+  if (record === void 0) return { kind: "none" };
+  if (run_carry.is_count_refused(record.carry, ctx.owner)) {
+    return { kind: "refused", carry: record.carry };
+  }
+  if (change === void 0) return { kind: "applied", carry: record.carry };
+  const owned = run_carry_conversation.reclaim_owner(record.carry, ctx.owner);
+  return { kind: "applied", carry: run_carry.apply_change(record.target, owned, change) };
+}
+async function refused_carry(ctx) {
+  const record = await read_record();
+  if (record === void 0 || !run_carry.is_count_refused(record.carry, ctx.owner)) return void 0;
+  return record.carry;
+}
+async function sync_main() {
+  let error_output = "";
+  const is_synced = await poll.poll_until(
+    async () => {
+      const result = await josh(["main:sync"]);
+      error_output = result.err ?? "";
+      return result.code === 0;
+    },
+    { ...SYNC_RETRY, sleeper: poll.sleep }
+  );
+  if (!is_synced) throw new Error(`main:sync failed: ${error_output}`);
+}
+async function close_lane(child) {
+  const result = await josh(["lane:close", child]);
+  const said = result.err?.trimEnd() ?? "";
+  if (said !== "") console.error(said);
+  if (result.code !== 0) console.error(`${session_cite.issue(child)}: lane:close is incomplete`);
+}
+async function close_preserved_lane(child) {
+  if (await lane_preserve.preserve_lane(child, "lane close", CLOSE_CAUSE)) await close_lane(child);
+}
+function kept_lane_comment(directory) {
+  return `The split left this issue's lane open: it still holds a commit, an uncommitted change or a live process \u2014 ${directory}`;
+}
+async function close_vacant_lane(child) {
+  const lane = await lane_registry.find_open_lane(child);
+  if (lane === void 0) return void 0;
+  if (!await lane_vacant.is_vacant(lane)) return lane;
+  await close_lane(child);
+  return void 0;
+}
+async function close_split_lane(child) {
+  const kept = await close_vacant_lane(child);
+  if (kept !== void 0) {
+    await git_gh_issue_write.issue_try_comment(child, kept_lane_comment(kept.directory));
+  }
+}
+async function post_counters(ctx, carry) {
+  if (carry === void 0 || ctx.epic === void 0) return;
+  await git_gh_issue_write.issue_try_comment(ctx.epic, run_merge.counters_comment(carry));
+}
+async function count_merged(ctx) {
+  return await apply_carry(ctx, {
+    ...run_merge.change_of("merged"),
+    merged_issue: Number(ctx.child)
+  });
+}
+async function do_merged(ctx, record) {
+  const refused = await refused_carry(ctx);
+  if (refused !== void 0) return refused;
+  const confirmed_at = /* @__PURE__ */ new Date();
+  await settled_together(run_merge_close.close_merged(ctx), sync_main());
+  const result = await count_merged(ctx);
+  if (result.kind === "refused") return result.carry;
+  await record(ctx.child, confirmed_at);
+  const carry = result.kind === "applied" ? result.carry : void 0;
+  await Promise.all([close_preserved_lane(ctx.child), post_counters(ctx, carry)]);
+  return void 0;
+}
+async function release_child(child) {
+  await lane_seat_stop.stop(child);
+  await run_merge_cut_release.release(child);
+  await run_label.unmark(child);
+  await close_vacant_lane(child);
+}
+function refused_result(carry) {
+  return { carry, is_parked: false, is_refused: true, waits: NO_WAITS };
+}
+async function do_waiting(ctx, waits) {
+  const refused = await refused_carry(ctx);
+  if (refused !== void 0) return refused_result(refused);
+  await release_child(ctx.child);
+  await git_gh_issue_write.issue_try_comment(ctx.child, run_merge.waiting_comment(waits));
+  return { carry: void 0, is_parked: false, is_refused: false, waits };
+}
+async function park_failed(ctx, cause3) {
+  const is_decision2 = run_merge_decision.is_decision(cause3.short);
+  const result = await apply_carry(ctx, run_merge.change_of(is_decision2 ? "parked" : "failed"));
+  if (result.kind === "refused") return refused_result(result.carry);
+  const carry = result.kind === "applied" ? result.carry : void 0;
+  await release_child(ctx.child);
+  const reason = { child: ctx.child, cause: cause3.why, carry, output: ctx.output };
+  const { label, comment } = run_merge_decision.park_options(cause3, reason);
+  const park = await issue_park.apply(ctx.child, label, comment);
+  return {
+    carry,
+    is_parked: park.is_labelled,
+    is_refused: false,
+    waits: NO_WAITS,
+    cause: cause3.short
+  };
+}
+async function do_failed(ctx, cause3) {
+  const waits = await run_merge_waits.read(ctx);
+  if (waits.length > 0) return await do_waiting(ctx, waits);
+  return await park_failed(
+    ctx,
+    run_merge_cap.park_cause(ctx.child, cause3, ctx.capped_note, ctx.output)
+  );
+}
+async function count_outage(ctx) {
+  if (ctx.is_streak_exempt !== true) return await apply_carry(ctx, run_merge.change_of("outage"));
+  const refused = await refused_carry(ctx);
+  return refused === void 0 ? { kind: "none" } : { kind: "refused", carry: refused };
+}
+async function do_outage(ctx) {
+  const result = await count_outage(ctx);
+  if (result.kind === "refused") return { carry: result.carry, is_refused: true };
+  await release_child(ctx.child);
+  await run_merge_github_limit.hold(ctx.child, ctx.output);
+  return { carry: result.kind === "applied" ? result.carry : void 0, is_refused: false };
+}
+async function relaunchable_lane(child) {
+  const lane = await lane_registry.find_open_lane(child);
+  return lane === void 0 || lane_relaunch.is_openai_lane(lane) ? void 0 : lane;
+}
+async function relaunchable_cut(child) {
+  const lane = await relaunchable_lane(child);
+  if (lane === void 0) return void 0;
+  const carried = run_cut.lane_cut_sync(lane.directory);
+  if (carried === void 0 || !run_cut.is_relaunchable(carried.cut, child)) return void 0;
+  return { lane, ...carried };
+}
+async function has_resumable_cut(child) {
+  return await relaunchable_cut(child) !== void 0;
+}
+async function stash_stopped(child) {
+  if (await has_resumable_cut(child)) return;
+  await lane_preserve.preserve_lane(child, "stopped unit", STOPPED_CAUSE);
+}
+async function resume_cut(child) {
+  const found = await relaunchable_cut(child);
+  if (found === void 0 || !run_cut.mark_merge_relaunched(found.target, found.cut)) return false;
+  const result = await lane_relaunch.resume(found.lane, found.cut.phase, (note) => {
+    console.error(note);
+  });
+  return result.kind === "launched";
+}
+async function is_over_budget(over) {
+  if (over === void 0) return false;
+  const result = await josh(["cost", "--cut"]);
+  return result.code !== 0 || result.out === OVER;
+}
+async function ask_next(ctx) {
+  if (ctx.epic === void 0 || ctx.repo === void 0) {
+    const backlog = await josh(["backlog:next"]);
+    return backlog.out;
+  }
+  const offer = await josh(["epic:next", ctx.epic, REPO_FLAG, ctx.repo, LANES]);
+  return offer.out;
+}
+var run_merge_steps = {
+  ask_next,
+  close_split_lane,
+  release_child,
+  do_failed,
+  do_merged,
+  do_outage,
+  has_resumable_cut,
+  is_over_budget,
+  read_record,
+  refused_carry,
+  resume_cut,
+  stash_stopped
+};
+
+// scripts/run/merge/run-merge-signals.ts
+function read_is_outage(output) {
+  if (output === void 0) return false;
+  if (api_outage.is_outage(run_ending.read_exit(output))) return true;
+  return run_ending.ended_mid_turn(output) || run_merge_github_limit.read_stop(output) === "auth";
+}
+async function is_exempt_stop(child, output) {
+  if (await run_merge_restart.is_host_restart(child, output)) return true;
+  return run_merge_github_limit.read_stop(output) === "rate-limit";
+}
+function read_is_auth_failure(output) {
+  if (output === void 0) return false;
+  return api_auth.is_auth_failed_transcript(run_ending.read_transcript(output));
+}
+async function retry_cause(child, output) {
+  if (await is_exempt_stop(child, output)) return "exempt";
+  if (read_is_outage(output)) return "api";
+  return await run_merge_ship.is_unanswered(child, output) ? "exempt" : void 0;
+}
+async function is_capped(child, cause3) {
+  const events = await run_event_stream_emit.current_events();
+  if (run_merge_cap.outages(events, child) < run_merge.CONSECUTIVE_OUTAGE_LIMIT) return false;
+  if (cause3 !== "api") return true;
+  const record = await run_merge_steps.read_record();
+  return !run_merge.is_outage_guard_tripped(record?.carry.outages ?? 0);
+}
+async function read_retryable(child, output) {
+  const cause3 = await retry_cause(child, output);
+  if (cause3 === void 0) return { is_outage: false, is_streak_exempt: false };
+  if (await is_capped(child, cause3)) {
+    const events = await run_event_stream_emit.current_events();
+    const limit = run_merge.CONSECUTIVE_OUTAGE_LIMIT;
+    return { is_outage: false, capped_note: run_merge_cap.note_of(events, child, limit) };
+  }
+  return { is_outage: true, is_streak_exempt: cause3 === "exempt" };
+}
+async function read_merged_pr(child, read2) {
+  if (read2.kind !== "state" || run_merge.classify_child(read2.state) !== "failed") return void 0;
+  return await issue_closing_pr.read_closing_pr(child);
+}
+async function read_is_withdrawn(child, read2) {
+  if (read2.kind !== "state" || run_merge.classify_child(read2.state) !== "merged") {
+    return run_event_scope.is_withdrawn(await run_event_stream_emit.current_events(), child);
+  }
+  const is_merged = await issue_merged.read_merge_state(child);
+  return is_merged === void 0 ? void 0 : !is_merged;
+}
+async function read_is_yielded(child) {
+  return lane_yield.is_yielded(await run_event_stream_emit.current_events(), child);
+}
+function read_resume_ms(output) {
+  if (output === void 0) return void 0;
+  const transcript = run_ending.read_transcript(output);
+  return api_usage_limit.transcript_resume_ms(transcript, Date.now(), run_ending.written_at(output));
+}
+async function read_signals(ctx, read2) {
+  const [is_cut, merged_pr, retryable, is_withdrawn, is_yielded] = await Promise.all([
+    run_merge_steps.has_resumable_cut(ctx.child),
+    read_merged_pr(ctx.child, read2),
+    read_retryable(ctx.child, ctx.output),
+    read_is_withdrawn(ctx.child, read2),
+    read_is_yielded(ctx.child)
+  ]);
+  const is_auth_failure = read_is_auth_failure(ctx.output);
+  const resume_ms2 = read_resume_ms(ctx.output);
+  return { ...retryable, is_cut, merged_pr, is_withdrawn, is_yielded, is_auth_failure, resume_ms: resume_ms2 };
+}
+function outcome_of(read2, signals) {
+  if (signals.is_withdrawn === void 0) return "unresolved";
+  return run_merge.classify_child(read2.kind === "state" ? read2.state : void 0, signals);
+}
+var run_merge_signals = { outcome_of, read_merged_pr, read_signals };
+
+// scripts/run/merge/run-merge-withdrawn.ts
+var UNMERGED_REASON = "its issue was closed without a merged pull request";
+var NOTHING_LEFT = { note: void 0, is_retry: false };
+async function collect(child) {
+  const events = await run_event_stream_emit.current_events();
+  if (run_event_scope.is_withdrawn(events, child)) return NOTHING_LEFT;
+  const lane = await lane_registry.find_open_lane(child);
+  return lane === void 0 ? NOTHING_LEFT : await lane_withdraw_closed.withdraw_lane(lane, UNMERGED_REASON, "merge");
+}
+async function collect_yield(child) {
+  const lane = await lane_registry.find_open_lane(child);
+  if (lane === void 0) return NOTHING_LEFT;
+  const reason = lane_yield.withdraw_reason(await run_event_stream_emit.current_events(), child);
+  return await lane_withdraw_closed.withdraw_lane(lane, reason, "yield");
+}
+var run_merge_withdrawn = { UNMERGED_REASON, collect, collect_yield };
+
+// scripts/run/merge/run-merge-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var FIRST = 0;
+var MIN_PID = 1;
+var { MERGE_TOKEN } = run_merge_token;
+var PARK_FAILURE_NOTE = `The failed child could not be parked with ${RUN_STALLED_LABEL}; stopping.`;
+var REPO_PATTERN = /^[A-Za-z0-9][\w.-]*\/[A-Za-z0-9][\w.-]*$/u;
+var USAGE = "Usage: josh run:merge <issue> [--over <deprecated>] [--epic <E> --repo <owner/repo>] [--owner <pid>] [--output <path>] [--driver] [--stash]";
+var OPTIONS = {
+  driver: { type: "boolean" },
+  stash: { type: "boolean" },
+  epic: { type: "string" },
+  output: { type: "string" },
+  over: { type: "string" },
+  owner: { type: "string" },
+  repo: { type: "string" }
+};
+function to_owner(raw) {
+  if (raw === void 0) return run_carry.session_owner();
+  const pid = cli_flags.to_count(raw);
+  return pid === void 0 || pid < MIN_PID ? void 0 : run_carry.owner_of(pid);
+}
+function is_epic_without_repo(values) {
+  return values.epic !== void 0 && values.repo === void 0;
+}
+function valid_epic(raw) {
+  if (raw === void 0) return void 0;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(raw) ? raw : void 0;
+}
+function valid_repo(raw) {
+  if (raw === void 0) return void 0;
+  return REPO_PATTERN.test(raw) ? raw : void 0;
+}
+function is_rejected(raw, valid) {
+  return raw !== void 0 && valid === void 0;
+}
+function has_invalid_offer(values) {
+  return is_epic_without_repo(values) || is_rejected(values.epic, valid_epic(values.epic)) || is_rejected(values.repo, valid_repo(values.repo));
+}
+function has_invalid_legacy_over(raw) {
+  if (raw === void 0) return false;
+  return cli_flags.to_count(raw) === void 0;
+}
+function valid_child(parsed) {
+  const child = parsed.positionals[FIRST];
+  if (child === void 0) return void 0;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(child) ? child : void 0;
+}
+function cut_check_of(values) {
+  return values.driver === true ? void 0 : true;
+}
+function to_context(parsed) {
+  if (has_invalid_offer(parsed.values) || has_invalid_legacy_over(parsed.values.over)) {
+    return void 0;
+  }
+  const child = valid_child(parsed);
+  if (child === void 0) return void 0;
+  const owner = to_owner(parsed.values.owner);
+  if (owner === void 0) return void 0;
+  return {
+    child,
+    epic: valid_epic(parsed.values.epic),
+    repo: valid_repo(parsed.values.repo),
+    over: cut_check_of(parsed.values),
+    owner,
+    output: parsed.values.output,
+    stash: parsed.values.stash
+  };
+}
+function parse2(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  return parsed === void 0 ? void 0 : to_context(parsed);
+}
+function emit(token, code) {
+  return { token, code, is_offer: false };
+}
+async function offered(ctx) {
+  const token = ctx.over === void 0 ? run_merge_driver.DEFERRED_OFFER : await run_merge_steps.ask_next(ctx);
+  return { token, code: SUCCESS_EXIT_CODE, is_offer: true };
+}
+function report_count_refused(carry) {
+  if (carry !== void 0) console.error(run_carry.count_refused_message(carry));
+  return emit(MERGE_TOKEN.BUSY, FAILURE_EXIT_CODE);
+}
+async function record_merged(ctx) {
+  return await run_merge_steps.do_merged(ctx, run_merge_dated.put_on_record);
+}
+async function on_merged(ctx) {
+  const refused = await record_merged(ctx);
+  if (refused !== void 0) return report_count_refused(refused);
+  await lane_overrun.investigate(Number(ctx.child));
+  await lane_baseline.investigate(Number(ctx.child));
+  if (await run_merge_steps.is_over_budget(ctx.over)) {
+    return emit(MERGE_TOKEN.OVER, SUCCESS_EXIT_CODE);
+  }
+  return await offered(ctx);
+}
+async function on_waiting(ctx, waits) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.PARK,
+    `${issue_cite.plain_for("program", ctx.child)} waiting on ${waits.join(", ")}`
+  );
+  return await offered(ctx);
+}
+async function on_parked_failure(ctx, result) {
+  if (!result.is_parked) {
+    console.error(PARK_FAILURE_NOTE);
+    return emit(MERGE_TOKEN.STOP, FAILURE_EXIT_CODE);
+  }
+  const cause3 = result.cause ?? run_merge_decision.cause(ctx.output).short;
+  const park = run_merge_decision.park_event(ctx.child, cause3);
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.PARK, park);
+  if (run_merge_decision.is_guard_tripped(cause3, result.carry)) {
+    await run_merge_health.check(ctx.child);
+  }
+  return { ...await offered(ctx), is_parked: true };
+}
+async function on_failed(ctx, cause3) {
+  const result = await run_merge_steps.do_failed(ctx, cause3);
+  if (result.is_refused) return report_count_refused(result.carry);
+  if (result.waits.length > 0) return await on_waiting(ctx, result.waits);
+  return await on_parked_failure(ctx, result);
+}
+async function on_outage(ctx) {
+  const result = await run_merge_steps.do_outage(ctx);
+  if (result.is_refused) return report_count_refused(result.carry);
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.OUTAGE,
+    `${issue_cite.plain_for("program", ctx.child)} outage (re-dispatchable)`
+  );
+  const outages2 = result.carry?.outages ?? 0;
+  if (run_merge.is_outage_guard_tripped(outages2)) {
+    await run_merge_usage_limit.record(
+      ctx.child,
+      Date.now() + run_merge.outage_wait_ms(outages2),
+      "api outage"
+    );
+  }
+  return await offered(ctx);
+}
+async function on_unauthenticated(ctx) {
+  await run_merge_steps.release_child(ctx.child);
+  await run_merge_auth.hold(ctx.child, Date.now());
+  return await offered(ctx);
+}
+async function on_usage_limit(ctx) {
+  await run_merge_steps.release_child(ctx.child);
+  await run_merge_usage_limit.record(ctx.child, ctx.resume_ms ?? Date.now());
+  return await offered(ctx);
+}
+async function on_cut(ctx) {
+  const refused = await run_merge_steps.refused_carry(ctx);
+  if (refused !== void 0) return report_count_refused(refused);
+  if (!await run_merge_steps.resume_cut(ctx.child)) {
+    return await on_failed(ctx, run_stalled.CUT_NOT_RELAUNCHED);
+  }
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.CHILD_LAUNCH,
+    `${issue_cite.plain_for("program", ctx.child)} resumed from its cut`
+  );
+  return emit(MERGE_TOKEN.RESUMED, SUCCESS_EXIT_CODE);
+}
+async function on_parked(ctx) {
+  await run_merge_steps.release_child(ctx.child);
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.PARK,
+    `${issue_cite.plain_for("program", ctx.child)} parked`
+  );
+  return await offered(ctx);
+}
+async function on_skipped(ctx) {
+  await run_merge_steps.close_split_lane(ctx.child);
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.SPLIT,
+    `${issue_cite.plain_for("program", ctx.child)} split`
+  );
+  return await offered(ctx);
+}
+async function on_collected(ctx, collected) {
+  if (collected.note !== void 0) console.error(collected.note);
+  if (collected.is_retry) return emit(MERGE_TOKEN.RETRY, FAILURE_EXIT_CODE);
+  return await offered(ctx);
+}
+async function on_withdrawn(ctx) {
+  return await on_collected(ctx, await run_merge_withdrawn.collect(ctx.child));
+}
+async function on_yielded(ctx) {
+  return await on_collected(ctx, await run_merge_withdrawn.collect_yield(ctx.child));
+}
+async function on_human_review(ctx) {
+  if (!await run_merge_human_review.retain(ctx.child)) {
+    return emit(MERGE_TOKEN.RETRY, FAILURE_EXIT_CODE);
+  }
+  return await offered(ctx);
+}
+async function on_unresolved() {
+  return emit(MERGE_TOKEN.RETRY, FAILURE_EXIT_CODE);
+}
+async function on_shipping() {
+  return emit(MERGE_TOKEN.RESUMED, SUCCESS_EXIT_CODE);
+}
+var HANDLERS = {
+  cut: on_cut,
+  failed: on_failed,
+  "human-review": on_human_review,
+  merged: on_merged,
+  outage: on_outage,
+  unauthenticated: on_unauthenticated,
+  "usage-limit": on_usage_limit,
+  parked: on_parked,
+  split: on_skipped,
+  unresolved: on_unresolved,
+  shipping: on_shipping,
+  withdrawn: on_withdrawn,
+  yielded: on_yielded
+};
+async function merge_child(ctx) {
+  if (lane_handoff.is_ship_running(ctx.child, process.cwd())) {
+    return { outcome: "shipping", ...await on_shipping() };
+  }
+  if (ctx.stash === true) await run_merge_steps.stash_stopped(ctx.child);
+  const read2 = await issue_state_cli.read_issue(ctx.child, ctx.repo);
+  const signals = await run_merge_signals.read_signals(ctx, read2);
+  const outcome = run_merge_signals.outcome_of(read2, signals);
+  const { merged_pr, is_streak_exempt, capped_note, resume_ms: resume_ms2 } = signals;
+  const handled = { ...ctx, merged_pr, is_streak_exempt, capped_note, resume_ms: resume_ms2 };
+  return { outcome, ...await HANDLERS[outcome](handled) };
+}
+async function run(argv) {
+  const ctx = parse2(argv);
+  if (ctx === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const result = await merge_child(ctx);
+  console.info(run_merge_driver.printed(argv, result));
+  return result.code;
+}
+var run_merge_cli = {
+  merge_child,
+  parse: parse2,
+  read_merged_pr: run_merge_signals.read_merged_pr,
+  record_merged,
+  run
+};
+
+export {
+  run_merge,
+  run_merge_cli
+};