@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/dist/commands/backlog-drive-cli.js

@@ -0,0 +1,2023 @@
+#!/usr/bin/env tsx
+import {
+  lane_hand_back_hold
+} from "./chunk-BJA5U4Q7.js";
+import {
+  backlog_arrival_added,
+  backlog_drive_listing
+} from "./chunk-UTHUX7VU.js";
+import {
+  backlog_drive_launch,
+  backlog_drive_launch_pass,
+  backlog_drive_owner,
+  backlog_drive_seats,
+  backlog_drive_trace,
+  backlog_drive_unit
+} from "./chunk-6YURRFRU.js";
+import "./chunk-AJWR7D3H.js";
+import {
+  lane_launch_cli
+} from "./chunk-LB557AHJ.js";
+import {
+  run_add,
+  run_add_issue
+} from "./chunk-YTBQAD5W.js";
+import {
+  run_park_release
+} from "./chunk-OGS2DK7I.js";
+import {
+  backlog_offer,
+  backlog_offer_cli
+} from "./chunk-KWYQR5MK.js";
+import "./chunk-KODXWMBX.js";
+import {
+  auto_ok_judge_read
+} from "./chunk-W7DRUOF7.js";
+import {
+  backlog_drive_retrospective
+} from "./chunk-P5SOYWH2.js";
+import {
+  backlog_drive_memory,
+  backlog_drive_named,
+  issue_human_stops
+} from "./chunk-4DN4XVPL.js";
+import {
+  backlog_drive_adopt
+} from "./chunk-24ZDAWML.js";
+import {
+  run_merge_driver
+} from "./chunk-4JI35CVO.js";
+import {
+  gh_core_rate_limit,
+  run_merge_token,
+  run_merge_usage_limit
+} from "./chunk-FHFWNNUC.js";
+import "./chunk-VV4TQYGD.js";
+import {
+  backlog_drive_args
+} from "./chunk-JHN6RCE6.js";
+import {
+  run_park_body
+} from "./chunk-UREXZJDB.js";
+import "./chunk-ZYGOZT4J.js";
+import "./chunk-QGATHT4S.js";
+import {
+  lane_plan_probe
+} from "./chunk-2QM72JCJ.js";
+import "./chunk-BTZJDHQT.js";
+import "./chunk-BCUDQWYK.js";
+import "./chunk-5CG3XU3O.js";
+import "./chunk-RUQY5TS3.js";
+import "./chunk-OP2RFVLS.js";
+import "./chunk-FWU3H4TX.js";
+import {
+  issue_state_cli
+} from "./chunk-BRHPRDDV.js";
+import "./chunk-M6JDU5EK.js";
+import "./chunk-4ZJOC6OK.js";
+import "./chunk-2CXT6MBR.js";
+import "./chunk-ZVAIIHBE.js";
+import "./chunk-4ZQM4I7R.js";
+import "./chunk-KZZWPUJW.js";
+import "./chunk-HRLGFRAV.js";
+import "./chunk-T4F33UKZ.js";
+import "./chunk-SASX3W2M.js";
+import {
+  backlog_ready
+} from "./chunk-M4UV3BEV.js";
+import {
+  backlog_hold_codes
+} from "./chunk-ZAAHZY2A.js";
+import "./chunk-ELY76WAR.js";
+import "./chunk-KCFOP5RI.js";
+import "./chunk-EYMPBHDN.js";
+import "./chunk-MFBNNTBM.js";
+import "./chunk-TYNH2R66.js";
+import "./chunk-EFDVE5P5.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import "./chunk-77BIN247.js";
+import "./chunk-ANUTT56I.js";
+import "./chunk-OX3VQLV2.js";
+import {
+  backlog_plan_comment
+} from "./chunk-AVVMDVGO.js";
+import "./chunk-5UJGACVN.js";
+import {
+  auto_ok_author,
+  auto_ok_cli
+} from "./chunk-FMZWRDKH.js";
+import "./chunk-SRG6PKVS.js";
+import "./chunk-7MJYLUF4.js";
+import {
+  issue_not_before
+} from "./chunk-FKZ5E4JD.js";
+import "./chunk-A4HOQKOG.js";
+import "./chunk-SSL6A3Y4.js";
+import "./chunk-COGKULQH.js";
+import "./chunk-QDFVVRQP.js";
+import "./chunk-KZSM5M5P.js";
+import "./chunk-CQUZ6TNQ.js";
+import {
+  epic_issue
+} from "./chunk-IAD4WLLI.js";
+import "./chunk-6NGNMIMT.js";
+import "./chunk-34JJYCIY.js";
+import "./chunk-BMM4RHCG.js";
+import "./chunk-JAKC2BHX.js";
+import "./chunk-B3M5WSGN.js";
+import "./chunk-SADJPNDB.js";
+import "./chunk-6RUWU2SB.js";
+import {
+  josh_command
+} from "./chunk-2VRITY55.js";
+import "./chunk-HH3CVIFU.js";
+import "./chunk-HLKAFSN4.js";
+import "./chunk-FDS65XOJ.js";
+import "./chunk-EXDFKKMH.js";
+import "./chunk-OL6IF4JC.js";
+import "./chunk-J3TKZLHA.js";
+import "./chunk-XZQWEVR3.js";
+import "./chunk-FURNDIT3.js";
+import "./chunk-D7JRJI44.js";
+import "./chunk-AXXEMVRJ.js";
+import "./chunk-D6D6WQR6.js";
+import "./chunk-XI2ABCRX.js";
+import "./chunk-VDGNXSP3.js";
+import "./chunk-AK7SEO4Y.js";
+import {
+  telegram_notify
+} from "./chunk-WJ4NEDNI.js";
+import "./chunk-7YZXS3AK.js";
+import "./chunk-S4X5PJV7.js";
+import "./chunk-5HVYOIIK.js";
+import "./chunk-6TIVDEKG.js";
+import "./chunk-ILIITIMQ.js";
+import "./chunk-3RIQ36LH.js";
+import "./chunk-2ADQ5XRD.js";
+import "./chunk-7IZJ5MG2.js";
+import "./chunk-HXCZ3KWS.js";
+import "./chunk-QGAERR7D.js";
+import "./chunk-MWO6FOSZ.js";
+import {
+  backlog_drive_restore,
+  backlog_offer_exclude,
+  run_event_retry
+} from "./chunk-TFLHYC2F.js";
+import {
+  lane_yield
+} from "./chunk-EGIHAEMT.js";
+import "./chunk-IBAYXCMU.js";
+import "./chunk-TAEGXID2.js";
+import "./chunk-HI5WPM6C.js";
+import "./chunk-2FJJYCBD.js";
+import "./chunk-QABRNGQV.js";
+import "./chunk-QX2R6UJG.js";
+import {
+  git_gh_command,
+  git_gh_pr_snapshot
+} from "./chunk-YGFOGA7C.js";
+import "./chunk-U7XU5RG3.js";
+import {
+  git_gh_repo
+} from "./chunk-GJYMI2CM.js";
+import "./chunk-AJ65WNJB.js";
+import "./chunk-23GH6B3D.js";
+import "./chunk-HXDTA5VU.js";
+import "./chunk-CQZI7RIK.js";
+import {
+  backlog_overlap,
+  lane_plan
+} from "./chunk-B7ZNIEDV.js";
+import {
+  issue_read
+} from "./chunk-2BB5ZR2F.js";
+import "./chunk-BJKEXXY6.js";
+import "./chunk-UWLLZQJB.js";
+import "./chunk-WAEN2RTT.js";
+import "./chunk-NEGRE5VW.js";
+import "./chunk-HE5S4XRE.js";
+import "./chunk-LAR76BFA.js";
+import "./chunk-Y27PTXXI.js";
+import "./chunk-GUR54ELE.js";
+import "./chunk-CFHRNTE5.js";
+import "./chunk-EKLU6QR7.js";
+import "./chunk-BMKWSWWE.js";
+import "./chunk-WMMGXJXP.js";
+import "./chunk-W6MVQEMO.js";
+import "./chunk-T25S4QHL.js";
+import "./chunk-TJKM56WJ.js";
+import "./chunk-RVUJ6F5L.js";
+import "./chunk-MY3RSOS5.js";
+import "./chunk-KVURNO74.js";
+import "./chunk-QHWJJ6X5.js";
+import "./chunk-U7Y6RKLK.js";
+import "./chunk-Q6SKKQVJ.js";
+import "./chunk-KK2SL42W.js";
+import "./chunk-PE7B7242.js";
+import "./chunk-KIILCKQR.js";
+import "./chunk-WWVYEHQT.js";
+import "./chunk-JZK33TA5.js";
+import "./chunk-QOSC5RKD.js";
+import "./chunk-JFLFGLE4.js";
+import "./chunk-K64EIHD2.js";
+import "./chunk-FGL6DBZU.js";
+import "./chunk-P3H3DKTE.js";
+import "./chunk-RUIBQMOV.js";
+import "./chunk-OZZWRJQI.js";
+import "./chunk-MVHPRYHE.js";
+import "./chunk-NFPD2P3V.js";
+import "./chunk-CGLLAEKZ.js";
+import "./chunk-WL5JHB3I.js";
+import "./chunk-SV4FZR24.js";
+import "./chunk-34KZDKQJ.js";
+import "./chunk-OOWGH2RG.js";
+import "./chunk-7LJQMM2K.js";
+import "./chunk-FROACLVU.js";
+import "./chunk-MGF64OHV.js";
+import "./chunk-JM6EVOFN.js";
+import "./chunk-KGE4AS2Y.js";
+import "./chunk-LX7TIEMI.js";
+import "./chunk-OF4BY4N7.js";
+import "./chunk-RXAZJMSZ.js";
+import "./chunk-3PEXBHRN.js";
+import "./chunk-5ZNUH4LV.js";
+import "./chunk-PBOS7MTW.js";
+import "./chunk-2NSB5ZYQ.js";
+import "./chunk-CWCKCZS6.js";
+import "./chunk-IW6NWCSN.js";
+import "./chunk-UCI4AL3Q.js";
+import "./chunk-2EZTYLO4.js";
+import "./chunk-NU7W6QGT.js";
+import "./chunk-DEZF7QZZ.js";
+import {
+  lane_sampler
+} from "./chunk-XXC32PVL.js";
+import {
+  lane_await
+} from "./chunk-IB5TT73I.js";
+import "./chunk-ZNR75OXP.js";
+import {
+  run_event_setup
+} from "./chunk-I2KCGKJI.js";
+import "./chunk-E33LSO2W.js";
+import "./chunk-Y2RNUX4W.js";
+import "./chunk-7C7FOKJK.js";
+import "./chunk-CBAKBWSZ.js";
+import "./chunk-DPJVKTO4.js";
+import "./chunk-C54QXJD6.js";
+import "./chunk-FCINBCKB.js";
+import "./chunk-Q5Q2QYVU.js";
+import "./chunk-GO3GH7FG.js";
+import "./chunk-KVHNQHX3.js";
+import "./chunk-7HCPRVMB.js";
+import "./chunk-RSSJWMQS.js";
+import "./chunk-HQGNXR6I.js";
+import "./chunk-KXK2A2HB.js";
+import {
+  run_stalled_park
+} from "./chunk-Y4EBUI6M.js";
+import {
+  issue_park
+} from "./chunk-OIX2363L.js";
+import {
+  run_stalled
+} from "./chunk-S4M6UWR2.js";
+import {
+  agent_worker_profile
+} from "./chunk-FVDQNMP6.js";
+import {
+  git_gh_issue_write
+} from "./chunk-RN2YDNLF.js";
+import "./chunk-RW64VHEB.js";
+import "./chunk-6UCWAFQY.js";
+import "./chunk-DYZOOWVW.js";
+import "./chunk-6I2JM5UX.js";
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import "./chunk-NDWZTWXV.js";
+import "./chunk-3WWQFCGX.js";
+import "./chunk-LAYSCY4L.js";
+import "./chunk-N7QTMTST.js";
+import "./chunk-7HAGC6SW.js";
+import "./chunk-6CJXLPRI.js";
+import "./chunk-OJ65BZBV.js";
+import "./chunk-LHKXJD6L.js";
+import {
+  REQUIRED_CHECKS,
+  absent_required,
+  collect_blocking_failures,
+  is_mergeable_state,
+  parse_pr_state_snapshot
+} from "./chunk-WVR4RUFP.js";
+import "./chunk-ROJXMBXP.js";
+import "./chunk-DBKTFB5V.js";
+import {
+  hook_decision
+} from "./chunk-RLBFEHHC.js";
+import "./chunk-LQXFVZTS.js";
+import "./chunk-EMTZAGT5.js";
+import "./chunk-TCBUX52E.js";
+import "./chunk-KXHXMERX.js";
+import "./chunk-MDLOETXL.js";
+import "./chunk-NFKULY26.js";
+import "./chunk-JTU5A4JI.js";
+import "./chunk-65E4OZJ7.js";
+import {
+  lane_process_table,
+  lane_registry,
+  lane_snapshot_trace
+} from "./chunk-452HWOJ7.js";
+import "./chunk-BYFC6MD2.js";
+import {
+  DEFAULT_SILENT_MINUTES,
+  PROCESS_ALIVE
+} from "./chunk-3AEDZZNL.js";
+import "./chunk-LULJUD6P.js";
+import "./chunk-TBNQIFWL.js";
+import "./chunk-XFPEUYDV.js";
+import "./chunk-5ZTQX7OS.js";
+import "./chunk-G4E4M2P4.js";
+import "./chunk-C2SEDMZ3.js";
+import {
+  git_gh_issue_read
+} from "./chunk-ENKFCOVY.js";
+import "./chunk-6OP63TBT.js";
+import "./chunk-TVZXG4Y4.js";
+import "./chunk-FIUCHMCF.js";
+import "./chunk-4PUKDAXL.js";
+import "./chunk-W3FX7FYN.js";
+import "./chunk-ZBFNQUY7.js";
+import "./chunk-X3TNPALI.js";
+import "./chunk-XXNEY4B3.js";
+import "./chunk-EWVR5AEX.js";
+import "./chunk-C6QSVO5K.js";
+import "./chunk-U3IVVR4W.js";
+import "./chunk-5RG4S66L.js";
+import "./chunk-O3NDWYNT.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-OKZWEVR4.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import {
+  lane_state
+} from "./chunk-ZZXO6TFH.js";
+import "./chunk-34DND4BA.js";
+import "./chunk-P4KIQRSL.js";
+import {
+  EPIC_LABEL,
+  IN_PROGRESS_LABEL,
+  NEEDS_DECISION_LABEL,
+  RUN_STALLED_LABEL,
+  has_any_label,
+  has_label_name,
+  has_parked_label,
+  parked_label_of
+} from "./chunk-QQBMVC5W.js";
+import "./chunk-TUIFS5E7.js";
+import "./chunk-QAHFPCFR.js";
+import "./chunk-66TGK5XL.js";
+import "./chunk-EZSO25UZ.js";
+import "./chunk-2DJLAUYB.js";
+import "./chunk-EW4NPUMQ.js";
+import "./chunk-BF6YX4HE.js";
+import "./chunk-3LZXX5GL.js";
+import "./chunk-W2IA2LV3.js";
+import {
+  run_ship_stage
+} from "./chunk-OHNP3QL2.js";
+import "./chunk-22DVQCP6.js";
+import "./chunk-MDKDJF2K.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import "./chunk-WQ6FS544.js";
+import "./chunk-6HRRZANN.js";
+import {
+  lane_ledger_write
+} from "./chunk-I63RNFFR.js";
+import {
+  run_carry
+} from "./chunk-MPGJ4ONJ.js";
+import "./chunk-6WKJ3GDA.js";
+import {
+  lane_paths
+} from "./chunk-YIA6FC3K.js";
+import "./chunk-JQXPLMCO.js";
+import {
+  issue_number_shape
+} from "./chunk-66NX6EXR.js";
+import "./chunk-3NWAGIA6.js";
+import "./chunk-2FE3C4PH.js";
+import "./chunk-HLUS2M3D.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  process_identity
+} from "./chunk-AKK56GNX.js";
+import "./chunk-TBIX5FRN.js";
+import "./chunk-IGD6QJPH.js";
+import "./chunk-FFHEGWPK.js";
+import "./chunk-R6QE5VJG.js";
+import "./chunk-4ZHWTTQW.js";
+import "./chunk-RDRN56E4.js";
+import "./chunk-XDF25GSU.js";
+import "./chunk-EBVS2LKX.js";
+import "./chunk-AQ3PMSXK.js";
+import "./chunk-QVOFWFWC.js";
+import "./chunk-G6BXCWPH.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import "./chunk-OKYFQJW3.js";
+import "./chunk-HHBC6QZE.js";
+import "./chunk-KKIMVXAP.js";
+import "./chunk-QWWTC3XR.js";
+import "./chunk-ILGPZ47M.js";
+import "./chunk-3CCGKX7Y.js";
+import "./chunk-KSR23NYN.js";
+import "./chunk-LR22UK5W.js";
+import "./chunk-V5FD7DVV.js";
+import "./chunk-36LOGVJ7.js";
+import "./chunk-ENFPR7J2.js";
+import "./chunk-SVV4U5AR.js";
+import "./chunk-UGCUSRZF.js";
+import "./chunk-AKQYYHP2.js";
+import "./chunk-CJKPF5DJ.js";
+import "./chunk-RBU2NKHF.js";
+import "./chunk-WB4T3VY2.js";
+import "./chunk-B77ZMVHS.js";
+import "./chunk-B5GXZK3E.js";
+import "./chunk-KTLR4Y32.js";
+import "./chunk-ZNX2LJCQ.js";
+import "./chunk-VJE3RJAX.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/backlog/backlog-drive-cli.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { setTimeout as sleep } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+
+// scripts/backlog/backlog-drive-hold.ts
+var NO_FREE_LANES = 0;
+var { OFFER_PREFIX, HAND_BACK_PREFIX, REASON_SEPARATOR } = backlog_hold_codes;
+var STOP_VERDICT = "stop";
+var FINISHED_REASONS = /* @__PURE__ */ new Set([STOP_VERDICT, "watch", "retrospective"]);
+function offer_reason(read2) {
+  if (read2.verdict === STOP_VERDICT) return void 0;
+  const detail = read2.cause ?? read2.answer;
+  const parts = [OFFER_PREFIX, read2.verdict, ...detail === void 0 ? [] : [detail]];
+  return parts.join(REASON_SEPARATOR);
+}
+async function held(result, read2, ports) {
+  if (result.kind === "continue") await ports.hold(offer_reason(read2), read2.waiting);
+  return result;
+}
+async function stopped(before, after, ports) {
+  if (after.is_stopping && !before.is_stopping) await ports.hold(void 0);
+}
+function hand_back_reason(end) {
+  if (FINISHED_REASONS.has(end.reason)) return void 0;
+  return [HAND_BACK_PREFIX, end.reason].join(REASON_SEPARATOR);
+}
+async function free_count(free_lanes, reason) {
+  if (reason === void 0) return NO_FREE_LANES;
+  try {
+    return await free_lanes();
+  } catch {
+    return void 0;
+  }
+}
+async function release(ledger) {
+  ledger.is_open = false;
+  await lane_ledger_write.record_released();
+  await lane_hand_back_hold.clear();
+}
+async function release_open(ledger) {
+  if (ledger.is_open) await release(ledger);
+}
+async function record(ledger, draft, count) {
+  if (count === void 0) return;
+  if (draft.reason === void 0) {
+    await release(ledger);
+    return;
+  }
+  if (count === NO_FREE_LANES) {
+    await release_open(ledger);
+    return;
+  }
+  ledger.is_open = true;
+  await lane_ledger_write.record_held({ reason: draft.reason, waiting: draft.waiting });
+  await lane_hand_back_hold.clear();
+}
+async function hand_back(ledger, reason, count) {
+  if (reason === void 0 || count !== NO_FREE_LANES) {
+    await record(ledger, { reason }, count);
+    return;
+  }
+  await release_open(ledger);
+  await lane_hand_back_hold.mark(reason);
+}
+function recorder(free_lanes = backlog_ready.drive_free_lane_count) {
+  const ledger = { is_open: true };
+  async function write(reason, waiting) {
+    await record(ledger, { reason, waiting }, await free_count(free_lanes, reason));
+  }
+  return {
+    hold: write,
+    end: async (end) => {
+      const reason = hand_back_reason(end);
+      await hand_back(ledger, reason, await free_count(free_lanes, reason));
+    }
+  };
+}
+var backlog_drive_hold = { hand_back_reason, held, recorder, stopped };
+
+// scripts/backlog/backlog-drive-idle.ts
+var WATCH_VERDICT = "watch";
+var BLOCKED_ANSWER = "blocked";
+var STALLED_HEADING = `Stalled mechanically (${RUN_STALLED_LABEL}):`;
+var IDLE_HEAD = "No child running and nothing left to dispatch.";
+var IDLE_RECOVERY = "Act on each issue under its heading, fix and release the stalled ones, or start the next run with `backlogrun`.";
+function is_idle(result, read2) {
+  if (read2.answer === BLOCKED_ANSWER) return false;
+  return read2.verdict === WATCH_VERDICT && result.state.in_flight.length === 0;
+}
+async function noticed(result, read2, ports) {
+  if (is_idle(result, read2)) await ports.idle(result.state);
+  return result;
+}
+function cited(issue, suffix = "") {
+  return `- ${issue_cite.plain_for("telegram", issue.number)} ${issue.title}${suffix}`;
+}
+function labelled_lines(issues, label) {
+  return issues.filter((issue) => has_any_label(issue.labels, /* @__PURE__ */ new Set([label]))).map((issue) => cited(issue));
+}
+function untrusted_lines(issues) {
+  return issues.filter((issue) => !auto_ok_author.is_author_trusted(issue)).map((issue) => cited(issue));
+}
+function dated_lines(issues, now_ms) {
+  const lines = [];
+  for (const issue of issues) {
+    const reason = issue_not_before.waiting_reason(issue.body, now_ms);
+    if (reason !== void 0) lines.push(cited(issue, ` \u2014 ${reason}`));
+  }
+  return lines;
+}
+function section(heading, lines) {
+  return lines.length === 0 ? [] : [heading, ...lines];
+}
+function waiting_lines(issues, stop) {
+  if (stop.label !== void 0) return labelled_lines(issues, stop.label);
+  return stop.key === issue_human_stops.UNTRUSTED_AUTHOR_KEY ? untrusted_lines(issues) : [];
+}
+function person_lines(issues) {
+  return issue_human_stops.idle_stops().flatMap((stop) => section(stop.idle_heading ?? stop.key, waiting_lines(issues, stop)));
+}
+function remaining_lines(reading) {
+  if (reading.issues === void 0) return ["Remaining issues: unreadable"];
+  const lines = [
+    ...person_lines(reading.issues),
+    ...section(STALLED_HEADING, labelled_lines(reading.issues, RUN_STALLED_LABEL)),
+    ...section("Waiting on a date:", dated_lines(reading.issues, reading.now_ms))
+  ];
+  return lines.length === 0 ? ["Nothing parked or dated is left."] : lines;
+}
+function describe(reading) {
+  const merged = `Merged this run: ${String(reading.merged)}`;
+  return [IDLE_HEAD, merged, ...remaining_lines(reading)].join("\n");
+}
+async function read_pool() {
+  const read2 = await auto_ok_cli.fetch_opted_in();
+  return read2.kind === "read" ? read2.issues : void 0;
+}
+async function emit_idle(compose) {
+  const { IDLE_NOTICE, CHILD_LAUNCH } = run_event_stream.EVENT_KIND;
+  return await run_event_stream_emit.emit_once_since_with(IDLE_NOTICE, CHILD_LAUNCH, compose);
+}
+async function send_idle(body) {
+  return await telegram_notify.idle({ body, recovery: IDLE_RECOVERY });
+}
+var DEFAULT_PORTS = {
+  read_issues: read_pool,
+  emit: emit_idle,
+  send: send_idle,
+  now_ms: () => Date.now()
+};
+async function notify(state, ports = DEFAULT_PORTS) {
+  try {
+    const body = await ports.emit(
+      async () => describe({
+        merged: state.exclude.length,
+        issues: await ports.read_issues(),
+        now_ms: ports.now_ms()
+      })
+    );
+    if (body !== void 0) await ports.send(body);
+  } catch {
+  }
+}
+var backlog_drive_idle = { describe, noticed, notify, read_pool };
+
+// scripts/backlog/backlog-drive-judge.ts
+var WATCH_VERDICT2 = "watch";
+var EXHAUSTED_ANSWER = "exhausted";
+var NO_FREE_LANES2 = 0;
+async function is_owed(read2, ports) {
+  const is_exhausted = read2.verdict === WATCH_VERDICT2 && read2.answer === EXHAUSTED_ANSWER;
+  if (!is_exhausted || await ports.free_lanes() <= NO_FREE_LANES2) return false;
+  return await ports.judgement_owed() > 0;
+}
+var backlog_drive_judge = { is_owed };
+
+// scripts/backlog/backlog-drive-park-triage.ts
+var TRIAGE_TOKEN = epic_triage.TRIAGE_VERDICT;
+function is_beside(state) {
+  return process_identity.is_same_process(state.triage_pid, state.triage_start) !== false;
+}
+function settled(state) {
+  return state.triage_pid === void 0 || is_beside(state) ? state : { ...state, triage_pid: void 0, triage_start: void 0 };
+}
+function is_owed2(state) {
+  return state.is_triage_owed === true && !state.is_stopping && !is_beside(state);
+}
+function triaged(result, is_triage_owed) {
+  if (!is_triage_owed || result.kind === "end" || is_beside(result.state)) return result;
+  return {
+    kind: "end",
+    end: { reason: TRIAGE_TOKEN, token: TRIAGE_TOKEN, issue: void 0 },
+    state: { ...result.state, is_triage_owed: false }
+  };
+}
+function hand_back2(state) {
+  if (is_beside(state) && !state.is_stopping) return { kind: "continue", state };
+  return is_owed2(state) ? triaged({ kind: "continue", state }, true) : void 0;
+}
+var backlog_drive_park_triage = { is_owed: is_owed2, triaged, hand_back: hand_back2, settled };
+
+// scripts/backlog/backlog-drive-paused.ts
+var HOLDING_VERDICTS = /* @__PURE__ */ new Set(["watch", "wait"]);
+var BLOCKED_ANSWER2 = "blocked";
+var PAUSED_TITLE = "backlogrun held by paused lanes";
+var PAUSED_HEAD = "No child of this run is running, and these paused lanes hold back work overlapping their paths:";
+var PAUSED_RECOVERY = "Resume a lane with `pnpm josh lane:resume <N>`, or close it with `pnpm josh lane:close <N>`.";
+var SILENT_WINDOW_MS = DEFAULT_SILENT_MINUTES * MS_PER_MINUTE;
+var SET_ASIDE_LABELS = /* @__PURE__ */ new Set([NEEDS_DECISION_LABEL, RUN_STALLED_LABEL]);
+function is_held(result, read2) {
+  if (read2.answer === BLOCKED_ANSWER2) return false;
+  return HOLDING_VERDICTS.has(read2.verdict) && result.state.in_flight.length === 0;
+}
+async function noticed2(result, read2, ports) {
+  if (is_held(result, read2)) await ports.paused();
+  return result;
+}
+function long_paused(records, now_ms) {
+  return records.filter(
+    (record2) => record2.state === "paused" && now_ms - Date.parse(record2.changed_at) >= SILENT_WINDOW_MS
+  );
+}
+function waiting_of(issues, records) {
+  const lanes = new Set(records.map((record2) => record2.issue));
+  return issues.filter((issue) => !lanes.has(String(issue.number))).filter((issue) => !has_any_label(issue.labels, SET_ASIDE_LABELS)).map((issue) => issue.number);
+}
+async function holding(paused, issues, records) {
+  const declared = await backlog_plan_comment.declared_of(issues, process.cwd());
+  const waiting = waiting_of(issues, records);
+  return paused.filter(
+    (record2) => waiting.some((number) => backlog_overlap.holds(declared, Number(record2.issue), number))
+  );
+}
+async function held_by(ports) {
+  const records = await ports.read_records();
+  const paused = long_paused(records, ports.now_ms());
+  if (paused.length === 0) return [];
+  const issues = await ports.read_issues();
+  return issues === void 0 ? [] : await holding(paused, issues, records);
+}
+function describe2(records) {
+  const lines = records.map(
+    (record2) => `- ${issue_cite.plain_for("telegram", record2.issue)} \u2014 ${lane_state.paused_note(record2) ?? ""}`
+  );
+  return [PAUSED_HEAD, ...lines].join("\n");
+}
+async function read_lane_records() {
+  const lanes = await lane_registry.list_lanes();
+  const records = await lane_state.read_states(lanes.map((lane) => lane.issue));
+  return [...records.values()];
+}
+async function emit_paused(compose) {
+  const { PAUSED_NOTICE, LANE_STATE } = run_event_stream.EVENT_KIND;
+  return await run_event_stream_emit.emit_once_since_with(PAUSED_NOTICE, LANE_STATE, compose);
+}
+async function send_paused(body) {
+  return await telegram_notify.confirm({
+    issue_title: PAUSED_TITLE,
+    body,
+    recovery: PAUSED_RECOVERY,
+    recommended: "Resume the paused lanes with `pnpm josh lane:resume <N>`",
+    alternatives: ["Close the paused lanes with `pnpm josh lane:close <N>`"]
+  });
+}
+var DEFAULT_PORTS2 = {
+  read_records: read_lane_records,
+  read_issues: backlog_drive_idle.read_pool,
+  emit: emit_paused,
+  send: send_paused,
+  now_ms: () => Date.now()
+};
+async function notify2(ports = DEFAULT_PORTS2) {
+  try {
+    const paused = await held_by(ports);
+    if (paused.length === 0) return;
+    const body = await ports.emit(async () => describe2(paused));
+    if (body !== void 0) await ports.send(body);
+  } catch {
+  }
+}
+var backlog_drive_paused = { noticed: noticed2, notify: notify2 };
+
+// scripts/backlog/backlog-drive-state.ts
+function initial_state(in_flight, active) {
+  return {
+    in_flight: [...in_flight],
+    exclude: [],
+    active,
+    retries: 0,
+    is_stopping: false
+  };
+}
+function merge_stopped(issue, state) {
+  if (state.is_stopping) return state;
+  return {
+    ...state,
+    is_stopping: true,
+    stop_reason: `run:merge ${issue_cite.plain_for("terminal", issue)} answered stop`,
+    stopped_by: issue
+  };
+}
+var backlog_drive_state = { initial_state, merge_stopped };
+
+// scripts/backlog/backlog-drive-token-handling.ts
+var { MERGE_TOKEN } = run_merge_token;
+var TOKEN_HANDLING = {
+  [MERGE_TOKEN.OVER]: "hand-back",
+  [MERGE_TOKEN.HUMAN_REVIEW]: "hand-back",
+  [MERGE_TOKEN.ENVIRONMENT]: "hand-back",
+  [MERGE_TOKEN.BUSY]: "hand-back",
+  [MERGE_TOKEN.RETRY]: "hand-back",
+  [MERGE_TOKEN.STOP]: "stop",
+  [MERGE_TOKEN.RESUMED]: "await"
+};
+function tokens_handled(...handlings) {
+  const entries = Object.entries(TOKEN_HANDLING);
+  return new Set(entries.filter(([, handling]) => handlings.includes(handling)).map(([key]) => key));
+}
+var IMMEDIATE_TOKENS = tokens_handled("hand-back");
+var HANDOFF_TOKENS = tokens_handled("hand-back", "stop");
+var backlog_drive_token_handling = { HANDOFF_TOKENS, IMMEDIATE_TOKENS, TOKEN_HANDLING };
+
+// scripts/backlog/backlog-offer-timing.ts
+function first_run(state, now_ms) {
+  return { state, started_ms: now_ms, offered_ms: -Infinity, checked_ms: -Infinity };
+}
+function is_window_spent(run3, config, now_ms) {
+  if (config.window_ms === void 0) return false;
+  return now_ms - run3.started_ms >= config.window_ms;
+}
+function due_ms(deadline, offered_ms, interval_ms) {
+  return deadline !== void 0 && deadline > offered_ms ? deadline : offered_ms + interval_ms;
+}
+function deadline_of(state) {
+  if (state.is_stopping || state.not_before_ms === void 0) return void 0;
+  return Math.min(state.not_before_ms, state.idle_until_ms ?? Infinity);
+}
+function interval_of(state, config, is_named_left2) {
+  return is_named_left2 && state.in_flight.length === 0 ? config.idle_offer_ms : config.offer_ms;
+}
+async function interval_for(run3, config, ports) {
+  const is_named_left2 = run3.state.in_flight.length === 0 && await ports.named_left();
+  return interval_of(run3.state, config, is_named_left2);
+}
+function is_check_due(run3, config, now_ms) {
+  return now_ms >= run3.checked_ms + config.check_ms;
+}
+async function is_listing_changed(run3, config, ports, now_ms) {
+  if (!is_check_due(run3, config, now_ms) || await ports.free_lanes() === 0) return false;
+  return await ports.listing_changed();
+}
+async function is_signalled(run3, ports) {
+  return await backlog_drive_memory.is_cleared(run3.state, ports) || await ports.added_since(run3.offered_ms) || await ports.raised_since(run3.offered_ms);
+}
+async function is_due(run3, config, ports, now_ms) {
+  const interval_ms = await interval_for(run3, config, ports);
+  if (now_ms >= due_ms(deadline_of(run3.state), run3.offered_ms, interval_ms)) return true;
+  return await is_signalled(run3, ports) || await is_listing_changed(run3, config, ports, now_ms);
+}
+function advanced(run3, step, config, now_ms) {
+  const { state, is_asked } = step;
+  const is_checked = is_asked || is_check_due(run3, config, now_ms);
+  const offered_ms = is_asked ? now_ms : run3.offered_ms;
+  return { ...run3, state, offered_ms, checked_ms: is_checked ? now_ms : run3.checked_ms };
+}
+function sleep_ms(deadline, milliseconds, now_ms) {
+  const remaining = (deadline ?? Infinity) - now_ms;
+  return remaining > 0 ? Math.min(milliseconds, remaining) : milliseconds;
+}
+function sleeper(deadline, ports) {
+  return async function wait(milliseconds) {
+    const duration = sleep_ms(deadline(), milliseconds, ports.now().getTime());
+    await ports.sleep(duration);
+  };
+}
+var backlog_offer_timing = {
+  advanced,
+  deadline_of,
+  due_ms,
+  first_run,
+  interval_of,
+  is_due,
+  is_window_spent,
+  sleep_ms,
+  sleeper
+};
+
+// scripts/backlog/backlog-yield-cap.ts
+var YIELD_CAP = 3;
+var WINDOW_MINUTES = 15;
+var WINDOW_MS = WINDOW_MINUTES * MS_PER_MINUTE;
+var YIELDED_OUTCOME = "yielded";
+var TRIP_CAUSE = "yield cap";
+function is_tripped(times, now) {
+  const since_ms = now.getTime() - WINDOW_MS;
+  return times.filter((at) => Date.parse(at) >= since_ms).length >= YIELD_CAP;
+}
+function times_of(events, issue) {
+  return events.filter(
+    (event) => lane_yield.is_yield_note(event) && run_event_scope.issue_named(event) === issue
+  ).map((event) => event.at);
+}
+function trip_text(issue) {
+  return `${issue_cite.plain_for("program", issue)} parked by backlog:drive: it gave its lane back ${String(YIELD_CAP)} times within ${String(WINDOW_MINUTES)} minutes`;
+}
+function body_of(issue) {
+  return [
+    `Parked with \`${RUN_STALLED_LABEL}\`: ${trip_text(issue)}, so the run stopped re-dispatching it.`,
+    `- Next: the drive re-offers it itself once ${String(WINDOW_MINUTES)} minutes pass, up to its auto-retry cap; past the cap, find why \`lane:plan\` keeps reading a holder, ${run_stalled.next_step(issue)}.`
+  ].join("\n");
+}
+async function is_capped(issue, outcome, ports) {
+  return outcome === YIELDED_OUTCOME && is_tripped(await ports.yields(issue), ports.now());
+}
+async function capped(issue, outcome, state, ports) {
+  if (!await is_capped(issue, outcome, ports)) return state;
+  await ports.park(issue, body_of(issue));
+  return { ...state, exclude: [...state.exclude, issue] };
+}
+async function yields(issue) {
+  return times_of(await run_event_stream_emit.current_events(), issue);
+}
+async function park(issue, body) {
+  if (await run_stalled_park.apply(issue, body, TRIP_CAUSE)) await run_park_release.release(issue);
+}
+var PORTS = { yields, park };
+var backlog_yield_cap = {
+  PORTS,
+  TRIP_CAUSE,
+  WINDOW_MS,
+  YIELD_CAP,
+  body_of,
+  capped,
+  is_tripped,
+  times_of
+};
+
+// scripts/backlog/backlog-drive.ts
+var { MERGE_TOKEN: MERGE_TOKEN2 } = run_merge_token;
+var { HANDOFF_TOKENS: HANDOFF_TOKENS2, IMMEDIATE_TOKENS: IMMEDIATE_TOKENS2, TOKEN_HANDLING: TOKEN_HANDLING2 } = backlog_drive_token_handling;
+var RUN_VERDICT = "run";
+var STOP_VERDICT2 = "stop";
+var EXCLUDED_OUTCOMES = /* @__PURE__ */ new Set(["merged", "withdrawn"]);
+var WATCH_VERDICT3 = "watch";
+var KNOWN_VERDICTS = /* @__PURE__ */ new Set([
+  RUN_VERDICT,
+  STOP_VERDICT2,
+  WATCH_VERDICT3,
+  "wait"
+]);
+var JUDGE_REASON = "judge";
+var { launch_all } = backlog_drive_launch_pass;
+var { is_drain_owed } = backlog_drive_retrospective;
+var { initial_state: initial_state2, merge_stopped: merge_stopped2 } = backlog_drive_state;
+function ended(reason, state, token, issue) {
+  const detail = reason === STOP_VERDICT2 ? state.stop_reason : void 0;
+  return {
+    kind: "end",
+    end: {
+      reason,
+      token,
+      issue,
+      ...detail !== void 0 && { detail },
+      ...reason === STOP_VERDICT2 && { is_finish: state.stop_is_finish }
+    },
+    state
+  };
+}
+function excluded(issue, outcome, state) {
+  if (!EXCLUDED_OUTCOMES.has(outcome) || state.exclude.includes(issue)) return state.exclude;
+  return [...state.exclude, issue];
+}
+function was_parked(collected2) {
+  return collected2.outcome === "parked" || collected2.is_parked === true;
+}
+function collected_state(issue, collected2, state, active) {
+  const in_flight = collected2.token === MERGE_TOKEN2.RESUMED ? state.in_flight : state.in_flight.filter((item) => item !== issue);
+  const exclude = excluded(issue, collected2.outcome, state);
+  const is_triage_owed = state.is_triage_owed === true || was_parked(collected2);
+  return { ...state, in_flight, exclude, active, is_triage_owed };
+}
+async function collect(issue, state, ports) {
+  const collected2 = await ports.merge(issue);
+  const { token, is_offer } = collected2;
+  if (token === "") return ended("merge", state, void 0, issue);
+  if (!is_offer && IMMEDIATE_TOKENS2.has(token)) return ended("merge", state, token, issue);
+  const active = ports.now().toISOString();
+  const next = await backlog_yield_cap.capped(
+    issue,
+    collected2.outcome,
+    collected_state(issue, collected2, state, active),
+    ports
+  );
+  return {
+    kind: "continue",
+    state: run_merge_token.is_control_stop(collected2) ? merge_stopped2(issue, next) : next
+  };
+}
+async function collect_finished(state, ports) {
+  const finished = state.in_flight.filter((item) => ports.is_finished(item));
+  let current = state;
+  for (const issue of finished) {
+    const result = await collect(issue, current, ports);
+    if (result.kind === "end") return { ...result, state: current };
+    current = result.state;
+  }
+  await backlog_drive_hold.stopped(state, current, ports);
+  return { kind: "continue", state: current };
+}
+function on_verdict(read2, state) {
+  if (!KNOWN_VERDICTS.has(read2.verdict)) return ended(read2.verdict, state, read2.verdict);
+  if (read2.verdict === STOP_VERDICT2) {
+    return {
+      kind: "continue",
+      state: {
+        ...state,
+        is_stopping: true,
+        stop_reason: read2.reason,
+        stop_is_finish: read2.is_finish
+      }
+    };
+  }
+  if (is_drain_owed(read2, state, WATCH_VERDICT3)) return ended(WATCH_VERDICT3, state, WATCH_VERDICT3);
+  return { kind: "continue", state };
+}
+async function usage_held(state, ports) {
+  await ports.hold(backlog_hold_codes.USAGE_LIMIT_REASON);
+  return { kind: "continue", state };
+}
+async function run_offered(issues, state, ports) {
+  if (await ports.usage_limited()) return await usage_held(state, ports);
+  if (await ports.memory_held()) return await backlog_drive_memory.held(state, ports);
+  return await launch_all(issues, state, ports);
+}
+async function run_then_judge(read2, state, ports) {
+  const result = await run_offered(read2.issues, state, ports);
+  return backlog_drive_park_triage.triaged(result, read2.is_judgment_owed === true || backlog_drive_park_triage.is_owed(state));
+}
+async function answered(read2, next, ports) {
+  if (await backlog_drive_judge.is_owed(read2, ports)) return ended(JUDGE_REASON, next, JUDGE_REASON);
+  const verdict = await backlog_drive_retrospective.ran(on_verdict(read2, next), read2, ports);
+  const idle = await backlog_drive_idle.noticed(verdict, read2, ports);
+  const result = await backlog_drive_paused.noticed(idle, read2, ports);
+  return await backlog_drive_hold.held(result, read2, ports);
+}
+async function ask_offer(state, ports) {
+  const read2 = await ports.offer(state);
+  if (read2 === void 0) return backlog_drive_park_triage.hand_back(state) ?? ended("offer", state);
+  const next = {
+    ...state,
+    retries: read2.retries,
+    is_memory_held: false,
+    not_before_ms: read2.not_before_ms,
+    idle_until_ms: read2.idle_until_ms
+  };
+  if (read2.verdict === RUN_VERDICT) return await run_then_judge(read2, next, ports);
+  return backlog_drive_park_triage.hand_back(next) ?? await answered(read2, next, ports);
+}
+function is_offering(before, after, should_offer) {
+  const is_collected = after.in_flight.length !== before.in_flight.length;
+  return !after.is_stopping && (should_offer || is_collected || backlog_drive_park_triage.is_owed(after));
+}
+async function offered(state, ports) {
+  if (await ports.free_lanes() === 0) {
+    return backlog_drive_park_triage.hand_back(state) ?? { kind: "continue", state };
+  }
+  return await ask_offer(state, ports);
+}
+function settle(result) {
+  if (result.kind === "end") return result;
+  const is_done = result.state.is_stopping && result.state.in_flight.length === 0;
+  return is_done ? ended(STOP_VERDICT2, result.state, STOP_VERDICT2) : result;
+}
+async function run_pass(state, should_offer, ports) {
+  const held3 = await backlog_drive_adopt.held(backlog_drive_park_triage.settled(state), should_offer, ports);
+  const collected2 = await collect_finished(held3, ports);
+  if (collected2.kind === "end") return collected2;
+  if (!is_offering(held3, collected2.state, should_offer)) return settle(collected2);
+  return settle(await offered(collected2.state, ports));
+}
+var WINDOW_END = { reason: "window", token: void 0, issue: void 0 };
+async function loop_step(run3, config, ports) {
+  await ports.begin_tick(run3.state.in_flight);
+  const now_ms = ports.now().getTime();
+  const is_due3 = await backlog_offer_timing.is_due(run3, config, ports, now_ms);
+  const result = await run_pass(run3.state, is_due3, ports);
+  ports.on_state(result.state);
+  if (result.kind === "end") return result;
+  const step = { state: result.state, is_asked: is_due3 };
+  const next = backlog_offer_timing.advanced(run3, step, config, now_ms);
+  return backlog_offer_timing.is_window_spent(next, config, ports.now().getTime()) ? { kind: "end", end: WINDOW_END } : { kind: "next", run: next };
+}
+async function run_loop(state, config, ports) {
+  const progress = { run: backlog_offer_timing.first_run(state, ports.now().getTime()) };
+  const end = await poll.wait_for(
+    async () => {
+      const step = await loop_step(progress.run, config, ports);
+      if (step.kind === "next") Object.assign(progress, { run: step.run });
+      return step.kind === "end" ? step.end : void 0;
+    },
+    {
+      interval_ms: config.poll_ms,
+      sleeper: backlog_offer_timing.sleeper(
+        () => backlog_offer_timing.deadline_of(progress.run.state),
+        ports
+      )
+    }
+  );
+  if (end.reason === STOP_VERDICT2) await ports.finish(end);
+  return end;
+}
+var backlog_drive = {
+  HANDOFF_TOKENS: HANDOFF_TOKENS2,
+  TOKEN_HANDLING: TOKEN_HANDLING2,
+  initial_state: initial_state2,
+  merge_stopped: merge_stopped2,
+  run_loop,
+  run_pass
+};
+
+// scripts/backlog/backlog-drive-carried.ts
+async function is_claimed(issue) {
+  const read2 = await issue_state_cli.read_issue(issue);
+  if (read2.kind !== "state") return false;
+  return has_label_name(read2.state.labels, IN_PROGRESS_LABEL) && !read2.state.is_human_review;
+}
+async function carried(lanes) {
+  const dispatched = lanes.filter((lane) => lane.output !== void 0).map((lane) => lane.issue);
+  const claims = await Promise.all(dispatched.map(async (issue) => await is_claimed(issue)));
+  return dispatched.filter((_issue, index) => claims[index] === true);
+}
+var backlog_drive_carried = { carried };
+
+// scripts/backlog/backlog-drive-retry.ts
+function is_ready(issue, cause, repo) {
+  const references = epic_issue.blocker_references_of(issue, repo);
+  const is_dependent = references.some(
+    (reference) => reference.number === cause && reference.repo.toLowerCase() === repo.toLowerCase()
+  );
+  return epic_issue.is_open(issue.state) && is_dependent && (issue.blockedBy?.nodes ?? []).every(
+    (blocker) => epic_issue.normalize_state(blocker.state ?? "") === epic_issue.CLOSED
+  );
+}
+async function park_protected(issue, cause, label) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.PARK,
+    `${issue_cite.plain_for("program", issue)} parked (${label}; blocker ${issue_cite.plain_for("program", cause)} closed)`
+  );
+}
+async function add_retry(issue, what) {
+  const result = await josh_command.josh_run(["run:add", String(issue), "--retry"], true);
+  if (result.code !== 0) throw new Error(`Could not retry ${what}.`);
+}
+async function retry_one(issue, cause, repo) {
+  const read2 = await run_add_issue.read(issue);
+  const citation = issue_cite.reference(repo, String(issue), void 0);
+  if (read2 === void 0) throw new Error(`Could not read all dependencies of ${citation}.`);
+  if (!is_ready(read2, cause, repo)) return;
+  const label = run_add.protected_label(epic_issue.label_names(read2));
+  if (label !== void 0) {
+    await park_protected(issue, cause, label);
+    return;
+  }
+  await add_retry(issue, `${citation} after its cause merged`);
+}
+async function retry_all(issues, cause, repo) {
+  const [issue, ...rest] = issues;
+  if (issue === void 0) return;
+  await retry_one(issue, cause, repo);
+  await retry_all(rest, cause, repo);
+}
+async function after_merge(cause) {
+  const events = await run_event_stream_emit.current_events(true);
+  const parked = backlog_drive_restore.parked_issues(events);
+  if (parked.size === 0) return;
+  const repo = await git_gh_command.repo_get_name_with_owner();
+  if (repo === void 0) throw new Error("Could not resolve the repository for dependent retries.");
+  await retry_all([...parked], cause, repo);
+}
+var backlog_drive_retry = { add_retry, after_merge };
+
+// scripts/backlog/backlog-drive-after-merge.ts
+var DECISION_HEADING = "## Decision (backlog:drive)";
+var SUCCESS_EXIT_CODE = 0;
+var DEFAULT_REASON = "because the park had no recommendation and it is the first reversible option with the smallest change (not tier C, no permission, no size approval)";
+async function trusted_bodies(issue) {
+  const json = await git_gh_issue_read.issue_list_comments(issue);
+  const comments = await issue_read.parse_comments(json);
+  return issue_read.trusted_bodies(comments ?? []);
+}
+async function run_josh(argv) {
+  const result = await josh_command.josh_run(argv, true);
+  return result.code;
+}
+async function notify_decided(line) {
+  return await telegram_notify.decided({
+    body: line,
+    recovery: `the "${DECISION_HEADING}" comment`
+  });
+}
+var PORTS2 = { bodies: trusted_bodies, run: run_josh, notify: notify_decided };
+function recommended(pick) {
+  return {
+    text: `Taking recommended option ${String(pick)}: tier A, no person's permission needed.`
+  };
+}
+function defaulted(issue, park2) {
+  const pick = run_park_body.default_pick(park2);
+  if (pick === void 0) return void 0;
+  const over = pick.over.length === 0 ? "no other option" : `option ${pick.over.join(", ")}`;
+  const choice = `Auto-decided: option ${String(pick.number)} over ${over}`;
+  return {
+    text: `${choice} ${DEFAULT_REASON}.`,
+    notice: `${issue_cite.plain_for("program", issue)}: ${choice}`
+  };
+}
+function decision_of(issue, bodies) {
+  if (bodies.some((body) => body.startsWith(DECISION_HEADING))) return void 0;
+  const park2 = bodies.findLast((body) => run_park_body.problem_of(body) === void 0);
+  if (park2 === void 0) return void 0;
+  const pick = run_park_body.auto_pick(park2);
+  return pick === void 0 ? defaulted(issue, park2) : recommended(pick);
+}
+async function is_recorded(issue, text, ports) {
+  const body = `${DECISION_HEADING}
+
+${text}`;
+  const commented = await ports.run(["issue:comment", issue, "--body", body]);
+  if (commented !== SUCCESS_EXIT_CODE) return false;
+  return await ports.run(["run:park", issue, "--clear"]) === SUCCESS_EXIT_CODE;
+}
+async function resolve(issue, ports = PORTS2) {
+  const decision = decision_of(issue, await ports.bodies(issue));
+  if (decision === void 0 || !await is_recorded(issue, decision.text, ports)) return false;
+  if (decision.notice !== void 0) await ports.notify(decision.notice);
+  return true;
+}
+async function after_merge2(issue, result, owner, ports = PORTS2) {
+  if (result.outcome === "parked" && await resolve(issue, ports)) return;
+  await backlog_drive_named.mark_done(issue, result, owner);
+  if (result.outcome === "merged") await backlog_drive_retry.after_merge(Number(issue));
+}
+var backlog_drive_after_merge = { DECISION_HEADING, after_merge: after_merge2, resolve };
+
+// scripts/backlog/backlog-drive-collect.ts
+var should_forward_stderr = true;
+function unprinted(code) {
+  return { token: "", code, is_offer: true, outcome: "unresolved" };
+}
+async function collected(issue, owner) {
+  await backlog_drive_owner.assert_current(owner);
+  const lane = await lane_registry.find_open_lane(issue);
+  const argv = run_merge_driver.argv_of({ child: issue, owner, output: lane?.output });
+  const ran = await josh_command.josh_run(argv, should_forward_stderr);
+  const result = run_merge_driver.read(ran.out) ?? unprinted(ran.code);
+  await backlog_drive_after_merge.after_merge(issue, result, owner);
+  return result;
+}
+async function merge(issue, owner) {
+  return await backlog_drive_trace.traced(
+    issue,
+    backlog_drive_trace.STEP.COLLECT,
+    async () => await collected(issue, owner)
+  );
+}
+var backlog_drive_collect = { merge };
+
+// scripts/backlog/backlog-drive-finish.ts
+var SUCCESS_EXIT_CODE2 = 0;
+var should_forward_stderr2 = true;
+function end_args(end) {
+  if (end.is_finish === true) return ["run:carry", "--end"];
+  return ["run:carry", "--end", "--stopped", end.detail ?? "stopped"];
+}
+async function finish(end) {
+  const report = await josh_command.josh_run(["run:report"], should_forward_stderr2);
+  if (report.code !== SUCCESS_EXIT_CODE2) throw new Error("run:report failed");
+  console.error(report.out);
+  const ended2 = await josh_command.josh_run(end_args(end), should_forward_stderr2);
+  if (ended2.code !== SUCCESS_EXIT_CODE2) throw new Error("run:carry --end failed");
+}
+var backlog_drive_finish = { finish };
+
+// scripts/backlog/backlog-drive-epic.ts
+var NO_RETRIES = 0;
+var SUCCESS_EXIT_CODE3 = 0;
+var FIRST_LINE = 0;
+var WAIT = { verdict: "wait", issues: [], retries: NO_RETRIES };
+var TRIAGE = { ...WAIT, verdict: epic_triage.TRIAGE_VERDICT };
+async function ask_next(epic) {
+  const repo = await git_gh_repo.repo_get_name_with_owner();
+  if (repo === void 0) return void 0;
+  const result = await josh_command.josh_run(["epic:next", epic, "--repo", repo, "--lanes"], true);
+  return result.code === SUCCESS_EXIT_CODE3 ? result.out.trim().split("\n") : void 0;
+}
+function handed_back(epic) {
+  return { ...WAIT, verdict: `epic ${issue_cite.plain_for("program", epic)}` };
+}
+function failed_offer(epic, state) {
+  const retries = state.retries + 1;
+  return retries >= backlog_offer.RETRY_LIMIT ? handed_back(epic) : { ...WAIT, retries };
+}
+function child_offer(children, state) {
+  const child = children.find(
+    (item) => !state.in_flight.includes(item) && !state.exclude.includes(item)
+  );
+  return child === void 0 ? WAIT : { verdict: "run", issues: [child], retries: NO_RETRIES };
+}
+function judgment_offer(epic, token) {
+  if (token === "stop") return handed_back(epic);
+  return token === epic_triage.TRIAGE_VERDICT ? TRIAGE : void 0;
+}
+async function answered_offer(epic, answers, state, owner) {
+  const token = answers[FIRST_LINE] ?? "";
+  if (issue_number_shape.ISSUE_NUMBER_PATTERN.test(token)) return child_offer(answers, state);
+  const judgment = judgment_offer(epic, token);
+  if (judgment !== void 0) return judgment;
+  if (token === "complete") {
+    await backlog_drive_named.mark_done(
+      epic,
+      { outcome: "merged", code: 0, token: "none", is_offer: true },
+      owner
+    );
+  }
+  return WAIT;
+}
+async function offer(epic, state, owner) {
+  const answers = await ask_next(epic);
+  return answers === void 0 ? failed_offer(epic, state) : await answered_offer(epic, answers, state, owner);
+}
+var backlog_drive_epic = { offer };
+
+// scripts/backlog/backlog-drive-rate-limit.ts
+var REMAINING_FLOOR = 100;
+var WAIT_VERDICT = "wait";
+async function held2(state, read_core = gh_core_rate_limit.read_core) {
+  const core = await read_core();
+  if (core === void 0 || core.remaining >= REMAINING_FLOOR) return void 0;
+  return { verdict: WAIT_VERDICT, issues: [], retries: state.retries, not_before_ms: core.reset_ms };
+}
+var backlog_drive_rate_limit = { REMAINING_FLOOR, held: held2 };
+
+// scripts/backlog/backlog-drive-escalate.ts
+function label_of(worker) {
+  return `${agent_worker_profile.LABEL_PREFIX}${worker.name}`;
+}
+function enabled_settings(directory) {
+  const result = agent_worker_profile.read(directory);
+  if (result.kind !== "settings") return void 0;
+  return result.settings.escalate ? result.settings : void 0;
+}
+async function current_worker(settings, read_labels) {
+  const labels = await read_labels();
+  if (labels === void 0) return void 0;
+  const result = agent_worker_profile.for_labels(settings, labels);
+  return result.kind === "worker" ? result.worker : void 0;
+}
+async function relabel(issue, move) {
+  if (!await git_gh_issue_write.issue_add_label(issue, label_of(move.to))) return false;
+  return await git_gh_issue_write.issue_clear_label(issue, label_of(move.from));
+}
+function agent_of(worker) {
+  return `${worker.agent.model} / ${worker.agent.effort}`;
+}
+function step_note(move, reason) {
+  return [
+    `Escalated the worker from \`${label_of(move.from)}\` (${agent_of(move.from)}) to \`${label_of(move.to)}\` (${agent_of(move.to)}); the lane resumes in the same worktree.`,
+    `- Reason: ${reason}`
+  ].join("\n");
+}
+async function step_up(issue, move, reason, retry) {
+  if (!await relabel(String(issue), move)) {
+    console.error(
+      `Could not move ${issue_cite.plain_for("program", issue)} to ${label_of(move.to)}. Left for a person.`
+    );
+    return;
+  }
+  await git_gh_issue_write.issue_try_comment(String(issue), step_note(move, reason));
+  await retry(issue);
+}
+function top_note(top, reason) {
+  return [
+    `Parked with \`${NEEDS_DECISION_LABEL}\`: the worker asked for a stronger profile, but \`${label_of(top)}\` is the top of josh.worker.profiles.`,
+    `- Reason: ${reason}`,
+    "- Next: a person decides how to go on."
+  ].join("\n");
+}
+async function hand_over(issue, top, reason) {
+  await issue_park.apply(String(issue), NEEDS_DECISION_LABEL, top_note(top, reason));
+}
+async function escalate(issue, reason, ports, directory = process.cwd()) {
+  const settings = enabled_settings(directory);
+  if (settings === void 0) return;
+  const from = await current_worker(settings, ports.labels);
+  if (from === void 0) return;
+  const to = agent_worker_profile.next(settings, from);
+  await (to === void 0 ? hand_over(issue, from, reason) : step_up(issue, { from, to }, reason, ports.retry));
+}
+var backlog_drive_escalate = { escalate };
+
+// scripts/backlog/backlog-drive-stalled-retry.ts
+var RETRY_CAP = 2;
+var CAP_NOTE = `auto-retry cap ${String(RETRY_CAP)} reached`;
+var RESUME_REFUSED = "escalated one profile up, but run:add refused the resume";
+var { PARK } = run_event_stream.EVENT_KIND;
+var last_sweep = { at: -Infinity };
+async function is_followup_clear(issue) {
+  try {
+    const branch = lane_paths.lane_branch(String(issue));
+    const { snapshot_json } = await git_gh_pr_snapshot.pr_get_checks_snapshot(branch);
+    const snapshot = parse_pr_state_snapshot(snapshot_json);
+    return absent_required(snapshot, REQUIRED_CHECKS).length === 0 && collect_blocking_failures(snapshot).length === 0 && is_mergeable_state(snapshot);
+  } catch {
+    return false;
+  }
+}
+async function is_next_sweep() {
+  return true;
+}
+async function is_window_passed(_issue, park2, now) {
+  return Date.parse(park2.at) + backlog_yield_cap.WINDOW_MS <= now;
+}
+var STAGE_CHECKS = /* @__PURE__ */ new Map([
+  [run_ship_stage.STAGE.FOLLOWUP, is_followup_clear]
+]);
+var CAUSE_CHECKS = /* @__PURE__ */ new Map([
+  [run_stalled.SESSION_UNFINISHED.short, is_next_sweep],
+  [run_stalled.CUT_NOT_RELAUNCHED.short, is_next_sweep],
+  [run_stalled.STALE_HANDOFF.short, is_next_sweep],
+  [backlog_yield_cap.TRIP_CAUSE, is_window_passed]
+]);
+function latest_parks(events) {
+  const parks = /* @__PURE__ */ new Map();
+  for (const event of run_event_retry.current_attempts(events)) {
+    const issue = run_event_scope.issue_named(event);
+    if (issue !== void 0 && event.kind === PARK) parks.set(Number(issue), event);
+  }
+  return parks;
+}
+async function stalled_labels(issue) {
+  const read2 = await run_add_issue.read(issue);
+  if (read2 === void 0) return void 0;
+  const labels = epic_issue.label_names(read2);
+  const is_stalled = epic_issue.is_open(read2.state) && has_label_name(labels, RUN_STALLED_LABEL) && run_add.protected_label(labels) === void 0;
+  return is_stalled ? labels : void 0;
+}
+async function is_still_stalled(issue) {
+  return await stalled_labels(issue) !== void 0;
+}
+function check_of(park2) {
+  if (park2.text.includes(CAP_NOTE)) return void 0;
+  if (park2.stop !== void 0) return STAGE_CHECKS.get(park2.stop.stage);
+  return CAUSE_CHECKS.get(run_stalled.class_of(run_stalled.cause_in(park2.text) ?? ""));
+}
+function cap_cause(park2) {
+  const cause = run_stalled.cause_in(park2.text) ?? "";
+  return cause === "" ? CAP_NOTE : `${CAP_NOTE} \u2014 ${cause}`;
+}
+async function note_cap(issue, park2) {
+  const text = run_stalled.park_event(issue, cap_cause(park2));
+  const { stop } = park2;
+  await run_event_stream_emit.emit(PARK, text, /* @__PURE__ */ new Date(), { ...stop && { stop } });
+}
+async function retry_cleared(issue) {
+  try {
+    await backlog_drive_retry.add_retry(
+      issue,
+      `${issue_cite.plain_for("program", issue)} automatically`
+    );
+    return true;
+  } catch (error) {
+    console.error(`${String(error)} Left for a person.`);
+    return false;
+  }
+}
+async function is_due2(issue, park2, is_cleared, due) {
+  if (!due.is_capped && !await is_cleared(issue, park2, due.now)) return false;
+  return await is_still_stalled(issue);
+}
+async function retry_park(issue, park2, context) {
+  const cause_check = check_of(park2);
+  if (cause_check === void 0) return;
+  const is_capped2 = run_event_retry.count_of(context.history, issue) >= RETRY_CAP;
+  if (!await is_due2(issue, park2, cause_check, { is_capped: is_capped2, now: context.now })) return;
+  await (is_capped2 ? note_cap(issue, park2) : retry_cleared(issue));
+}
+function is_escalation(park2) {
+  const cause = run_stalled.cause_in(park2.text) ?? "";
+  return run_stalled.class_of(cause) === run_stalled.ESCALATION_REQUESTED.short;
+}
+async function resume_escalated(issue) {
+  if (await retry_cleared(issue)) return;
+  await run_event_stream_emit.emit(PARK, run_stalled.park_event(issue, RESUME_REFUSED));
+}
+async function escalate_park(issue, park2) {
+  await backlog_drive_escalate.escalate(issue, run_stalled.cause_in(park2.text) ?? "", {
+    labels: async () => await stalled_labels(issue),
+    retry: resume_escalated
+  });
+}
+async function settle_park(issue, park2, context) {
+  await (is_escalation(park2) ? escalate_park(issue, park2) : retry_park(issue, park2, context));
+}
+async function retry_all2(parks, context) {
+  const [first, ...rest] = parks;
+  if (first === void 0) return;
+  await settle_park(first[0], first[1], context);
+  await retry_all2(rest, context);
+}
+async function sweep(now = Date.now()) {
+  if (now - last_sweep.at < backlog_budget.OFFER_INTERVAL_MS) return;
+  last_sweep.at = now;
+  const parks = latest_parks(await run_event_stream_emit.current_events());
+  if (parks.size === 0) return;
+  await retry_all2([...parks], { history: await run_event_stream_emit.all_events(), now });
+}
+var backlog_drive_stalled_retry = { CAP_NOTE, RETRY_CAP, sweep };
+
+// scripts/backlog/backlog-drive-unread.ts
+var NO_RETRIES2 = 0;
+var HANDED_BACK = "offer";
+var UNKNOWN_REASON = "unknown reason";
+function cause_of(read2) {
+  if (read2.kind === "missing") return "the number does not resolve";
+  const status = read2.status === void 0 ? [] : [`status ${String(read2.status)}`];
+  return [read2.reason ?? UNKNOWN_REASON, ...status].join(", ");
+}
+function note_of(issue, read2) {
+  return `The state of named issue ${issue_cite.plain_for("terminal", issue)} could not be read (${cause_of(read2)})`;
+}
+function handed_back2(note) {
+  console.error(note);
+  return { verdict: HANDED_BACK, issues: [], retries: NO_RETRIES2 };
+}
+function offer2(issue, read2, retries) {
+  const note = note_of(issue, read2);
+  if (read2.kind === "missing") return handed_back2(`${note}; check the number and the repository.`);
+  const failures = retries + 1;
+  if (failures >= backlog_offer.RETRY_LIMIT) {
+    return handed_back2(`${note}; the offer failed ${String(failures)} times in a row.`);
+  }
+  console.error(`${note}; reading it again.`);
+  return { verdict: "wait", issues: [], retries: failures };
+}
+var backlog_drive_unread = { HANDED_BACK, offer: offer2 };
+
+// scripts/backlog/backlog-drive-named-offer.ts
+var NO_RETRIES3 = 0;
+function max_of(forwarded) {
+  const index = forwarded.indexOf("--max");
+  return index === -1 ? void 0 : Number(forwarded[index + 1]);
+}
+function budget_offer(carry, state, forwarded) {
+  const budget = backlog_budget.decide({
+    answer: "candidates",
+    merged: carry.merged,
+    running: state.in_flight.length,
+    started_at_ms: Date.parse(carry.started_at),
+    active_at_ms: Date.parse(state.active),
+    now_ms: Date.now(),
+    max_issues: max_of(forwarded),
+    idle_budget_ms: backlog_budget.DEFAULT_IDLE_MS
+  });
+  return {
+    verdict: budget.verdict,
+    issues: [],
+    retries: NO_RETRIES3,
+    reason: budget.reason,
+    is_finish: budget.verdict === "stop"
+  };
+}
+function is_settled(state) {
+  return state.state.toUpperCase() === "CLOSED" || has_parked_label(state.labels);
+}
+async function classify(issue, named, state, owner) {
+  const result = await issue_state_cli.read_issue(issue);
+  if (result.kind !== "state") return backlog_drive_unread.offer(issue, result, state.retries);
+  if (is_settled(result.state)) {
+    await backlog_drive_named.mark_settled(issue, owner);
+    return { verdict: "wait", issues: [], retries: NO_RETRIES3 };
+  }
+  return has_label_name(result.state.labels, EPIC_LABEL) ? await backlog_drive_epic.offer(issue, state, owner) : named;
+}
+async function unmerged_reason(issue, merged) {
+  if (merged.includes(issue)) return void 0;
+  const result = await issue_state_cli.read_issue(String(issue));
+  if (result.kind !== "state") return "state unreadable";
+  if (result.state.state.toUpperCase() === "CLOSED") return void 0;
+  return parked_label_of(result.state.labels) ?? "open";
+}
+function cite(issue, reason) {
+  return reason === void 0 ? void 0 : `${issue_cite.plain_for("program", issue)} (${reason})`;
+}
+async function unmerged_of(carry) {
+  const declared = backlog_drive_named.named_issues(carry);
+  const merged = carry.merged_issues ?? [];
+  const reasons = await Promise.all(
+    declared.map(async (issue) => await unmerged_reason(issue, merged))
+  );
+  const cited2 = declared.map((issue, index) => cite(issue, reasons[index]));
+  return cited2.filter((line) => line !== void 0);
+}
+async function only_end(carry, named) {
+  const unmerged = await unmerged_of(carry);
+  if (unmerged.length === 0) return named;
+  return {
+    ...named,
+    reason: `only: ${unmerged.join(", ")} ended without a merge`,
+    is_finish: false
+  };
+}
+async function not_run(carry, named) {
+  return named?.is_finish === true ? await only_end(carry, named) : named;
+}
+async function declared_among(numbers, listed) {
+  const pool = [...new Set(numbers)].map(
+    (number) => listed.find((issue) => issue.number === number) ?? { number }
+  );
+  return await backlog_plan_comment.declared_of(pool, process.cwd());
+}
+async function holding2(carry, in_flight) {
+  const yielded = backlog_drive_named.named_issues(carry).filter((issue) => lane_plan.is_yielded(issue, process.cwd()));
+  if (yielded.length === 0) return [...in_flight];
+  const listing = await auto_ok_cli.fetch_opted_in();
+  const listed = listing.kind === "read" ? listing.issues : [];
+  const running = lane_plan_probe.running_of(listed).map((issue) => issue.number);
+  const declared = await declared_among([...in_flight.map(Number), ...running], listed);
+  const scopes = await declared_among(yielded, listed);
+  const held3 = yielded.filter(
+    (issue) => lane_plan.is_yield_held(issue, declared, process.cwd(), scopes.get(issue))
+  );
+  return [.../* @__PURE__ */ new Set([...in_flight, ...held3.map(String)])];
+}
+async function launch(issue, named, state, owner) {
+  if (issue === void 0) return void 0;
+  const held3 = await backlog_drive_rate_limit.held(state);
+  return held3 ?? await classify(issue, named, state, owner);
+}
+function is_passed(carry, issue, offered2) {
+  if (issue === void 0 || offered2?.verdict !== "wait") return false;
+  return offered2.retries === NO_RETRIES3 && !backlog_drive_named.is_declared(carry, issue);
+}
+async function offer_of(carry, state, waiting, context) {
+  const named = backlog_drive_named.offer(carry, waiting, context.is_only);
+  if (named?.verdict !== "run") return { offer: await not_run(carry, named), passed: [] };
+  const budget = budget_offer(carry, state, context.forwarded);
+  if (budget.verdict !== "run") return { offer: budget, passed: [] };
+  const [issue] = named.issues;
+  const offered2 = await launch(issue, named, state, context.owner);
+  if (!is_passed(carry, issue, offered2)) return { offer: offered2, passed: [] };
+  const past = await offer_of(
+    carry,
+    state,
+    { ...waiting, in_flight: [...waiting.in_flight, issue] },
+    context
+  );
+  return { ...past, passed: [issue, ...past.passed] };
+}
+function held_alone(state, waiting) {
+  if (state.in_flight.length > 0 || waiting.in_flight.length === 0) return void 0;
+  return { verdict: "wait", issues: [], retries: NO_RETRIES3 };
+}
+async function read(carry, state, context) {
+  await backlog_drive_stalled_retry.sweep();
+  const waiting = { ...state, in_flight: await holding2(carry, state.in_flight) };
+  const { offer: offer3, passed } = await offer_of(carry, state, waiting, context);
+  const pool = {
+    ...state,
+    in_flight: [...state.in_flight, ...passed],
+    exclude: [...state.exclude, ...waiting.in_flight]
+  };
+  return { offer: offer3 ?? held_alone(state, waiting), pool };
+}
+var backlog_drive_named_offer = { read };
+
+// scripts/backlog/backlog-drive-offer-argv.ts
+function running_of(state) {
+  return state.in_flight.length + (backlog_drive_park_triage.is_owed(state) ? 1 : 0);
+}
+function offer_argv(state, carry, forwarded) {
+  const settled2 = [...state.exclude, ...state.waiting ?? []];
+  const exclude = backlog_offer_exclude.exclude_of(settled2, state.in_flight);
+  return [
+    "backlog:offer",
+    "--json",
+    "--started",
+    carry.started_at,
+    "--active",
+    state.active,
+    "--merged",
+    String(carry.merged),
+    "--running",
+    String(running_of(state)),
+    "--retries",
+    String(state.retries),
+    ...backlog_offer_exclude.exclude_argv(exclude),
+    ...forwarded
+  ];
+}
+var backlog_drive_offer_argv = { offer_argv };
+
+// scripts/backlog/backlog-drive-rate.ts
+var { EVENT_KIND } = run_event_stream;
+var PRUNE_COMMAND = "lane:prune";
+function used_delta(before, after) {
+  return before.reset_ms === after.reset_ms ? after.used - before.used : after.used;
+}
+function record_of(before, after) {
+  if (before === void 0 || after === void 0) return { is_missing: true };
+  return {
+    used_delta: used_delta(before, after),
+    remaining: after.remaining,
+    reset: new Date(after.reset_ms).toISOString()
+  };
+}
+async function measured(cycle) {
+  const before = await gh_core_rate_limit.read_allowance();
+  const result = await cycle();
+  const after = await gh_core_rate_limit.read_allowance();
+  await run_event_stream_emit.emit(EVENT_KIND.RATE_LIMIT, JSON.stringify(record_of(before, after)));
+  return result;
+}
+async function offer_run(argv) {
+  return await measured(async () => {
+    await josh_command.josh_run([PRUNE_COMMAND], true);
+    return await josh_command.josh_run(argv, true);
+  });
+}
+var backlog_drive_rate = { measured, offer_run };
+
+// scripts/backlog/backlog-drive-record.ts
+async function read_record() {
+  const target = await run_carry.repository_directory();
+  if (target === void 0) return void 0;
+  const read2 = run_carry.read_carry(run_carry.carry_path(target));
+  return read2.kind === "carried" ? read2.carry : void 0;
+}
+async function is_named_left() {
+  const remaining = run_carry.remaining_of(await read_record()) ?? [];
+  return remaining.length > 0;
+}
+async function stall(issue, outcome) {
+  const comment = [
+    `Parked by \`backlog:drive\`: \`lane:launch\` answered \`${outcome}\` for ${issue_cite.plain_for("program", issue)}.`,
+    "",
+    `Read the lane's log, then ${run_stalled.next_step(issue)}.`
+  ].join("\n");
+  await run_stalled_park.apply(issue, comment, `launch ${outcome}`);
+}
+function record_ports(read2) {
+  return {
+    added_since: async (since_ms) => await backlog_arrival_added.is_added_since(since_ms, read2),
+    raised_since: async (since_ms) => await backlog_arrival_added.is_raised_since(since_ms, read2),
+    named_left: is_named_left,
+    ...backlog_yield_cap.PORTS,
+    stall
+  };
+}
+var backlog_drive_record = { read_record, record_ports };
+
+// scripts/backlog/backlog-drive-retrospective-unit.ts
+function brief_of(owner) {
+  return [
+    "Run the backlogrun retrospective as the run parent would: `pnpm josh doc:read retrospective.md`;",
+    "its digest is `pnpm josh retrospective`.",
+    `Close with \`pnpm josh run:carry --retrospective --summary "<result>" --owner ${owner}\`:`,
+    "the run record is held by that process, not this session.",
+    "Nobody answers this session: a question for a person ends it, written as the final message."
+  ].join(" ");
+}
+var LOG_LABEL = "retrospective";
+function request_of(ports, git_directory, owner) {
+  const log = backlog_drive_unit.log_path(git_directory, LOG_LABEL, ports.now());
+  return backlog_drive_unit.request_of(brief_of(owner), ports, log);
+}
+function production_ports() {
+  return {
+    repository_directory: run_carry.repository_directory,
+    emit: run_event_setup.emit,
+    launch_attached: backlog_drive_unit.launch_attached,
+    is_marked: (git_directory) => run_carry.retrospective_done_of(run_carry.read_carry(run_carry.carry_path(git_directory))),
+    environment: process.env,
+    cwd: process.cwd(),
+    now: () => Date.now()
+  };
+}
+async function run(owner, ports = production_ports()) {
+  const git_directory = await ports.repository_directory();
+  if (git_directory === void 0) return false;
+  const request = request_of(ports, git_directory, owner);
+  if (request === void 0) return false;
+  await ports.emit(run_event_setup.STAGE.RETROSPECTIVE);
+  await ports.launch_attached(request);
+  return ports.is_marked(git_directory);
+}
+var backlog_drive_retrospective_unit = { run };
+
+// scripts/backlog/backlog-drive-tick.ts
+async function snapshot_of(issues, table) {
+  if (issues.length === 0) return void 0;
+  const rows = await table();
+  if (rows === void 0) return void 0;
+  const trace = await lane_snapshot_trace.traces_of(issues, rows);
+  const covered = new Set(issues);
+  return (issue) => covered.has(issue) ? trace(issue) === PROCESS_ALIVE : void 0;
+}
+function liveness(table = lane_process_table.read_table, is_probed_running = lane_await.is_process_running_default) {
+  const current = { snapshot: void 0 };
+  return {
+    is_running: (issue) => current.snapshot?.(issue) ?? is_probed_running(issue),
+    take: async (issues) => {
+      current.snapshot = await snapshot_of(issues, table);
+    }
+  };
+}
+function tick_share(lanes = liveness(), stream = backlog_arrival_added.tick_reader()) {
+  return {
+    is_running: lanes.is_running,
+    read: stream.read,
+    begin_tick: async (in_flight) => {
+      stream.begin_tick();
+      await lanes.take(in_flight);
+    }
+  };
+}
+var backlog_drive_tick = { liveness, tick_share };
+
+// scripts/backlog/backlog-drive-cli.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/backlog/backlog-drive-cli.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var ARGV_OFFSET = 2;
+var SUCCESS_EXIT_CODE4 = 0;
+var FAILURE_EXIT_CODE = 1;
+var POLL_MS = 5e3;
+var FIRST_LINE2 = 0;
+var offer_read_schema = z.object({
+  verdict: z.string(),
+  issues: z.array(z.string()),
+  retries: z.number(),
+  answer: z.string().optional(),
+  cause: z.string().optional(),
+  waiting: z.array(z.number()).optional(),
+  not_before_ms: z.number().optional(),
+  idle_until_ms: z.number().optional(),
+  is_judgment_owed: z.boolean().optional(),
+  reason: z.string().optional(),
+  is_finish: z.boolean().optional()
+});
+var offer_schema = z.object({ [backlog_offer_cli.JSON_KEY]: offer_read_schema });
+function to_offer(out) {
+  return json_value.parse_with(out, offer_schema)?.[backlog_offer_cli.JSON_KEY];
+}
+async function read_offer(state, context) {
+  const carry = await backlog_drive_owner.assert_current(context.owner);
+  const { offer: named, pool } = await backlog_drive_named_offer.read(carry, state, context);
+  const answered2 = named ?? await backlog_drive_rate_limit.held(state);
+  if (answered2 !== void 0) return answered2;
+  const argv = backlog_drive_offer_argv.offer_argv(pool, carry, context.forwarded);
+  const result = await backlog_drive_rate.offer_run(argv);
+  const offer3 = result.code === SUCCESS_EXIT_CODE4 ? to_offer(result.out) : void 0;
+  return offer3 === void 0 ? void 0 : { ...offer3, is_retrospective_owed: backlog_drive_retrospective.is_owed(carry) };
+}
+function merge_token(out, code) {
+  const token = out.split("\n", FIRST_LINE2 + 1)[FIRST_LINE2] ?? "";
+  if (code === SUCCESS_EXIT_CODE4 || backlog_drive.HANDOFF_TOKENS.has(token)) return token;
+  return "";
+}
+function finished_checker(seeded, is_running) {
+  const states = /* @__PURE__ */ new Map();
+  const config = {
+    is_running,
+    is_shipped: lane_await.is_shipped_default,
+    reconfirm_ms: lane_await.RECONFIRM_MS,
+    never_appeared_timeout_ms: lane_await.NEVER_APPEARED_TIMEOUT_MS
+  };
+  return (issue) => {
+    const state = states.get(issue) ?? {
+      appeared: seeded.has(issue),
+      disappeared_at: void 0,
+      first_polled_at: void 0
+    };
+    states.set(issue, state);
+    try {
+      return lane_await.check_issue(issue, state, Date.now(), config) !== void 0;
+    } catch {
+      return true;
+    }
+  };
+}
+async function open_lanes() {
+  const lanes = await lane_registry.list_lanes();
+  return lanes.filter((lane) => !lane.is_stranded);
+}
+function end_line(end) {
+  const token = end.token === void 0 || end.token === end.reason ? [] : [end.token];
+  const issue = end.issue === void 0 ? [] : [issue_cite.plain_for("program", end.issue)];
+  const base = [end.reason, ...token, ...issue].join(" ");
+  return end.detail === void 0 ? base : `${base} ${end.detail}`;
+}
+function judgement_reader() {
+  const cache = /* @__PURE__ */ new Map();
+  return async () => {
+    const owed = await auto_ok_judge_read.owed(cache);
+    return owed?.length ?? 0;
+  };
+}
+function reporters(holds) {
+  return {
+    hold: holds.hold,
+    idle: backlog_drive_idle.notify,
+    paused: backlog_drive_paused.notify
+  };
+}
+function room_ports() {
+  return {
+    free_lanes: backlog_ready.drive_free_lane_count,
+    listing_changed: backlog_drive_listing.watcher(),
+    limit_room: backlog_ready.drive_limit_room,
+    has_lane: backlog_drive_seats.has_kept_lane,
+    memory_held: backlog_drive_memory.gauge(),
+    usage_limited: async () => await run_merge_usage_limit.is_held(Date.now())
+  };
+}
+function child_ports(seeded, owner, is_running) {
+  const known = new Set(seeded);
+  return {
+    is_finished: finished_checker(known, is_running),
+    merge: async (issue) => await backlog_drive_collect.merge(issue, owner),
+    adoptable: async (in_flight) => {
+      const adopting = await backlog_drive_adopt.adoptable(in_flight);
+      for (const issue of adopting) known.add(issue);
+      return adopting;
+    }
+  };
+}
+async function offer_for(state, context) {
+  const read2 = await read_offer(state, context);
+  lane_launch_cli.keep_pending(read2?.verdict === "run" ? read2.issues : []);
+  return read2;
+}
+function ports_of(context, seeded, last, holds) {
+  const tick = backlog_drive_tick.tick_share();
+  return {
+    ...child_ports(seeded, context.owner, tick.is_running),
+    begin_tick: tick.begin_tick,
+    offer: async (state) => await offer_for(state, context),
+    launch: async (issue) => await backlog_drive_launch.launch(issue, context.owner),
+    ...room_ports(),
+    judgement_owed: judgement_reader(),
+    ...reporters(holds),
+    now: () => /* @__PURE__ */ new Date(),
+    sleep,
+    ...backlog_drive_record.record_ports(tick.read),
+    finish: backlog_drive_finish.finish,
+    retrospective: async () => await backlog_drive_retrospective_unit.run(context.owner),
+    on_state: (state) => {
+      last.state = state;
+    }
+  };
+}
+async function seeded_lanes(context) {
+  const carry = await backlog_drive_record.read_record();
+  if (carry === void 0) return void 0;
+  const events = await run_event_stream_emit.current_events();
+  await backlog_drive_named.reconcile(carry, events, context.owner);
+  const open = await open_lanes();
+  const lanes = [.../* @__PURE__ */ new Set([...open.map((lane) => lane.issue), ...context.awaited])];
+  const carried2 = await backlog_drive_carried.carried(open);
+  const dispatched = backlog_drive_named.own_carried(carry, carried2, context.is_only);
+  return {
+    lanes: backlog_drive_restore.restore(lanes, events, carry.merged_issues ?? [], dispatched),
+    left_out: backlog_drive_restore.left_out(events, context.exclude)
+  };
+}
+function loop_config(window_ms) {
+  return {
+    poll_ms: POLL_MS,
+    offer_ms: backlog_budget.OFFER_INTERVAL_MS,
+    idle_offer_ms: backlog_budget.IDLE_OFFER_INTERVAL_MS,
+    check_ms: backlog_budget.LISTING_CHECK_INTERVAL_MS,
+    window_ms
+  };
+}
+async function report_end(end, state, context, holds) {
+  await holds.end(end);
+  console.info(end_line(end));
+  console.info(backlog_drive_args.resume_line(state, context));
+}
+function seeded_state(seeded, context) {
+  const fresh = backlog_drive.initial_state(
+    seeded.lanes,
+    context.active ?? (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const initial = context.stopped === void 0 ? fresh : backlog_drive.merge_stopped(context.stopped, fresh);
+  initial.is_triage_owed = context.is_triage_owed;
+  initial.triage_pid = context.triage_pid;
+  initial.triage_start = context.triage_start;
+  return { ...initial, ...seeded.left_out };
+}
+async function drive(context) {
+  const seeded = await seeded_lanes(context);
+  if (seeded === void 0) return FAILURE_EXIT_CODE;
+  const last = { state: seeded_state(seeded, context) };
+  const holds = backlog_drive_hold.recorder();
+  const ports = ports_of(context, seeded.lanes, last, holds);
+  const end = await backlog_drive.run_loop(last.state, loop_config(context.window_ms), ports);
+  await report_end(end, last.state, context, holds);
+  return SUCCESS_EXIT_CODE4;
+}
+async function run_safe(context) {
+  const stop_sampling = lane_sampler.start();
+  try {
+    return await drive(context);
+  } catch (error) {
+    console.info(`error ${error_text.message_of(error)}`);
+    return FAILURE_EXIT_CODE;
+  } finally {
+    lane_launch_cli.keep_pending([]);
+    stop_sampling();
+  }
+}
+async function run2(argv) {
+  const context = backlog_drive_args.parse(argv);
+  if (context === void 0) {
+    console.error(backlog_drive_args.USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return await run_safe(context);
+}
+async function main(argv) {
+  hook_decision.load_environment_file();
+  process.exitCode = await run2(argv);
+}
+var backlog_drive_cli = {
+  child_ports,
+  end_line,
+  loop_config,
+  merge: backlog_drive_collect.merge,
+  merge_token,
+  offer_argv: backlog_drive_offer_argv.offer_argv,
+  parse: backlog_drive_args.parse,
+  ports_of,
+  read_offer,
+  resume_line: backlog_drive_args.resume_line,
+  run: run2,
+  seeded_state,
+  to_offer
+};
+if (process.argv[1] === fileURLToPath(__josh_source_url)) await main(process.argv.slice(ARGV_OFFSET));
+export {
+  backlog_drive_cli
+};