@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/commands/run-ship-cli.js

@@ -0,0 +1,2615 @@
+#!/usr/bin/env tsx
+import {
+  lane_hand_back_held,
+  run_ship_pre_detach
+} from "./chunk-OTZJXU2R.js";
+import {
+  run_section,
+  run_tail
+} from "./chunk-GM3XLC4W.js";
+import "./chunk-UCUSCLEK.js";
+import "./chunk-BRFQBJ5Y.js";
+import {
+  run_ship_wait_cli,
+  run_ship_waiter
+} from "./chunk-ZHZSZNE2.js";
+import "./chunk-SXULS6DX.js";
+import {
+  early_push_record
+} from "./chunk-QXQ56E56.js";
+import {
+  run_ship_args
+} from "./chunk-EI6JG5DF.js";
+import {
+  run_ship_preflight,
+  run_ship_scoped,
+  run_ship_tree_stamp
+} from "./chunk-F6OWP2AY.js";
+import "./chunk-5TMAPYQD.js";
+import {
+  run_stalled_park
+} from "./chunk-6WEVLIZE.js";
+import "./chunk-BJA5U4Q7.js";
+import "./chunk-KQWSENCT.js";
+import {
+  run_wake_code,
+  run_wake_stop,
+  run_wake_takeover,
+  run_wake_window
+} from "./chunk-HG2NZQD5.js";
+import {
+  run_investigation_record
+} from "./chunk-SVAKCXZ7.js";
+import {
+  run_ship_stop_text
+} from "./chunk-U5HQQWRE.js";
+import "./chunk-T33QDAWD.js";
+import {
+  run_stalled
+} from "./chunk-B33BTNB4.js";
+import {
+  pre_commit_lint_switch
+} from "./chunk-X5XYKDOD.js";
+import {
+  pre_push_related_switch
+} from "./chunk-VCR77BHO.js";
+import {
+  lane_session_broker
+} from "./chunk-MYNM3YMR.js";
+import {
+  lane_session_action,
+  review_pair,
+  review_pair_session,
+  run_ship_review,
+  run_ship_stop_cause
+} from "./chunk-3BNNMJOT.js";
+import {
+  ts_entry_loader
+} from "./chunk-VHRNXWVP.js";
+import {
+  api_auth,
+  lane_relaunch
+} from "./chunk-3GF52L5F.js";
+import "./chunk-GPTO6IZG.js";
+import "./chunk-PZU6FZO6.js";
+import "./chunk-DAJCUSPG.js";
+import {
+  main_merge,
+  main_merge_regenerate
+} from "./chunk-WQJ7O3C3.js";
+import "./chunk-XGMRAKSL.js";
+import "./chunk-US6X7JXC.js";
+import {
+  followup_ship_environment
+} from "./chunk-LBLII7BS.js";
+import "./chunk-PZTWQYRI.js";
+import {
+  run_step_section
+} from "./chunk-RVHBWSIG.js";
+import "./chunk-CADFBQJJ.js";
+import "./chunk-MZHOPRI6.js";
+import "./chunk-XDQOWUVT.js";
+import {
+  main_merge_guard
+} from "./chunk-P4D5RESF.js";
+import "./chunk-ZAJD6T6E.js";
+import "./chunk-6NRTLH6I.js";
+import "./chunk-JB7R3A4A.js";
+import {
+  run_ship_body_draft
+} from "./chunk-J3G2R64I.js";
+import "./chunk-4HBVHYNL.js";
+import "./chunk-KVJDDECB.js";
+import "./chunk-SK2LJBFS.js";
+import {
+  review_final_record
+} from "./chunk-CJAA5GAF.js";
+import {
+  review_round_reuse,
+  run_ship_probe
+} from "./chunk-CJSFC5YI.js";
+import {
+  review_reviewed_tree
+} from "./chunk-Q3463XNL.js";
+import "./chunk-BCK5LW4F.js";
+import "./chunk-HZBTXKT2.js";
+import "./chunk-NMLCPYBN.js";
+import "./chunk-6Q3XUCLM.js";
+import {
+  backlog_ready
+} from "./chunk-5WIZR5SC.js";
+import "./chunk-ZAAHZY2A.js";
+import "./chunk-ILQZFUDC.js";
+import "./chunk-RINVPTA2.js";
+import "./chunk-FNOSSXLG.js";
+import "./chunk-VZSJCFRT.js";
+import "./chunk-PWYXY46Y.js";
+import {
+  lane_capacity
+} from "./chunk-YPNTORQD.js";
+import "./chunk-AM44D7NF.js";
+import "./chunk-NJ53AWJU.js";
+import "./chunk-ANUTT56I.js";
+import "./chunk-P4O67FP5.js";
+import "./chunk-F3WBEEYC.js";
+import "./chunk-JOARHU3M.js";
+import "./chunk-F2J6DGDM.js";
+import "./chunk-T3FD3Q73.js";
+import "./chunk-ZQ3CKRMP.js";
+import "./chunk-M42SLJCD.js";
+import "./chunk-A4HOQKOG.js";
+import "./chunk-QA22PBCJ.js";
+import "./chunk-B2EA2HCY.js";
+import "./chunk-NGKB632X.js";
+import "./chunk-KZSM5M5P.js";
+import "./chunk-YGDNUTTI.js";
+import "./chunk-LC7SBONO.js";
+import "./chunk-6NGNMIMT.js";
+import "./chunk-T2E724HN.js";
+import "./chunk-RZJAUVMI.js";
+import "./chunk-T57W3UWK.js";
+import "./chunk-GIGKMIPQ.js";
+import "./chunk-SADJPNDB.js";
+import {
+  josh_command
+} from "./chunk-2VRITY55.js";
+import "./chunk-ELWNRE6E.js";
+import "./chunk-HLKAFSN4.js";
+import "./chunk-7ZECP3J6.js";
+import "./chunk-3HU3LPIF.js";
+import "./chunk-2CXAVVST.js";
+import "./chunk-J3TKZLHA.js";
+import "./chunk-IZVM2TTH.js";
+import "./chunk-2IESYBZH.js";
+import "./chunk-5PAEXYIY.js";
+import "./chunk-RQRLW4XK.js";
+import "./chunk-TPKFVVJQ.js";
+import "./chunk-BPSJSHYD.js";
+import "./chunk-VDGNXSP3.js";
+import {
+  telegram_notify
+} from "./chunk-WJ4NEDNI.js";
+import "./chunk-5HVYOIIK.js";
+import "./chunk-D4SZK7H2.js";
+import "./chunk-OJ4LGBVD.js";
+import "./chunk-3RIQ36LH.js";
+import "./chunk-2ADQ5XRD.js";
+import "./chunk-7IZJ5MG2.js";
+import "./chunk-HXCZ3KWS.js";
+import "./chunk-EKCKCX5S.js";
+import "./chunk-LUMCYDGE.js";
+import "./chunk-EH3LVYOX.js";
+import "./chunk-HOSZITJM.js";
+import {
+  run_review,
+  run_review_pinned,
+  run_review_pinned_accepted,
+  run_review_pinned_join,
+  run_review_pinned_steps,
+  run_review_pinned_tree
+} from "./chunk-5HCPSV45.js";
+import {
+  test_pinned,
+  test_pinned_record
+} from "./chunk-VZHC2I3T.js";
+import "./chunk-N6TYL3B2.js";
+import "./chunk-HZSQI6TD.js";
+import "./chunk-ESQEEL4O.js";
+import "./chunk-VD5674LW.js";
+import "./chunk-2FJJYCBD.js";
+import "./chunk-D3SHCUBC.js";
+import "./chunk-NFEBQED3.js";
+import "./chunk-LE7TFPMU.js";
+import "./chunk-QX2R6UJG.js";
+import "./chunk-RX5JSPPH.js";
+import "./chunk-U7XU5RG3.js";
+import "./chunk-GJYMI2CM.js";
+import "./chunk-VD72V5VX.js";
+import "./chunk-U2UH4VM4.js";
+import "./chunk-WGULS5DA.js";
+import {
+  RETRY_PENDING_KEY,
+  RETRY_PENDING_VALUE,
+  git_gh_pr_read
+} from "./chunk-23GH6B3D.js";
+import "./chunk-GU5ML3Y3.js";
+import "./chunk-4Z5723GA.js";
+import "./chunk-HBNB3TLG.js";
+import "./chunk-BJKEXXY6.js";
+import {
+  cost_cli
+} from "./chunk-FVVZIJUC.js";
+import "./chunk-GW4UWR3O.js";
+import "./chunk-DKM4UJQU.js";
+import {
+  changed_paths_sync
+} from "./chunk-CA6F5OXK.js";
+import "./chunk-QWX7EBC6.js";
+import "./chunk-6I2JM5UX.js";
+import "./chunk-BYSPYVLD.js";
+import "./chunk-3WWQFCGX.js";
+import "./chunk-LAYSCY4L.js";
+import "./chunk-AVUGMOHZ.js";
+import "./chunk-KVSSLDA3.js";
+import "./chunk-6CJXLPRI.js";
+import "./chunk-GPMSYXYO.js";
+import "./chunk-E2ZCUKHT.js";
+import {
+  FAILURE_MESSAGE_PREFIX,
+  FAILURE_REASON_CHECKS,
+  FAILURE_REASON_CONFLICT
+} from "./chunk-WVR4RUFP.js";
+import "./chunk-HH2KDLTP.js";
+import "./chunk-3EO2XN3A.js";
+import "./chunk-5GBZ43UA.js";
+import {
+  check_reuse
+} from "./chunk-O5FVBIRI.js";
+import "./chunk-SV4FHQE7.js";
+import "./chunk-6SKMZGER.js";
+import "./chunk-LCEJXF7A.js";
+import "./chunk-HE5S4XRE.js";
+import "./chunk-DNJC7X73.js";
+import "./chunk-ENLWXAHD.js";
+import "./chunk-NOXLKIPR.js";
+import {
+  test_pinned_logic
+} from "./chunk-E3CXOVPQ.js";
+import "./chunk-GA6E4VGO.js";
+import "./chunk-7EAMUVIO.js";
+import {
+  review_round
+} from "./chunk-7P4X4TQL.js";
+import "./chunk-PR3JCPP7.js";
+import "./chunk-WMMGXJXP.js";
+import "./chunk-W6MVQEMO.js";
+import "./chunk-T25S4QHL.js";
+import {
+  review_interaction
+} from "./chunk-V5OIPYA6.js";
+import {
+  review_round2
+} from "./chunk-RVUJ6F5L.js";
+import "./chunk-MY3RSOS5.js";
+import "./chunk-KVURNO74.js";
+import "./chunk-QHWJJ6X5.js";
+import "./chunk-REPANBLS.js";
+import "./chunk-Q6SKKQVJ.js";
+import "./chunk-EWA72KO7.js";
+import {
+  run_ship_lap
+} from "./chunk-PE7B7242.js";
+import {
+  review_attest
+} from "./chunk-KIILCKQR.js";
+import "./chunk-WG6GYBRJ.js";
+import "./chunk-CRNPPKP2.js";
+import "./chunk-LAKVPOJQ.js";
+import "./chunk-UU6GCJGM.js";
+import "./chunk-ZDSDPKCD.js";
+import "./chunk-MVPUQLN5.js";
+import "./chunk-5SB37YDW.js";
+import "./chunk-VW5SGE7A.js";
+import "./chunk-ICEMFE2V.js";
+import "./chunk-BIKGPT52.js";
+import "./chunk-PDDKRHHS.js";
+import "./chunk-55I7OYHI.js";
+import "./chunk-DJVMC3U2.js";
+import "./chunk-MSPIR3OA.js";
+import "./chunk-QQZOQ7AM.js";
+import "./chunk-AWLYN2SP.js";
+import "./chunk-L6XN3EXI.js";
+import "./chunk-W4J6YTFE.js";
+import "./chunk-BK6Q4VCA.js";
+import "./chunk-P6RGQXHI.js";
+import "./chunk-KB3OQWDT.js";
+import "./chunk-FGL6DBZU.js";
+import "./chunk-SNO7CY2B.js";
+import "./chunk-RUIBQMOV.js";
+import "./chunk-OZZWRJQI.js";
+import "./chunk-L6LU2633.js";
+import {
+  gate_tree
+} from "./chunk-IXX4SXIP.js";
+import {
+  file_map_stamp
+} from "./chunk-CGLLAEKZ.js";
+import "./chunk-WL5JHB3I.js";
+import "./chunk-4BEIYKI2.js";
+import "./chunk-LE2T3FGJ.js";
+import "./chunk-LQXFVZTS.js";
+import "./chunk-F2HFWLQR.js";
+import "./chunk-6NV2F7QH.js";
+import "./chunk-REMKUFAC.js";
+import "./chunk-VGHSZLYQ.js";
+import "./chunk-7LJQMM2K.js";
+import "./chunk-FROACLVU.js";
+import "./chunk-MGF64OHV.js";
+import "./chunk-RK4HE5NW.js";
+import "./chunk-O26Y2FOJ.js";
+import "./chunk-XH6BGVVP.js";
+import "./chunk-RXAZJMSZ.js";
+import "./chunk-3PEXBHRN.js";
+import "./chunk-RZ4OKKPM.js";
+import "./chunk-PBOS7MTW.js";
+import "./chunk-2NSB5ZYQ.js";
+import "./chunk-2MJ4OCDL.js";
+import "./chunk-IW6NWCSN.js";
+import "./chunk-UCI4AL3Q.js";
+import "./chunk-QS5USD4T.js";
+import "./chunk-WWC5L3AO.js";
+import {
+  lane_ledger
+} from "./chunk-XYAK53TK.js";
+import {
+  agent_argv
+} from "./chunk-NJT5L6IC.js";
+import "./chunk-OHVAEJSM.js";
+import "./chunk-E33LSO2W.js";
+import "./chunk-DXJQHJQ4.js";
+import "./chunk-Y2RNUX4W.js";
+import {
+  agent_role_profile
+} from "./chunk-RIQ75QWR.js";
+import "./chunk-6WTVAL4D.js";
+import "./chunk-LHKXJD6L.js";
+import "./chunk-ROJXMBXP.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-RUWV4INF.js";
+import "./chunk-JTU5A4JI.js";
+import "./chunk-FNQW6NY7.js";
+import "./chunk-337QQM4C.js";
+import "./chunk-BEE7OAQ5.js";
+import "./chunk-DBKTFB5V.js";
+import "./chunk-UCQJDYE3.js";
+import {
+  core_priority
+} from "./chunk-TCBUX52E.js";
+import "./chunk-KXHXMERX.js";
+import "./chunk-MDLOETXL.js";
+import "./chunk-65E4OZJ7.js";
+import "./chunk-NFKULY26.js";
+import {
+  lane_registry
+} from "./chunk-LRS2OS5J.js";
+import {
+  lane_handoff
+} from "./chunk-AI5K4QJO.js";
+import "./chunk-7S6VRZOH.js";
+import "./chunk-LULJUD6P.js";
+import "./chunk-TBNQIFWL.js";
+import "./chunk-P4CWLRT2.js";
+import "./chunk-XFPEUYDV.js";
+import "./chunk-5ZTQX7OS.js";
+import {
+  run_ship_detach
+} from "./chunk-HCA5QG2U.js";
+import {
+  detached_launch
+} from "./chunk-C2SEDMZ3.js";
+import "./chunk-LRA3PXHS.js";
+import "./chunk-6OP63TBT.js";
+import "./chunk-TVZXG4Y4.js";
+import "./chunk-FIUCHMCF.js";
+import "./chunk-XXNEY4B3.js";
+import "./chunk-4PUKDAXL.js";
+import "./chunk-EWVR5AEX.js";
+import "./chunk-C6QSVO5K.js";
+import "./chunk-W3FX7FYN.js";
+import "./chunk-ZBFNQUY7.js";
+import "./chunk-U3IVVR4W.js";
+import "./chunk-O3NDWYNT.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-34LAULSC.js";
+import "./chunk-5Y7QQYTU.js";
+import "./chunk-34DND4BA.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import "./chunk-P4KIQRSL.js";
+import {
+  RUN_STALLED_LABEL
+} from "./chunk-QQBMVC5W.js";
+import "./chunk-TUIFS5E7.js";
+import {
+  lane_child_marker
+} from "./chunk-QAHFPCFR.js";
+import "./chunk-66TGK5XL.js";
+import {
+  agent_profile_schema
+} from "./chunk-EZSO25UZ.js";
+import "./chunk-2DJLAUYB.js";
+import {
+  lane_child_invocation,
+  run_ship_next,
+  run_ship_stop_context
+} from "./chunk-EW4NPUMQ.js";
+import {
+  review_stop_log
+} from "./chunk-BF6YX4HE.js";
+import "./chunk-3LZXX5GL.js";
+import "./chunk-W2IA2LV3.js";
+import {
+  run_ship_stage
+} from "./chunk-OHNP3QL2.js";
+import {
+  session_cite
+} from "./chunk-X7PN54LZ.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 "./chunk-MPGJ4ONJ.js";
+import "./chunk-6WKJ3GDA.js";
+import "./chunk-YIA6FC3K.js";
+import "./chunk-JQXPLMCO.js";
+import "./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 {
+  git_common_directory
+} from "./chunk-FFHEGWPK.js";
+import "./chunk-R6QE5VJG.js";
+import "./chunk-4ZHWTTQW.js";
+import {
+  FULL_PAGE_QUERY,
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./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-UEURNXE5.js";
+import {
+  stamp_file
+} from "./chunk-QWWTC3XR.js";
+import "./chunk-ILGPZ47M.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import "./chunk-KSR23NYN.js";
+import {
+  buffered_process
+} from "./chunk-D5TAR6TV.js";
+import "./chunk-G47ZNQVG.js";
+import {
+  changed_paths
+} from "./chunk-V5FD7DVV.js";
+import {
+  change_base
+} from "./chunk-36LOGVJ7.js";
+import "./chunk-ENFPR7J2.js";
+import "./chunk-F7XLEK55.js";
+import "./chunk-UGCUSRZF.js";
+import {
+  git_command,
+  git_diff_reads
+} from "./chunk-AKQYYHP2.js";
+import {
+  git_spawn
+} from "./chunk-CJKPF5DJ.js";
+import "./chunk-RBU2NKHF.js";
+import "./chunk-NKKH3PBE.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import "./chunk-B5GXZK3E.js";
+import "./chunk-KTLR4Y32.js";
+import "./chunk-ZNX2LJCQ.js";
+import "./chunk-VJE3RJAX.js";
+import "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/ship/run-ship-cli.ts
+import { dirname as __josh_dirname2 } from "node:path";
+import { fileURLToPath as __josh_file_path2 } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// scripts/run/ship/run-ship.ts
+var PREFLIGHT_HEADER = "=== preflight ===";
+var PRE_DETACH_HEADER = "=== pre-detach checks ===";
+var REVIEW_HEADER = "=== review ===";
+var GATE_HEADER = "=== gate ===";
+var SYNC_HEADER = "=== sync origin/main ===";
+var COMMIT_HEADER = "=== commit/push/PR ===";
+var ROUND_TWO_HEADER = "=== round-2 review ===";
+var FOLLOWUP_HEADER = "=== followup ===";
+var REPORT_HEADER = "=== report ===";
+var STOPPED_PREFIX = "stopped at: ";
+var SKIPPED_BODY = "skipped \u2014 already done";
+function mark_of(result) {
+  const { is_skipped, reason } = result;
+  return {
+    ...is_skipped !== void 0 && { is_skipped },
+    ...reason !== void 0 && { reason }
+  };
+}
+function section_of(header, result) {
+  const { conflicts, preconditions, cause } = result;
+  return {
+    header,
+    body: run_tail.section_body(result.out, result.err, result.code),
+    code: result.code,
+    out: result.out,
+    ...conflicts !== void 0 && { conflicts },
+    ...preconditions !== void 0 && { preconditions },
+    ...cause !== void 0 && { cause },
+    ...mark_of(result)
+  };
+}
+function failed_section(sections) {
+  return sections.findLast((section) => section.code !== run_section.SUCCESS_EXIT_CODE);
+}
+function format_report(sections) {
+  const body = run_section.format_sections(sections);
+  const failed = failed_section(sections);
+  if (failed === void 0) return body;
+  return `${body}${run_section.SECTION_SEPARATOR}${STOPPED_PREFIX}${failed.header}`;
+}
+function with_checks(stop, checks3) {
+  if (checks3.code === run_section.SUCCESS_EXIT_CODE) return stop;
+  return {
+    ...stop,
+    preconditions: [...stop.preconditions ?? [], ...checks3.preconditions ?? []]
+  };
+}
+var run_ship = {
+  COMMIT_HEADER,
+  FOLLOWUP_HEADER,
+  GATE_HEADER,
+  PREFLIGHT_HEADER,
+  PRE_DETACH_HEADER,
+  REPORT_HEADER,
+  REVIEW_HEADER,
+  ROUND_TWO_HEADER,
+  SKIPPED_BODY,
+  SYNC_HEADER,
+  STOPPED_PREFIX,
+  exit_code: run_section.exit_code_of,
+  failed_section,
+  format_report,
+  section_of,
+  with_checks
+};
+
+// scripts/git/git-merge-conflicts.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var CLEAN_EXIT_CODE = 0;
+var HEAD = "HEAD";
+function blob_id(revision, file_path, cwd) {
+  return git_spawn_sync.read(["rev-parse", "--verify", "--quiet", `${revision}:${file_path}`], {
+    cwd
+  });
+}
+function working_blob_id(file_path, cwd) {
+  if (!existsSync(path.join(cwd, file_path))) return void 0;
+  return git_spawn_sync.read(["hash-object", "-w", "--", file_path], { cwd });
+}
+function is_one_sided(sides) {
+  return sides.ours === sides.theirs || sides.ours === sides.base || sides.theirs === sides.base;
+}
+function is_complete(sides) {
+  return sides.base !== void 0 && sides.ours !== void 0 && sides.theirs !== void 0;
+}
+function is_merged(sides, cwd) {
+  if (is_one_sided(sides)) return true;
+  if (!is_complete(sides)) return false;
+  const { base, ours, theirs } = sides;
+  const result = git_spawn_sync.run(["merge-file", "-p", "--object-id", ours, base, theirs], {
+    cwd
+  });
+  return result.exit_code === CLEAN_EXIT_CODE;
+}
+function sides_of(file_path, commits, cwd) {
+  return {
+    base: blob_id(commits.base, file_path, cwd),
+    ours: working_blob_id(file_path, cwd),
+    theirs: blob_id(commits.theirs, file_path, cwd)
+  };
+}
+function working_tree_conflicts(theirs, paths3, cwd) {
+  const fork = git_spawn_sync.read(["merge-base", HEAD, theirs], { cwd });
+  if (fork === void 0) return void 0;
+  const base = changed_paths_sync.through_merge(fork, theirs, { cwd });
+  return paths3.filter((file_path) => !is_merged(sides_of(file_path, { base, theirs }, cwd), cwd));
+}
+var git_merge_conflicts = { working_tree_conflicts };
+
+// scripts/run/ship/run-ship-conflict-probe.ts
+var FAILURE_EXIT_CODE = 1;
+var CONFLICT_NOTE = "merging origin/main would stop on a conflict in:";
+function fix_note() {
+  return `The pre-detach checks did not run. Commit the work with ${main_merge_guard.commit_command()}, run \`pnpm josh main:merge\`, resolve the conflict in those files, then run the ship again.`;
+}
+async function read_conflicts() {
+  try {
+    const default_branch = await git_command.get_default_branch();
+    await git_command.fetch_branch(default_branch);
+    const paths3 = await changed_paths.read_changed_paths(false);
+    const root = await git_command.repository_root();
+    return git_merge_conflicts.working_tree_conflicts(`origin/${default_branch}`, paths3, root);
+  } catch {
+    return void 0;
+  }
+}
+async function probe() {
+  const conflicts = await read_conflicts() ?? [];
+  if (conflicts.length === 0 || main_merge_regenerate.is_resolvable(conflicts)) return void 0;
+  const out = [CONFLICT_NOTE, ...conflicts, fix_note()].join("\n");
+  return { code: FAILURE_EXIT_CODE, out, conflicts };
+}
+var run_ship_conflict_probe = { CONFLICT_NOTE, probe, read_conflicts };
+
+// scripts/run/ship/run-ship-detach-wait.ts
+var SUCCESS_EXIT_CODE = 0;
+var UNDER = "under";
+var END_TURN = "end the turn: the supervisor ships the rest";
+async function after_launch(issue) {
+  const verdict = cost_cli.session_verdict();
+  console.info(`cost --cut: ${verdict}`);
+  if (verdict === UNDER) return await run_ship_wait_cli.run([issue]);
+  console.info(END_TURN);
+  return SUCCESS_EXIT_CODE;
+}
+var run_ship_detach_wait = { END_TURN, after_launch };
+
+// scripts/run/ship/run-ship-early-push.ts
+async function push(args) {
+  const state = await run_ship_probe.read_state();
+  if (!state.is_committed || state.is_pushed) {
+    await early_push_record.record("ship", state.is_pushed ? "already-pushed" : "uncommitted");
+    return;
+  }
+  const result = await josh_command.josh_run(
+    ["git", "-y", "--skip-commit", ...args.body, args.title],
+    true
+  );
+  await early_push_record.record("ship", result.code === 0 ? "pushed" : "push-failed");
+}
+async function refresh(stage, is_review, state) {
+  if (!is_review || stage !== run_ship_stage.STAGE.GATE) return state;
+  return await run_ship_probe.read_state();
+}
+var run_ship_early_push = { push, refresh };
+
+// scripts/run/ship/run-ship-group.ts
+async function run(step, execute, sections) {
+  const steps2 = step.beside === void 0 ? [step] : [step, step.beside];
+  const results = await Promise.all(steps2.map(async (current) => await execute(current)));
+  const failed = results.findLastIndex((section) => section.code !== 0);
+  sections.push(...results.filter((_, index) => index !== failed));
+  if (failed !== -1) sections.push(...results.slice(failed, failed + 1));
+  const stopped_step = steps2[failed];
+  return stopped_step === void 0 ? void 0 : { step: stopped_step, sections };
+}
+function settled_phase(section) {
+  const { PHASE: PHASE4 } = run_ship_stage;
+  if (section.code !== 0) return PHASE4.FAILED;
+  return section.is_skipped === true ? PHASE4.SKIPPED : PHASE4.DONE;
+}
+var run_ship_group = { run, settled_phase };
+
+// scripts/run/ship/run-ship-handover.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { fileURLToPath } from "node:url";
+
+// scripts/run/ship/run-ship-relaunch.ts
+function holder_pid(repository, number) {
+  return run_ship_detach.read_record(repository, number)?.pid;
+}
+function successor_argv() {
+  return {
+    command: process.execPath,
+    args: [...ts_entry_loader.loader_argv(process.execArgv), ...process.argv.slice(1)]
+  };
+}
+function relaunch(request2) {
+  const launch_id = process.env[run_ship_detach.LAUNCH_ID_KEY];
+  if (launch_id === void 0) return void 0;
+  const result = detached_launch.launch(
+    {
+      argv: successor_argv(),
+      cwd: request2.cwd,
+      log_path: run_ship_detach.log_path(request2.repository, request2.number),
+      env: run_ship_detach.supervisor_environment(launch_id)
+    },
+    console.error
+  );
+  return result.kind === "launched" ? result.pid : void 0;
+}
+var run_ship_relaunch = { holder_pid, relaunch };
+
+// scripts/run/ship/run-ship-handover.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/run/ship/run-ship-handover.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 ENTRY = fileURLToPath(new URL("run-ship-cli.ts", __josh_source_url));
+var ROOT = fileURLToPath(new URL("../../..", __josh_source_url));
+var HANDOVER_HEADER = "=== handover ===";
+var SUCCESS_EXIT_CODE2 = 0;
+async function never_stale() {
+  return false;
+}
+async function watch() {
+  if (!run_ship_detach.is_supervised()) return never_stale;
+  return await run_wake_code.watch(run_wake_code.source_of(ROOT, ENTRY));
+}
+function ports_of(repository, number) {
+  return {
+    holder_pid: () => run_ship_relaunch.holder_pid(repository, number),
+    is_alive: process_identity.is_live_pid,
+    stop: run_wake_stop.signal
+  };
+}
+async function note(number, text) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.NOTE,
+    `${issue_cite.plain_for("program", number)} ${text}`
+  );
+}
+async function take_over(args, repository) {
+  const pid = run_ship_relaunch.relaunch({ repository, number: args.number, cwd: process.cwd() });
+  if (pid === void 0) return void 0;
+  const result = await run_wake_takeover.await_takeover(pid, ports_of(repository, args.number));
+  return result === "taken" ? pid : void 0;
+}
+function handed_over(pid) {
+  return {
+    header: HANDOVER_HEADER,
+    body: `code changed on main \u2014 process ${String(pid)} ships the rest on the new code`,
+    code: SUCCESS_EXIT_CODE2
+  };
+}
+async function hand_over(args, is_stale) {
+  if (!await is_stale()) return void 0;
+  const repository = await run_ship_probe.repository_directory();
+  if (repository === void 0) return void 0;
+  const pid = await take_over(args, repository);
+  if (pid === void 0) {
+    await note(
+      args.number,
+      `The ship supervisor's code changed on main, but no successor took the ship over, so process ${String(process.pid)} runs the rest on the code it started with.`
+    );
+    return void 0;
+  }
+  await note(
+    args.number,
+    `The ship supervisor's code changed on main, so process ${String(process.pid)} handed the ship to process ${String(pid)} on the new code.`
+  );
+  return handed_over(pid);
+}
+var run_ship_handover = { hand_over, watch };
+
+// scripts/run/ship/run-ship-infra-retry.ts
+import { setTimeout as delay } from "node:timers/promises";
+var MAX_INFRA_RETRIES = 2;
+var RETRY_DELAY_MS = 6e4;
+var RETRY_CAP = String(MAX_INFRA_RETRIES);
+var DEFAULT_HOOKS = {
+  wait: async (milliseconds) => {
+    await delay(milliseconds);
+  },
+  note: (text) => {
+    process.stderr.write(`${text}
+`);
+  }
+};
+function is_retryable(stage, section) {
+  if (section.code === 0 || run_ship_stop_cause.is_review(stage)) return false;
+  return run_ship_stop_cause.cause_of(stage, section) === run_ship_stop_cause.CAUSE.INFRA;
+}
+async function run_attempt(attempt, retries_left) {
+  if (retries_left === 0) return await attempt();
+  process.env[RETRY_PENDING_KEY] = RETRY_PENDING_VALUE;
+  try {
+    return await attempt();
+  } finally {
+    Reflect.deleteProperty(process.env, RETRY_PENDING_KEY);
+  }
+}
+async function retried(stage, attempt, hooks = DEFAULT_HOOKS, retries_left = MAX_INFRA_RETRIES) {
+  const section = await run_attempt(attempt, retries_left);
+  if (retries_left === 0 || !is_retryable(stage, section)) return section;
+  const ordinal = String(MAX_INFRA_RETRIES - retries_left + 1);
+  hooks.note(`josh ship: ${stage} stopped on the infrastructure \u2014 retry ${ordinal}/${RETRY_CAP}`);
+  await hooks.wait(RETRY_DELAY_MS);
+  return await retried(stage, attempt, hooks, retries_left - 1);
+}
+var run_ship_infra_retry = { MAX_INFRA_RETRIES, RETRY_DELAY_MS, retried };
+
+// scripts/run/ship/run-ship-pre-detach-pinned.ts
+import { randomUUID } from "node:crypto";
+
+// scripts/run/ship/run-ship-pre-detach-timed.ts
+var SUCCESS_EXIT_CODE3 = 0;
+var { PHASE } = run_ship_stage;
+async function emit_phase(issue, phase) {
+  const text = run_ship_stage.event_text(issue, lane_ledger_write.PRE_DETACH_STAGE, phase);
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SHIP_STAGE, text);
+}
+async function checks(issue, run5 = run_ship_pre_detach.checks) {
+  await emit_phase(issue, PHASE.START);
+  const started_ms = performance.now();
+  const result = await run5();
+  const elapsed_ms = performance.now() - started_ms;
+  await lane_ledger_write.record_stage({
+    stage: lane_ledger_write.PRE_DETACH_STAGE,
+    elapsed_ms,
+    issue: Number(issue)
+  });
+  await emit_phase(issue, result.code === SUCCESS_EXIT_CODE3 ? PHASE.DONE : PHASE.FAILED);
+  return result;
+}
+var run_ship_pre_detach_timed = { checks };
+
+// scripts/run/ship/run-ship-pre-detach-pinned.ts
+var SUCCESS_EXIT_CODE4 = 0;
+var FAILURE_EXIT_CODE2 = 1;
+var SKIPPED_NOTE = "test:pinned not run before the detach; round 1 lists the unpinned places under --unpinned-ok: ";
+var CARRIED_NOTE = "josh ship: --unpinned-ok carried from an earlier run on this branch: ";
+async function own_summary(reason) {
+  const token = randomUUID();
+  const argv = ["josh", ...test_pinned_record.launch_argv(token, reason, "pre-detach")];
+  const result = await buffered_process.run_buffered_process(argv);
+  const answer = test_pinned_record.read(token);
+  test_pinned_record.clear(token);
+  return answer ?? test_pinned_record.not_run_summary(result.output);
+}
+function remaining_note(remaining) {
+  const hunks = remaining === void 0 ? "the remaining hunks" : `${String(remaining)} remaining hunks`;
+  return `test:pinned: probing ${hunks} in the background \u2014 the next ship's pre-detach reads their verdicts
+`;
+}
+async function is_rest_launched() {
+  try {
+    const tree = await run_review_pinned_tree.key();
+    run_review_pinned_steps.clear();
+    return run_review_pinned_steps.launch_remaining(PROJECT_ROOT, tree).kind === "launched";
+  } catch (error) {
+    error_text.trace_swallowed("run_ship_pre_detach_pinned.is_rest_launched", error);
+    return false;
+  }
+}
+async function continued(answer) {
+  if (answer.is_cut !== true || !await is_rest_launched()) return answer;
+  return { ...answer, text: `${answer.text}${remaining_note(answer.remaining)}` };
+}
+async function summary(reason) {
+  const answer = await run_review_pinned_join.answer_on_tree();
+  const is_whole = answer?.is_cut !== true || reason === void 0;
+  return await continued(answer !== void 0 && is_whole ? answer : await own_summary(reason));
+}
+async function held_summary() {
+  try {
+    const report = await test_pinned.held_report(test_pinned_logic.DEFAULT_MAX_HUNKS);
+    return report === void 0 ? void 0 : test_pinned_record.summary_of(report);
+  } catch (error) {
+    error_text.trace_swallowed("run_ship_pre_detach_pinned.held_summary", error);
+    return void 0;
+  }
+}
+async function summary_for(reason) {
+  const held = reason === void 0 ? void 0 : await held_summary();
+  return held ?? await summary(reason);
+}
+async function is_listed_after_detach(number) {
+  try {
+    return !await review_round_reuse.is_reusable_here(Number(number));
+  } catch (error) {
+    error_text.trace_swallowed("run_ship_pre_detach_pinned.is_listed_after_detach", error);
+    return false;
+  }
+}
+async function pinned_check(options) {
+  const reason = run_review_pinned.ok_reason_of(options.unpinned_ok);
+  if (reason !== void 0 && await is_listed_after_detach(options.number)) {
+    return { code: SUCCESS_EXIT_CODE4, out: `${SKIPPED_NOTE}${reason}
+` };
+  }
+  const verdict = await run_review_pinned_accepted.judge(await summary_for(reason), reason);
+  return {
+    code: verdict.kind === "stop" ? FAILURE_EXIT_CODE2 : SUCCESS_EXIT_CODE4,
+    out: verdict.text
+  };
+}
+function cleared() {
+  try {
+    run_review_pinned_steps.clear();
+  } catch (error) {
+    error_text.trace_swallowed("run_ship_pre_detach_pinned.cleared", error);
+  }
+}
+function checks_for(options) {
+  if (!options.is_review) {
+    return async () => {
+      cleared();
+      return await run_ship_pre_detach.checks();
+    };
+  }
+  return async () => await run_ship_pre_detach.checks(process.cwd(), check_reuse.DEFAULT_RECORDS, async () => {
+    return await pinned_check(options);
+  });
+}
+async function timed_checks(args) {
+  return await run_ship_pre_detach_timed.checks(args.number, checks_for(args));
+}
+async function with_recorded_reason(args) {
+  if (!args.is_review || args.unpinned_ok.length > 0) return args;
+  const reason = await run_review_pinned_accepted.recorded_reason();
+  if (reason === void 0) return args;
+  console.info(`${CARRIED_NOTE}${reason}`);
+  return { ...args, unpinned_ok: [run_review_pinned.UNPINNED_OK_FLAG, reason] };
+}
+var run_ship_pre_detach_pinned = { checks_for, pinned_check, timed_checks, with_recorded_reason };
+
+// scripts/run/ship/run-ship-reship.ts
+var { PHASE: PHASE2, STAGE } = run_ship_stage;
+var { CAUSE } = run_ship_stop_cause;
+var SUCCESS_EXIT_CODE5 = 0;
+var REVIEW_REASONS = /* @__PURE__ */ new Set([STAGE.REVIEW, STAGE.ROUND_TWO]);
+var FIX_CAUSES = /* @__PURE__ */ new Set([CAUSE.CHECK, CAUSE.FINDING]);
+var FOLLOWUP_CHECK = { reason: STAGE.FOLLOWUP, cause: CAUSE.CHECK };
+var SHIP_STAGES = /* @__PURE__ */ new Set([
+  ...Object.values(STAGE),
+  lane_ledger_write.PRE_DETACH_STAGE
+]);
+var SKIP_REASON = "re-ship after review or followup failure";
+var SKIP_NOTE = `${lane_ledger_write.PRE_DETACH_STAGE}: skipped (${SKIP_REASON})`;
+function is_followup_check(stop) {
+  return stop.reason === FOLLOWUP_CHECK.reason && stop.cause === FOLLOWUP_CHECK.cause;
+}
+function is_fix_failure(stop) {
+  if (is_followup_check(stop)) return true;
+  return REVIEW_REASONS.has(stop.reason) && FIX_CAUSES.has(stop.cause ?? "");
+}
+async function with_base(stop) {
+  if (!is_fix_failure(stop)) return stop;
+  const base = await change_base.resolved_through_merge();
+  return base === void 0 ? stop : { ...stop, base };
+}
+function is_ship_mark(entry, issue) {
+  if (entry.kind === lane_ledger.KIND.STOP) return entry.issue === issue;
+  return entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue && SHIP_STAGES.has(entry.stage);
+}
+async function last_stop(issue, path2) {
+  const ledger = path2 ?? await lane_ledger_write.target();
+  if (ledger === void 0) return void 0;
+  const marks = lane_ledger.read_entries(ledger).filter((entry) => is_ship_mark(entry, Number(issue)));
+  const last = marks.at(-1);
+  return last?.kind === lane_ledger.KIND.STOP ? last : void 0;
+}
+async function is_due(issue, path2) {
+  const last = await last_stop(issue, path2);
+  if (last?.base === void 0 || !is_fix_failure(last)) return false;
+  return last.base === await change_base.resolved_through_merge();
+}
+async function skipped(issue) {
+  const text = run_ship_stage.event_text(issue, lane_ledger_write.PRE_DETACH_STAGE, PHASE2.SKIPPED);
+  console.error(SKIP_NOTE);
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.SHIP_STAGE,
+    run_ship_stage.with_reason(text, SKIP_REASON)
+  );
+  return { header: run_ship.PREFLIGHT_HEADER, body: SKIP_NOTE, code: SUCCESS_EXIT_CODE5 };
+}
+async function pinned_only(args) {
+  const passed = { code: SUCCESS_EXIT_CODE5, out: run_ship_pre_detach.PASSED };
+  return run_ship_pre_detach.with_pinned(
+    passed,
+    await run_ship_pre_detach_pinned.pinned_check(args)
+  );
+}
+async function checks2(args) {
+  if (!args.is_review) return { code: SUCCESS_EXIT_CODE5, out: SKIP_NOTE };
+  return await run_ship_pre_detach_timed.checks(args.number, async () => await pinned_only(args));
+}
+var run_ship_reship = { SKIP_NOTE, SKIP_REASON, checks: checks2, is_due, skipped, with_base };
+
+// scripts/run/ship/run-ship-return.ts
+import { setTimeout as sleep2 } from "node:timers/promises";
+
+// scripts/run/ship/run-ship-place.ts
+import { setTimeout as sleep } from "node:timers/promises";
+var PLACE_POLL_MS = 3e4;
+var PLACE_POLLS = 120;
+var RELAUNCH_OVERSHOOT = 1;
+function is_behind(lane, issue) {
+  return lane.issue.localeCompare(issue, void 0, { numeric: true }) > 0;
+}
+async function waiters_behind(issue) {
+  const lanes = await lane_registry.list_lanes();
+  return lanes.filter(
+    (lane) => is_behind(lane, issue) && lane_handoff.is_place_waiting(lane.issue, lane.directory)
+  ).length;
+}
+async function is_over_limit(issue) {
+  const limit = await lane_capacity.lane_limit();
+  if (limit.kind !== "limit") return false;
+  const use = await backlog_ready.lane_use();
+  const behind = await waiters_behind(issue);
+  return use.occupied - behind > lane_capacity.seated_limit(limit.limit) + RELAUNCH_OVERSHOOT;
+}
+async function is_place_taken(issue) {
+  try {
+    return await is_over_limit(issue);
+  } catch {
+    return false;
+  }
+}
+function mark(lane, is_waiting) {
+  const repository = git_common_directory.repository(lane.directory);
+  if (repository === void 0) return;
+  try {
+    run_ship_stage.mark_place_waiting(
+      run_ship_stage.record_path(repository, lane.issue),
+      is_waiting
+    );
+  } catch {
+  }
+}
+async function wait_for_place(issue) {
+  const is_free = await poll.poll_until(async () => !await is_place_taken(issue), {
+    attempts: PLACE_POLLS,
+    interval_ms: PLACE_POLL_MS,
+    sleeper: sleep
+  });
+  if (!is_free) await sleep(PLACE_POLL_MS);
+}
+async function await_place(lane, stage) {
+  if (stage !== run_ship_stage.STAGE.FOLLOWUP) return;
+  mark(lane, true);
+  try {
+    await wait_for_place(lane.issue);
+  } finally {
+    mark(lane, false);
+  }
+}
+var run_ship_place = { await_place };
+
+// scripts/run/ship/run-ship-relaunch-cap.ts
+var MAX_SHIP_STOP_RELAUNCHES = 4;
+var PARK_CAUSE = "ship-stop cap";
+var TIMEOUT_PARK_CAUSE = "merge-wait timeout";
+var CI_INFRA_PARK_CAUSE = "CI infrastructure failure";
+var { CI_INFRA } = run_ship_stop_cause.CAUSE;
+var { CHILD_LAUNCH, SHIP_STOP } = run_event_stream.EVENT_KIND;
+var STOP_KIND = { REVIEW: "review", MECHANICAL: "mechanical" };
+var REVIEW_REASONS2 = /* @__PURE__ */ new Set([
+  run_ship_stage.STAGE.REVIEW,
+  run_ship_stage.STAGE.ROUND_TWO
+]);
+function kind_of(reason) {
+  return reason !== void 0 && REVIEW_REASONS2.has(reason) ? STOP_KIND.REVIEW : STOP_KIND.MECHANICAL;
+}
+function is_capped_stop(text) {
+  return run_ship_stop_text.cause_of(text) !== CI_INFRA;
+}
+function is_stop_of(event, kind) {
+  if (event.kind !== SHIP_STOP || !is_capped_stop(event.text)) return false;
+  return kind_of(run_ship_stop_text.reason_of(event.text)) === kind;
+}
+function stops_since_dispatch(events, issue, kind) {
+  const own = events.filter((event) => run_event_scope.issue_named(event) === issue);
+  const dispatched = own.findLastIndex((event) => event.kind === CHILD_LAUNCH);
+  return own.slice(dispatched + 1).filter((event) => is_stop_of(event, kind)).length;
+}
+async function is_over(issue, reason) {
+  const events = await run_event_stream_emit.all_events();
+  return stops_since_dispatch(events, issue, kind_of(reason)) > MAX_SHIP_STOP_RELAUNCHES;
+}
+function park_comment(issue, lead, blocked) {
+  return [
+    lead,
+    ...blocked === void 0 ? [] : ["", `Cause: \`${blocked}\``],
+    "",
+    `Read the stop with \`pnpm josh ship --log ${issue}\`, then ${run_stalled.next_step(issue)}.`
+  ].join("\n");
+}
+async function park_with(issue, notice, parked2) {
+  const { blocked, stop } = parked2;
+  const comment = park_comment(issue, notice.lead, blocked);
+  const is_parked = await run_stalled_park.apply(issue, comment, blocked ?? notice.cause, { stop });
+  if (!is_parked) return false;
+  await telegram_notify.warn({
+    issue_title: `${notice.title} ${issue_cite.plain_for("telegram", issue)}`,
+    body: notice.body,
+    recovery: `Read pnpm josh ship --log ${issue}, then fix the cause and remove ${RUN_STALLED_LABEL} to offer it again.`
+  });
+  return true;
+}
+async function park(issue, parked2) {
+  const { reason } = parked2;
+  const kind = kind_of(reason);
+  const relaunches = String(MAX_SHIP_STOP_RELAUNCHES);
+  return await park_with(
+    issue,
+    {
+      lead: `Parked by the \`josh ship\` supervisor: the ship stopped at \`${reason}\` after ${relaunches} relaunches of the lane child for ${kind} stops since its dispatch \u2014 the ${kind} stop cap was exceeded.`,
+      cause: PARK_CAUSE,
+      title: "Ship stop cap reached",
+      body: `The lane child's ${kind} stops passed their cap of ${relaunches} relaunches since its dispatch, the last at ${reason}, so it was not relaunched and the issue is parked.`
+    },
+    parked2
+  );
+}
+async function park_timed_out(issue, parked2) {
+  const { reason } = parked2;
+  return await park_with(
+    issue,
+    {
+      lead: `Parked by the \`josh ship\` supervisor: the merge wait at \`${reason}\` timed out, which a relaunch of the lane child does not clear, so none was started.`,
+      cause: TIMEOUT_PARK_CAUSE,
+      title: "Merge wait timed out",
+      body: `The merge wait at ${reason} timed out, so the lane child was not relaunched and the issue is parked.`
+    },
+    parked2
+  );
+}
+async function park_ci_infra(issue, parked2) {
+  const { reason } = parked2;
+  return await park_with(
+    issue,
+    {
+      lead: `Parked by the \`josh ship\` supervisor: CI infrastructure failures outlasted every rerun at \`${reason}\`, which a relaunch of the lane child does not clear, so none was started. Resume it once CI recovers.`,
+      cause: CI_INFRA_PARK_CAUSE,
+      title: CI_INFRA_PARK_CAUSE,
+      body: `CI infrastructure failures outlasted every rerun at ${reason}, so the lane child was not relaunched and the issue is parked until CI recovers.`
+    },
+    parked2
+  );
+}
+async function park_at_once(issue, parked2) {
+  if (parked2.stop.cause === CI_INFRA) return await park_ci_infra(issue, parked2);
+  return await park_timed_out(issue, parked2);
+}
+var run_ship_relaunch_cap = {
+  MAX_SHIP_STOP_RELAUNCHES,
+  STOP_KIND,
+  is_over,
+  kind_of,
+  park,
+  park_at_once,
+  park_timed_out,
+  stops_since_dispatch
+};
+
+// scripts/run/ship/run-ship-return.ts
+var OPENAI_PROVIDER = "openai";
+var SERVING_POLL_MS = 1e3;
+var SERVING_POLLS = 60;
+var RELOAD_POLLS = (run_wake_window.WINDOW_MS + run_wake_window.PASS_INTERVAL_MS) / SERVING_POLL_MS + SERVING_POLLS;
+var VERSION_MISMATCH_NOTE = "the lane broker runs older code than this ship (a version mismatch), and no broker on the current code read the request within the wait";
+function stop_text(issue, stage, resume, output) {
+  const reason = run_ship_stage.stop_reason(stage, resume.conflicts);
+  const cause = run_ship_stop_cause.cause_of(stage, { ...resume, ...output });
+  return run_ship_stop_text.format(issue, reason, cause);
+}
+function can_relaunch(lane) {
+  return lane !== void 0 && lane.profile?.provider !== OPENAI_PROVIDER;
+}
+async function lane_to_relaunch(issue) {
+  if (!lane_child_marker.is_child_of(process.cwd())) return void 0;
+  const lane = await lane_registry.find_open_lane(issue);
+  return can_relaunch(lane) ? lane : void 0;
+}
+function note2(text) {
+  process.stderr.write(`${text}
+`);
+}
+async function record_failed_relaunch(issue, reason) {
+  note2(`the lane child could not be relaunched: ${reason}`);
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.RELAUNCH_FAILED,
+    `${issue_cite.plain_for("program", issue)} could not be relaunched: ${reason}`
+  );
+}
+async function relaunched(lane, stop) {
+  const invocation = lane_child_invocation.ship_stop_invocation(lane.issue, stop);
+  const phase = agent_profile_schema.IMPLEMENTATION_PHASE;
+  const result = await lane_relaunch.relaunch(lane, invocation, phase, note2);
+  if (result.kind === "launched") return "relaunched";
+  await record_failed_relaunch(lane.issue, result.note);
+  return "recorded";
+}
+async function ask_broker(lane, stop) {
+  const answer = await lane_session_broker.request(lane.directory, lane.issue, {
+    kind: "relaunch",
+    stop
+  });
+  if (answer.is_success) return { reply: "started", reason: "" };
+  note2(`the lane broker did not start the lane child \u2014 ${answer.reason}`);
+  const reply = lane_session_broker.is_unreadable(answer) ? "unreadable" : "failed";
+  return { reply, reason: answer.reason };
+}
+async function await_server(lane, previous, polls = SERVING_POLLS) {
+  const found = await poll.poll_for(
+    () => {
+      const session = lane_session_broker.serving_session(lane.directory, lane.issue);
+      return session === previous ? void 0 : session;
+    },
+    { attempts: polls, interval_ms: SERVING_POLL_MS, sleeper: sleep2 }
+  );
+  if (found === void 0 && polls > 0) await sleep2(SERVING_POLL_MS);
+  return found;
+}
+function polls_after(reply) {
+  return reply === "unreadable" ? RELOAD_POLLS : SERVING_POLLS;
+}
+function redispatch_reason(last) {
+  const cause = last.reply === "unreadable" ? `${VERSION_MISMATCH_NOTE}: ` : "";
+  return `${cause}the driver re-dispatches the issue \u2014 ${last.reason}`;
+}
+async function brokered(lane, stop, server) {
+  const first = await ask_broker(lane, stop);
+  if (first.reply === "started") return "relaunched";
+  const next = await await_server(lane, server, polls_after(first.reply));
+  const last = next === void 0 ? first : await ask_broker(lane, stop);
+  if (last.reply === "started") return "relaunched";
+  await record_failed_relaunch(lane.issue, redispatch_reason(last));
+  return "redispatch";
+}
+async function is_returned(issue, stop) {
+  const repository = await run_ship_probe.repository_directory();
+  if (repository === void 0) return false;
+  const stop_note = lane_child_invocation.ship_stop_note(issue, stop);
+  return await run_ship_waiter.offer(repository, issue, stop_note);
+}
+async function relaunched_or_brokered(lane, stop) {
+  await run_ship_place.await_place(lane, stop.stage);
+  const server = await await_server(lane);
+  return server === void 0 ? await relaunched(lane, stop) : await brokered(lane, stop, server);
+}
+async function parked(issue, parking, output, is_at_once) {
+  const blocked = run_ship_stop_cause.blocked_cause_of(output.body);
+  const { park: park2, park_at_once: park_at_once2 } = run_ship_relaunch_cap;
+  const is_parked = await (is_at_once ? park_at_once2 : park2)(issue, { ...parking, blocked });
+  if (is_parked) return "parked";
+  note2("the lane child was not relaunched, and the park label was refused");
+  return "recorded";
+}
+async function park_outcome(issue, stage, resume, output) {
+  const reason = run_ship_stage.stop_reason(stage, resume.conflicts);
+  const failed = { ...resume, ...output };
+  const is_at_once = run_ship_stop_cause.parks_at_once(stage, failed);
+  if (is_at_once || await run_ship_relaunch_cap.is_over(issue, reason)) {
+    const stop = { stage, cause: run_ship_stop_cause.cause_of(stage, failed) };
+    return await parked(issue, { reason, stop }, output, is_at_once);
+  }
+  return void 0;
+}
+async function keep_stop(issue, stop) {
+  const repository = await run_ship_probe.repository_directory();
+  if (repository === void 0) return;
+  await run_ship_detach.mark_stop(
+    repository,
+    issue,
+    lane_child_invocation.ship_stop_invocation(issue, stop)
+  );
+}
+async function stopped(issue, stage, resume, output) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.SHIP_STOP,
+    stop_text(issue, stage, resume, output)
+  );
+  await keep_stop(issue, { stage, ...resume });
+  const lane = await lane_to_relaunch(issue);
+  if (lane === void 0) return "recorded";
+  const parked_outcome = await park_outcome(issue, stage, resume, output);
+  if (parked_outcome !== void 0) return parked_outcome;
+  const findings = run_ship_stop_cause.details_of(stage, { ...resume, ...output });
+  const context = await run_ship_stop_context.build(issue, output.body, findings);
+  const stop = { stage, ...resume, context };
+  return await is_returned(issue, stop) ? "returned" : await relaunched_or_brokered(lane, stop);
+}
+async function return_control(issue, stage, resume, output) {
+  return await stopped(issue, stage, resume, { body: output });
+}
+function stopped_resume(resume, failed) {
+  const { conflicts, cause } = failed ?? {};
+  return {
+    ...resume,
+    ...conflicts !== void 0 && { conflicts },
+    ...cause !== void 0 && { cause }
+  };
+}
+async function hand_back(args, stage, failed) {
+  const is_review_stale = await run_ship_probe.read_review_stale();
+  const resume = { ...run_ship_next.resume_of(args), is_review_stale };
+  return await stopped(args.number, stage, stopped_resume(resume, failed), failed ?? { body: "" });
+}
+var run_ship_return = { hand_back, return_control };
+
+// scripts/run/ship/run-ship-final-review.ts
+async function run2(issue, review) {
+  const stamp = review_final_record.stamp(issue);
+  const tree = await gate_tree.read_gate_tree();
+  const is_stale = await review_round_reuse.is_stale_here();
+  if (!is_stale && run_ship_tree_stamp.is_reusable(stamp, tree)) {
+    return { code: 0, out: "final round 2 reused on the reviewed tree", is_skipped: true };
+  }
+  stamp.write(tree.files, void 0, tree.base);
+  const result = await review();
+  run_ship_tree_stamp.complete(stamp, tree, result.code);
+  return result;
+}
+var run_ship_final_review = { run: run2 };
+
+// scripts/run/ship/run-ship-review-checkpoint.ts
+function checkpoints(issue, stage, phases, head) {
+  return phases.map(([name, phase]) => ({
+    name,
+    phase,
+    stamp: file_map_stamp.create(
+      `josh-ship-review-step-${issue}-${stage}-${name}-`,
+      PROJECT_ROOT,
+      () => head
+    )
+  }));
+}
+function matches(stamp, tree) {
+  const prior = stamp.read();
+  if (prior?.completed_at === void 0) return false;
+  return stamp.describes_inputs(prior) && file_map_stamp.describes_base(prior, tree.base) && file_map_stamp.changed_since(prior, tree.files).length === 0;
+}
+async function attested_prefix(entries, count) {
+  const provider = entries.findIndex(({ name }) => name === "provider");
+  if (provider === -1 || provider >= count) return count;
+  const { status } = await review_attest.check_here();
+  return status === "missing" || status === "mismatch" ? provider : count;
+}
+async function reusable_prefix(entries, tree, is_stale) {
+  const missing = entries.findIndex(({ stamp }) => is_stale || !matches(stamp, tree));
+  const count = await attested_prefix(entries, missing === -1 ? entries.length : missing);
+  for (const { stamp } of entries.slice(count)) stamp.remove();
+  return count;
+}
+async function recorded(phase, stamp, tree) {
+  stamp.write(tree.files, void 0, tree.base);
+  const result = await phase();
+  if (result.code === 0) stamp.complete();
+  return result;
+}
+async function run3(issue, stage, phases, is_stale = false) {
+  const tree = await gate_tree.read_gate_tree();
+  if (tree.base === void 0 || Object.keys(tree.files).length === 0) {
+    for (const { stamp } of checkpoints(issue, stage, phases, "")) stamp.remove();
+    return await run_ship_scoped.run_phases(phases.map(([, phase]) => phase));
+  }
+  const entries = checkpoints(issue, stage, phases, await git_command.head_commit());
+  const count = await reusable_prefix(entries, tree, is_stale);
+  return await run_ship_scoped.run_phases(
+    entries.map(({ name, phase, stamp }, index) => async () => {
+      if (index < count) return { code: 0, out: `review step ${name}: reused` };
+      return await recorded(phase, stamp, tree);
+    })
+  );
+}
+var run_ship_review_checkpoint = { run: run3 };
+
+// scripts/run/ship/run-ship-review-reason.ts
+var HELD_REASON = "reused: round 1 attested on this branch, its tree held";
+var DELTA_REASON = "reused: round 1 attested on this branch, what moved since is round 2's delta";
+var RAN_PREFIX = "ran: --review with no reusable round 1 \u2014 ";
+var UNNAMED_CAUSE = "the recorded round does not cover this tree";
+function reused(answer) {
+  const reason = answer.reuse === review_round_reuse.REUSE.HELD ? HELD_REASON : DELTA_REASON;
+  return answer.note === void 0 ? reason : `${reason} \u2014 ${answer.note}`;
+}
+function ran(answer) {
+  return `${RAN_PREFIX}${answer.cause ?? UNNAMED_CAUSE}`;
+}
+var run_ship_review_reason = { ran, reused };
+
+// scripts/run/ship/run-ship-brokered-review.ts
+var { CODE } = review_attest.REVIEW_SLOT;
+function copy_stamp(source, target) {
+  const text = stamp_file.read_stamp_text(source);
+  if (text !== void 0) stamp_file.write_text_stamp(target, text);
+}
+async function code_request(directory, issue, round) {
+  return await lane_session_broker.request(directory, issue, { kind: "review", round });
+}
+async function staged_review(directory, issue, round, slot) {
+  const code = lane_session_broker.review_paths(directory);
+  const own = lane_session_broker.review_paths(directory, slot);
+  copy_stamp(own.brief, code.brief);
+  const answer = await code_request(directory, issue, round);
+  copy_stamp(code.findings, own.findings);
+  stamp_file.remove_stamp(code.findings);
+  return answer;
+}
+async function staged_reviews(directory, issue, round, slots) {
+  const [slot, ...rest] = slots;
+  if (slot === void 0) return [];
+  const answer = await staged_review(directory, issue, round, slot);
+  return [answer, ...await staged_reviews(directory, issue, round, rest)];
+}
+async function in_turn(directory, issue, round, slots) {
+  const code_brief = lane_session_broker.review_paths(directory).brief;
+  const kept = stamp_file.read_stamp_text(code_brief);
+  const others = slots.filter((slot) => slot !== CODE);
+  const answers = [...await staged_reviews(directory, issue, round, others)];
+  if (kept !== void 0) stamp_file.write_text_stamp(code_brief, kept);
+  if (slots.includes(CODE)) answers.push(await code_request(directory, issue, round));
+  return answers.find((answer) => !answer.is_success) ?? lane_session_action.SUCCESS;
+}
+async function request(directory, issue, round, slots) {
+  if (slots.length === 1 && slots[0] === CODE) return await code_request(directory, issue, round);
+  const answer = await lane_session_broker.request(directory, issue, {
+    kind: "review",
+    round,
+    slots
+  });
+  if (!lane_session_broker.is_unreadable(answer)) return answer;
+  return await in_turn(directory, issue, round, slots);
+}
+var run_ship_brokered_review = { request };
+
+// scripts/run/ship/run-ship-reviewer.ts
+var SUCCESS_EXIT_CODE6 = 0;
+var FAILURE_EXIT_CODE3 = 1;
+var should_forward_stderr = true;
+var ATTEST_CHECK = ["review:attest", "--check"];
+var KEPT_REVIEW_NOTE = "the reviewer wrote its findings before it failed \u2014 its review is kept; attest and record judge it.";
+var MISSING_FINDINGS_NOTE = "the reviewer submitted no findings; nothing is at the slot path:";
+var ROUND_ONE = "1";
+var ROUND_TWO = "2";
+var { CAUSE: CAUSE2 } = run_ship_stop_cause;
+var { CODE: CODE2 } = review_attest.REVIEW_SLOT;
+var { PRIORITY_ENVIRONMENT } = core_priority;
+function failure(out, cause) {
+  return { code: FAILURE_EXIT_CODE3, out, cause };
+}
+function tagged(cause, result) {
+  return result.code === SUCCESS_EXIT_CODE6 ? result : { ...result, cause };
+}
+function tagged_phase(cause, phase) {
+  return async () => tagged(cause, await phase());
+}
+function paths(slot) {
+  return lane_session_broker.review_paths(PROJECT_ROOT, slot);
+}
+async function josh(argv) {
+  return await josh_command.josh_run(argv, should_forward_stderr, void 0, PRIORITY_ENVIRONMENT);
+}
+function note3(text) {
+  process.stderr.write(`${text}
+`);
+}
+function exited_note(log_path) {
+  const exited = `reviewer failed \u2014 log: ${log_path}`;
+  if (!api_auth.is_auth_failed_transcript(stamp_file.read_stamp_text(log_path))) return exited;
+  return `${api_auth.AUTH_FAILURE_NOTE}: ${exited}`;
+}
+function current_verdict(slot) {
+  return run_ship_review.read_verdict(stamp_file.read_stamp_text(paths(slot).findings));
+}
+function missing_findings(slots) {
+  const missing = slots.map((slot) => paths(slot).findings).filter((findings) => stamp_file.read_stamp_text(findings) === void 0);
+  return missing.length === 0 ? void 0 : `${MISSING_FINDINGS_NOTE} ${missing.join(", ")}`;
+}
+function finished_session(slots) {
+  const missing = missing_findings(slots);
+  return missing === void 0 ? { code: SUCCESS_EXIT_CODE6, out: "" } : failure(missing, CAUSE2.INFRA);
+}
+function ended_session(failed_note, slots = [CODE2]) {
+  if (slots.some((slot) => current_verdict(slot).kind === run_ship_review.VERDICT.INVALID)) {
+    const missing = missing_findings(slots);
+    return failure(missing === void 0 ? failed_note : `${failed_note}
+${missing}`, CAUSE2.INFRA);
+  }
+  note3(`${failed_note}
+${KEPT_REVIEW_NOTE}`);
+  return { code: SUCCESS_EXIT_CODE6, out: "" };
+}
+async function run_direct_session(argv, profile, slot, round) {
+  const log_path = paths(slot).log;
+  const request2 = { argv, cwd: PROJECT_ROOT, log_path, profile, env: PRIORITY_ENVIRONMENT };
+  note3(agent_role_profile.describe_review(Number(round), profile));
+  const result = await detached_launch.launch_attached(request2, note3);
+  if (result.kind === "failed") {
+    return failure(`reviewer could not start: ${result.note}`, CAUSE2.INFRA);
+  }
+  if (result.exit_code !== SUCCESS_EXIT_CODE6) return ended_session(exited_note(log_path), [slot]);
+  return finished_session([slot]);
+}
+function is_brokered(profile, issue) {
+  if (!lane_child_marker.is_child_of(PROJECT_ROOT)) return false;
+  return profile.provider === "openai" || lane_session_broker.is_serving(PROJECT_ROOT, issue);
+}
+function session_for(prompt_of, issue, round, slots) {
+  const { slot, all } = slots;
+  const prompt = run_ship_review.slot_prompt(prompt_of, slot, all)(paths(slot).brief, slot, issue);
+  return { slot, built: agent_argv.review_in(prompt, Number(round), PROJECT_ROOT) };
+}
+async function run_slot(session, round) {
+  const { built, slot } = session;
+  if (built.kind === "rejected") {
+    return failure(`reviewer profile rejected: ${built.note}`, CAUSE2.INFRA);
+  }
+  return await run_direct_session(built.argv, built.profile, slot, round);
+}
+async function run_brokered(issue, round, slots) {
+  const answer = await run_ship_brokered_review.request(PROJECT_ROOT, issue, round, slots);
+  return answer.is_success ? finished_session(slots) : ended_session(`isolated reviewer failed: ${answer.reason}`, slots);
+}
+async function launch_pair(slots) {
+  if (slots.includes(CODE2)) await review_pair_session.launch(PROJECT_ROOT, PRIORITY_ENVIRONMENT);
+}
+async function run_slots(sessions, round, slots) {
+  const [results] = await Promise.all([
+    Promise.all(sessions.map(async (session) => await run_slot(session, round))),
+    launch_pair(slots)
+  ]);
+  return results;
+}
+async function run_sessions(prompt_of, issue, round, slots) {
+  const sessions = slots.map((slot) => session_for(prompt_of, issue, round, { slot, all: slots }));
+  const [first] = sessions;
+  if (first?.built.kind === "argv" && is_brokered(first.built.profile, issue)) {
+    return await run_brokered(issue, round, slots);
+  }
+  const results = await run_slots(sessions, round, slots);
+  return results.find((result) => result.code !== SUCCESS_EXIT_CODE6) ?? {
+    code: SUCCESS_EXIT_CODE6,
+    out: ""
+  };
+}
+function offer_pair(code) {
+  if (code !== void 0) review_pair.offer(code.brief);
+}
+async function record_pair(issue, code) {
+  if (code === void 0) return;
+  const argv = review_pair_session.pair_argv(issue, paths(CODE2).log, PROJECT_ROOT);
+  if (argv === void 0) return;
+  const result = await josh(argv);
+  if (result.code !== SUCCESS_EXIT_CODE6) note3(`paired reviewer: review:pair recorded nothing`);
+}
+async function launch_reviewers(briefs, prompt_of, issue, round) {
+  const code = briefs.find(({ slot }) => slot === CODE2);
+  const effective_round = review_round.from_brief(code?.brief ?? "", round);
+  for (const { brief, slot } of briefs) {
+    const target = paths(slot);
+    stamp_file.write_text_stamp(target.brief, brief);
+    stamp_file.remove_stamp(target.findings);
+  }
+  offer_pair(code);
+  const result = await run_sessions(
+    effective_round === ROUND_TWO ? run_ship_review.verification_prompt : prompt_of,
+    issue,
+    effective_round,
+    briefs.map(({ slot }) => slot)
+  );
+  await record_pair(issue, code);
+  return result;
+}
+async function attest_phase() {
+  return tagged(CAUSE2.ATTEST, await josh(ATTEST_CHECK));
+}
+function reviewed_together(opens, prompt_of, issue, round) {
+  const printed = /* @__PURE__ */ new Map();
+  function briefs() {
+    return opens.map(({ slot }) => ({ brief: printed.get(slot) ?? "", slot }));
+  }
+  return [
+    ...opens.map(({ open, slot }) => async () => {
+      const result = await josh(open);
+      printed.set(slot, result.out);
+      return tagged(CAUSE2.CHECK, result);
+    }),
+    async () => await launch_reviewers(briefs(), prompt_of, issue, round)
+  ];
+}
+function reviewed(open, prompt_of, issue, round) {
+  return reviewed_together([{ open, slot: CODE2 }], prompt_of, issue, round);
+}
+var run_ship_reviewer = {
+  attest_phase,
+  current_verdict,
+  failure,
+  josh,
+  note: note3,
+  paths,
+  reviewed,
+  reviewed_together,
+  ROUND_ONE,
+  ROUND_TWO,
+  SUCCESS_EXIT_CODE: SUCCESS_EXIT_CODE6,
+  tagged,
+  tagged_phase
+};
+
+// scripts/run/ship/run-ship-review-steps.ts
+var RUN_REVIEW = "run:review";
+function round_two_decision(issue) {
+  return ["review:round2", "--record", issue, "--json"];
+}
+var REVIEW_BRIEF = "review:brief";
+var ROUND_TWO_BRIEF = [REVIEW_BRIEF, "--round", "2"];
+var INTERACTION_FLAG = "--interaction";
+var INTERACTION_BRIEF = [REVIEW_BRIEF, INTERACTION_FLAG];
+var UNREADABLE_DECISION_NOTE = "review:round2 printed no decision josh ship can read:";
+var COMMENT_FLAG = "--comment";
+var FIXED_JOIN_NOTE = "the round-1 gate read the tree before the review fixes \u2014 drained, not judged; the gate re-runs once the tree is fixed.";
+var ROUND_TWO_SKIPPED_NOTE = "round 2 not due \u2014 nothing left to verify; shipping on.";
+var ROUND_ONE_RECORDED_NOTE = "round 1 already recorded \u2014 reused, not reviewed again; round 2 decides on the fix delta before the commit.";
+var { run_phases, scoped_pair } = run_ship_scoped;
+var { CAUSE: CAUSE3 } = run_ship_stop_cause;
+var { CODE: CODE3, INTERACTION } = review_attest.REVIEW_SLOT;
+var ROUND_ONE_OPENS = {
+  code: [RUN_REVIEW, run_review.CODE_ONLY_FLAG],
+  interaction: INTERACTION_BRIEF
+};
+var SLOT_RECORD_FLAGS = {
+  code: [],
+  interaction: [INTERACTION_FLAG]
+};
+var {
+  attest_phase: attest_phase2,
+  current_verdict: current_verdict2,
+  failure: failure2,
+  josh: josh2,
+  note: note4,
+  paths: paths2,
+  reviewed: reviewed2,
+  reviewed_together: reviewed_together2,
+  ROUND_ONE: ROUND_ONE2,
+  ROUND_TWO: ROUND_TWO2,
+  SUCCESS_EXIT_CODE: SUCCESS_EXIT_CODE7,
+  tagged: tagged2,
+  tagged_phase: tagged_phase2
+} = run_ship_reviewer;
+function has_fixes(slots) {
+  return slots.some(
+    (slot) => run_ship_review.has_fixes(stamp_file.read_stamp_text(paths2(slot).findings))
+  );
+}
+function is_drained(code, slots) {
+  if (code === run_review.UNPINNED_EXIT_CODE) return false;
+  return code === run_review.MOVED_EXIT_CODE || has_fixes(slots);
+}
+async function join_gate(slots) {
+  const joined = await josh2([RUN_REVIEW, "--join"]);
+  if (joined.code === SUCCESS_EXIT_CODE7 || !is_drained(joined.code, slots)) return joined;
+  note4(FIXED_JOIN_NOTE);
+  return { code: SUCCESS_EXIT_CODE7, out: joined.out };
+}
+function record_flags(round, outcome) {
+  return round === ROUND_TWO2 && outcome.is_passing ? [COMMENT_FLAG] : [];
+}
+async function record_and_route(issue, round, outcome_of, slot = CODE3) {
+  const verdict = current_verdict2(slot);
+  if (verdict.kind === run_ship_review.VERDICT.INVALID) return failure2(verdict.note, CAUSE3.INFRA);
+  const outcome = outcome_of(verdict);
+  const flags = [...SLOT_RECORD_FLAGS[slot], ...record_flags(round, outcome)];
+  const specs = run_ship_review.recorded_specs(verdict, outcome);
+  const recorded2 = await josh2(["review:record", "--issue", issue, ...flags, ...specs]);
+  if (recorded2.code !== SUCCESS_EXIT_CODE7) return tagged2(CAUSE3.CHECK, recorded2);
+  review_stop_log.record({
+    issue: Number(issue),
+    stage: run_ship_stage.STAGE.REVIEW,
+    findings: run_ship_review.passing_fixes(verdict, outcome),
+    is_fixed: true
+  });
+  const out = [...verdict.report, outcome.note].join("\n");
+  return outcome.is_passing ? { code: SUCCESS_EXIT_CODE7, out } : failure2(out, CAUSE3.FINDING);
+}
+async function is_fix_verified(slots) {
+  const is_fixed = slots.some(
+    (slot) => current_verdict2(slot).kind === run_ship_review.VERDICT.FIXED
+  );
+  if (!is_fixed) return true;
+  const checked = await scoped_pair();
+  return checked.code === SUCCESS_EXIT_CODE7;
+}
+function outcome_for_round(round, verdict) {
+  return round === ROUND_TWO2 ? run_ship_review.round_two_outcome(verdict) : run_ship_review.round_one_outcome(verdict);
+}
+async function round_one_record(issue, slot, is_verified) {
+  const round = slot === CODE3 ? review_round.from_brief(stamp_file.read_stamp_text(paths2(slot).brief) ?? "") : ROUND_ONE2;
+  return await record_and_route(
+    issue,
+    round,
+    (verdict) => is_verified ? outcome_for_round(round, verdict) : run_ship_review.UNVERIFIED_OUTCOME,
+    slot
+  );
+}
+function merged(results) {
+  const out = results.map((result) => result.out).join("\n");
+  const stopped3 = results.find((result) => result.code !== SUCCESS_EXIT_CODE7);
+  return stopped3 === void 0 ? { code: SUCCESS_EXIT_CODE7, out } : { ...stopped3, out };
+}
+async function record_slots(issue, slots) {
+  const is_verified = await is_fix_verified(slots);
+  const results = [];
+  for (const slot of slots) {
+    const result = await round_one_record(issue, slot, is_verified);
+    results.push(result);
+  }
+  return merged(results);
+}
+function skipped2(out) {
+  return { code: SUCCESS_EXIT_CODE7, out, is_skipped: true };
+}
+async function record_outcome(issue, verdict, cause) {
+  if (verdict === run_ship_review.VERDICT.INVALID || cause === CAUSE3.CHECK || review_round.from_brief(stamp_file.read_stamp_text(paths2(CODE3).brief) ?? "") === ROUND_TWO2) {
+    return;
+  }
+  await lane_ledger_write.record_round_one({ issue: Number(issue), verdict });
+}
+function round_one_kind(slots) {
+  const kinds = new Set(slots.map((slot) => current_verdict2(slot).kind));
+  const { FIXED, INVALID } = run_ship_review.VERDICT;
+  if (kinds.has(INVALID)) return INVALID;
+  return kinds.has(FIXED) ? FIXED : current_verdict2().kind;
+}
+async function code_round_one_record(issue, slots) {
+  const kind = round_one_kind(slots);
+  const recorded2 = await record_slots(issue, slots);
+  const is_stopped = recorded2.cause === CAUSE3.FINDING;
+  review_reviewed_tree.mark_stopped(Number(issue), is_stopped);
+  await record_outcome(issue, is_stopped ? run_ship_review.VERDICT.BLOCKING : kind, recorded2.cause);
+  return recorded2;
+}
+function round_one_opens(slots, unpinned_ok) {
+  return slots.map((slot) => ({
+    open: slot === CODE3 ? [...ROUND_ONE_OPENS[slot], ...unpinned_ok] : ROUND_ONE_OPENS[slot],
+    slot
+  }));
+}
+async function reused_round(issue, reused2) {
+  await record_outcome(issue, lane_ledger_write.ROUND_ONE_REUSED);
+  return { ...skipped2(ROUND_ONE_RECORDED_NOTE), reason: run_ship_review_reason.reused(reused2) };
+}
+async function round_one_stage(issue, is_stale, slots, unpinned_ok) {
+  const reused2 = await review_round_reuse.answer(Number(issue), is_stale);
+  if (reused2.reuse !== review_round_reuse.REUSE.AGAIN) return await reused_round(issue, reused2);
+  if (is_stale) review_reviewed_tree.discard();
+  const opens = round_one_opens(slots, unpinned_ok);
+  const provider = reviewed_together2(opens, run_ship_review.reviewer_prompt, issue, ROUND_ONE2);
+  const ran2 = await run_ship_review_checkpoint.run(
+    issue,
+    `one-${slots.join("-")}`,
+    [
+      ["scoped", tagged_phase2(CAUSE3.CHECK, scoped_pair)],
+      ["provider", async () => await run_phases(provider)],
+      ["gate", tagged_phase2(CAUSE3.CHECK, async () => await join_gate(slots))],
+      ["attest", attest_phase2],
+      ["record", async () => await code_round_one_record(issue, slots)]
+    ],
+    is_stale
+  );
+  return { ...ran2, reason: run_ship_review_reason.ran(reused2) };
+}
+async function interaction_stage(issue) {
+  const opens = [{ open: INTERACTION_BRIEF, slot: INTERACTION }];
+  const provider = reviewed_together2(opens, run_ship_review.reviewer_prompt, issue, ROUND_ONE2);
+  return await run_ship_review_checkpoint.run(
+    issue,
+    "interaction",
+    [
+      ["scoped", tagged_phase2(CAUSE3.CHECK, scoped_pair)],
+      ["provider", async () => await run_phases(provider)],
+      ["attest", attest_phase2],
+      ["record", async () => await record_slots(issue, [INTERACTION])]
+    ],
+    await review_round_reuse.is_stale_here()
+  );
+}
+async function due_slots(issue) {
+  return review_interaction.round_one_slots(await review_interaction.status(Number(issue)));
+}
+async function is_interaction_due(issue) {
+  const slots = await due_slots(issue);
+  return slots.includes(INTERACTION);
+}
+async function is_interaction_owed(issue, first) {
+  if (first.code !== SUCCESS_EXIT_CODE7) return false;
+  return await is_interaction_due(issue);
+}
+function after_interaction(first, second) {
+  const out = [first.out, second.out].join("\n");
+  const { reason } = first;
+  return { code: SUCCESS_EXIT_CODE7, out, ...reason !== void 0 && { reason } };
+}
+async function review_stage(issue, is_stale = false, unpinned_ok = []) {
+  const slots = await due_slots(issue);
+  const first = await round_one_stage(issue, is_stale, slots, unpinned_ok);
+  if (!await is_interaction_owed(issue, first)) return first;
+  const second = await interaction_stage(issue);
+  if (second.code !== SUCCESS_EXIT_CODE7) return second;
+  return after_interaction(first, second);
+}
+async function reviewed_round_two(issue) {
+  const provider = reviewed2(ROUND_TWO_BRIEF, run_ship_review.verification_prompt, issue, ROUND_TWO2);
+  return await run_ship_review_checkpoint.run(
+    issue,
+    "two",
+    [
+      ["scoped", tagged_phase2(CAUSE3.CHECK, scoped_pair)],
+      ["provider", async () => await run_phases(provider)],
+      ["attest", attest_phase2],
+      [
+        "record",
+        async () => await record_and_route(issue, ROUND_TWO2, run_ship_review.round_two_outcome)
+      ]
+    ],
+    await review_round_reuse.is_stale_here()
+  );
+}
+async function execute_round_two_stage(issue) {
+  const decision = await josh2(round_two_decision(issue));
+  if (decision.code !== SUCCESS_EXIT_CODE7) return tagged2(CAUSE3.CHECK, decision);
+  const answer = review_round2.parse_json(decision.out);
+  if (answer === void 0) {
+    return failure2(`${UNREADABLE_DECISION_NOTE}
+${decision.out}`, CAUSE3.CHECK);
+  }
+  note4(answer.reason);
+  await lane_ledger_write.record_round_two({
+    issue: Number(issue),
+    verdict: answer.verdict,
+    code: answer.code
+  });
+  if (answer.verdict !== review_round2.REQUIRED_VERDICT) {
+    return skipped2(`${answer.verdict}
+${ROUND_TWO_SKIPPED_NOTE}`);
+  }
+  return await reviewed_round_two(issue);
+}
+async function round_two_stage(issue) {
+  return await run_ship_final_review.run(issue, async () => await execute_round_two_stage(issue));
+}
+var run_ship_review_steps = { review_stage, round_two_stage };
+
+// scripts/gh/git-gh-code-scanning.ts
+import { z } from "zod";
+var ALERT_NOTE = "code scanning alerts in the pull request\u2019s own files (a merge does not clear them):";
+var location_schema = z.looseObject({ path: z.string(), start_line: z.number() });
+var alert_schema = z.looseObject({
+  rule: z.looseObject({ id: z.string() }),
+  most_recent_instance: z.looseObject({ location: location_schema })
+});
+var file_schema = z.looseObject({ filename: z.string() });
+async function read_listing(path2, schema) {
+  const raw_json = await git_gh_exec.exec_gh_api({ path: path2, should_paginate: true });
+  return json_value.parse_with(raw_json, schema.array());
+}
+async function read_alerts(pr_number) {
+  const query = `${FULL_PAGE_QUERY}&state=open&ref=refs/pull/${String(pr_number)}/merge`;
+  const path2 = `${git_gh_api_path.code_scanning_alerts_api_path()}${query}`;
+  const alerts = await read_listing(path2, alert_schema);
+  return alerts?.map(({ rule, most_recent_instance: { location } }) => ({
+    rule: rule.id,
+    path: location.path,
+    line: location.start_line
+  }));
+}
+async function read_files(pr_number) {
+  const path2 = `${git_gh_api_path.pull_files_api_path(String(pr_number))}${FULL_PAGE_QUERY}`;
+  const files = await read_listing(path2, file_schema);
+  return files === void 0 ? void 0 : new Set(files.map((file) => file.filename));
+}
+async function read_own_alerts(pr_number) {
+  const [alerts, files] = await Promise.all([read_alerts(pr_number), read_files(pr_number)]);
+  if (alerts === void 0 || files === void 0) return void 0;
+  return alerts.filter((alert) => files.has(alert.path));
+}
+async function own_alerts_note(pr_number) {
+  try {
+    const alerts = await read_own_alerts(pr_number);
+    if (alerts === void 0 || alerts.length === 0) return void 0;
+    return [
+      ALERT_NOTE,
+      ...alerts.map((alert) => `  ${alert.rule} \u2014 ${alert.path}:${String(alert.line)}`)
+    ].join("\n");
+  } catch {
+    return void 0;
+  }
+}
+var git_gh_code_scanning = { ALERT_NOTE, own_alerts_note };
+
+// scripts/run/ship/run-ship-overlap.ts
+var WAIT_INTERVAL_MS = 3e4;
+var MAX_WAIT_ATTEMPTS = 60;
+var NAME_ONLY_ARGUMENTS = [
+  "-c",
+  "core.quotePath=false",
+  "diff",
+  "--name-only",
+  "--no-relative",
+  "--no-renames"
+];
+var REGENERATED_PATHS = new Set(
+  main_merge_regenerate.RESOLVED_FILES.filter((entry) => "command" in entry).map(
+    (entry) => entry.path
+  )
+);
+function to_paths(raw) {
+  return changed_paths.to_paths(raw);
+}
+async function has_upstream(directory) {
+  try {
+    await git_spawn.read(["-C", directory, "rev-parse", "--verify", "--quiet", "@{upstream}"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function lane_paths(directory) {
+  const base = await git_diff_reads.default_branch_reference();
+  try {
+    return to_paths(
+      await git_spawn.read(["-C", directory, ...NAME_ONLY_ARGUMENTS, `${base}...HEAD`, "--"])
+    );
+  } catch {
+    return [];
+  }
+}
+function own_launch(issue) {
+  const since = lane_handoff.ship_running_since(issue, process.cwd());
+  return { issue, since: since ?? Infinity };
+}
+function is_launched_before(lane, own) {
+  const since = lane_handoff.ship_running_since(lane.issue, lane.directory);
+  if (since === void 0) return false;
+  return since < own.since || since === own.since && Number(lane.issue) < Number(own.issue);
+}
+async function is_open_ship(lane, own) {
+  if (!is_launched_before(lane, own)) return false;
+  return await has_upstream(lane.directory);
+}
+async function lane_head(directory) {
+  try {
+    return await git_spawn.read(["-C", directory, "rev-parse", "HEAD"]);
+  } catch {
+    return void 0;
+  }
+}
+async function conflicting_paths(lane, shared) {
+  const theirs = await lane_head(lane.directory);
+  const conflicted = theirs === void 0 ? void 0 : git_merge_conflicts.working_tree_conflicts(theirs, shared, process.cwd());
+  return (conflicted ?? shared).filter((file_path) => !REGENERATED_PATHS.has(file_path));
+}
+async function shared_paths(lane, launch, own) {
+  if (!await is_open_ship(lane, launch)) return [];
+  const paths3 = await lane_paths(lane.directory);
+  const shared = paths3.filter((file_path) => own.has(file_path));
+  if (shared.length === 0) return [];
+  return await conflicting_paths(lane, shared);
+}
+async function other_lanes(issue) {
+  const lanes = await lane_registry.list_lanes();
+  return lanes.filter((lane) => lane.issue !== issue && !lane.is_stranded);
+}
+async function find_overlap(issue) {
+  const own = new Set(await changed_paths.read_changed_paths(false));
+  const launch = own_launch(issue);
+  const others = await other_lanes(issue);
+  const shared = await Promise.all(
+    others.map(async (lane) => await shared_paths(lane, launch, own))
+  );
+  return {
+    lanes: others.filter((_lane, index) => (shared[index] ?? []).length > 0),
+    paths: [...new Set(shared.flat())].toSorted((left, right) => left.localeCompare(right))
+  };
+}
+async function read_overlap(issue) {
+  try {
+    return await find_overlap(issue);
+  } catch {
+    return { lanes: [], paths: [] };
+  }
+}
+function is_settled(lanes) {
+  return lanes.every((lane) => !lane_handoff.is_ship_running(lane.issue, lane.directory));
+}
+async function wait_for(lanes, options) {
+  return await poll.poll_until(async () => is_settled(lanes), {
+    attempts: MAX_WAIT_ATTEMPTS,
+    interval_ms: WAIT_INTERVAL_MS,
+    sleeper: options.sleeper ?? poll.sleep
+  });
+}
+async function await_overlap(issue, options = {}) {
+  const overlap = await read_overlap(issue);
+  if (overlap.lanes.length === 0) return void 0;
+  const started = Date.now();
+  const is_cleared = await wait_for(overlap.lanes, options);
+  const lanes = overlap.lanes.map((lane) => Number(lane.issue));
+  const waited_ms = Date.now() - started;
+  const record2 = { issue: Number(issue), lanes, paths: [...overlap.paths], waited_ms, is_cleared };
+  await lane_ledger_write.record_overlap(record2, options.ledger);
+  return record2;
+}
+function note5(record2) {
+  if (record2 === void 0) return "";
+  const lanes = record2.lanes.map((lane) => session_cite.issue(lane)).join(", ");
+  const outcome = record2.is_cleared ? "waited for" : "gave up waiting for";
+  return `${outcome} ${lanes}, whose open pull requests conflict on: ${record2.paths.join(", ")}`;
+}
+var run_ship_overlap = { MAX_WAIT_ATTEMPTS, await_overlap, note: note5 };
+
+// scripts/run/ship/run-ship-sync.ts
+var { STEP, timed } = run_ship_lap;
+var should_forward_stderr2 = true;
+var SUCCESS_EXIT_CODE8 = 0;
+var FAILURE_EXIT_CODE4 = 1;
+var MAX_MERGE_RETRIES = 2;
+var CONFLICT_NOTE2 = "merging the default branch left unmerged paths:";
+var DEFERRED_PREFIX = "merge deferred to the followup: ";
+var CURRENT_SUFFIX = " brings nothing in";
+var MERGED_PREFIX = "merged ";
+var MERGED_GATE_NOTE = "the default branch moved since the sync; the tree merged with it fails the gate:";
+var PUSHED_NOTE = "pushed the merge ahead of the gate, so CI runs beside it";
+var PUSH_FAILED_NOTE = "the push ahead of the gate failed; the commit stage pushes after the gate:";
+var PAIR_RED_NOTE = "the scoped pair is red on the merged tree; the commit stage pushes after the gate";
+var LEFT_TO_CI_NOTE = "the default branch moved since the sync without a conflict \u2014 not merged again; the pull request CI checks the merge ref";
+var MERGED_AGAIN_NOTE = "followup: the default branch moved under the failed checks \u2014 merged it again; gating and pushing the merged tree, no re-ship";
+function push_argv(title) {
+  return ["git", "-y", "--skip-commit", "--skip-pr", title];
+}
+async function josh3(argv) {
+  return await josh_command.josh_run(argv, should_forward_stderr2);
+}
+async function merge_outcome() {
+  try {
+    return await timed(STEP.MERGE, async () => await main_merge.merge());
+  } catch (error) {
+    return { kind: "refused", message: error_text.message_of(error) };
+  }
+}
+function conflict_result(files, lead) {
+  const out = [lead, CONFLICT_NOTE2, ...files].filter((line) => line !== "").join("\n");
+  return { code: FAILURE_EXIT_CODE4, out, conflicts: files };
+}
+function sync_note(outcome) {
+  if (outcome.kind === "refused") return `${DEFERRED_PREFIX}${outcome.message}`;
+  return outcome.kind === "current" ? `${outcome.branch}${CURRENT_SUFFIX}` : `${MERGED_PREFIX}${outcome.branch}`;
+}
+async function commit_locally(title, is_dirty) {
+  if (!is_dirty) return void 0;
+  const commit = await timed(
+    STEP.LOCAL_COMMIT,
+    async () => await josh_command.josh_run(
+      ["git", "-y", "--skip-push", "--skip-pr", title],
+      should_forward_stderr2,
+      void 0,
+      { [pre_commit_lint_switch.SWITCH_ENV_KEY]: "off" }
+    )
+  );
+  return commit.code === SUCCESS_EXIT_CODE8 ? void 0 : commit;
+}
+async function push_ahead(title) {
+  const pair = await run_ship_scoped.scoped_pair();
+  if (pair.code !== SUCCESS_EXIT_CODE8) return PAIR_RED_NOTE;
+  const push2 = await timed(
+    STEP.PUSH,
+    async () => await josh_command.josh_run(push_argv(title), should_forward_stderr2, void 0, {
+      [pre_push_related_switch.SWITCH_ENV_KEY]: pre_push_related_switch.SWITCH_ON
+    })
+  );
+  return push2.code === SUCCESS_EXIT_CODE8 ? PUSHED_NOTE : [PUSH_FAILED_NOTE, push2.out].join("\n");
+}
+async function open_pull_number() {
+  try {
+    return await git_gh_pr_read.pr_get_number(await git_command.branch());
+  } catch {
+    return void 0;
+  }
+}
+async function pushed_note(outcome, title) {
+  if (outcome.kind !== "merged" || await open_pull_number() === void 0) return "";
+  return await push_ahead(title);
+}
+async function waited_note(issue) {
+  const overlap = await timed(
+    STEP.OVERLAP_WAIT,
+    async () => await run_ship_overlap.await_overlap(issue)
+  );
+  return run_ship_overlap.note(overlap);
+}
+async function sync_stage(issue, title, is_dirty) {
+  const waited = await waited_note(issue);
+  const failed_commit = await commit_locally(title, is_dirty);
+  if (failed_commit !== void 0) {
+    const out2 = [waited, failed_commit.out].filter((line) => line !== "").join("\n");
+    return { ...failed_commit, out: out2 };
+  }
+  const outcome = await merge_outcome();
+  if (outcome.kind === "conflict") return conflict_result(outcome.files, waited);
+  const pushed = await pushed_note(outcome, title);
+  const out = [waited, sync_note(outcome), pushed].filter((line) => line !== "").join("\n");
+  return { code: SUCCESS_EXIT_CODE8, out };
+}
+async function gate_merged() {
+  const gate = await run_ship_scoped.scoped_gate();
+  if (gate.code === SUCCESS_EXIT_CODE8) return void 0;
+  const out = [MERGED_GATE_NOTE, gate.out].filter((line) => line !== "").join("\n");
+  return { ...gate, out, cause: run_ship_stop_cause.CAUSE.CHECK };
+}
+async function is_behind_default() {
+  try {
+    const default_branch = await git_command.get_default_branch();
+    return await git_command.commit_count_beyond("HEAD", `origin/${default_branch}`) > 0;
+  } catch {
+    return true;
+  }
+}
+async function is_merge_left_to_ci() {
+  const conflicts = await run_ship_conflict_probe.read_conflicts();
+  if (conflicts?.length !== 0) return false;
+  if (await is_behind_default()) console.error(LEFT_TO_CI_NOTE);
+  return true;
+}
+async function merge_and_gate(is_green) {
+  const outcome = await merge_outcome();
+  if (outcome.kind === "conflict") return conflict_result(outcome.files, "");
+  if (is_green && outcome.kind !== "merged") return void 0;
+  return await gate_merged();
+}
+async function catch_up() {
+  const is_green = await run_ship_scoped.is_gate_green();
+  if (is_green && await is_merge_left_to_ci()) return void 0;
+  return await merge_and_gate(is_green);
+}
+async function push_merged(title) {
+  const gate = await gate_merged();
+  if (gate !== void 0) return gate;
+  const push2 = await josh3(push_argv(title));
+  return push2.code === SUCCESS_EXIT_CODE8 ? void 0 : push2;
+}
+var MERGE_FIXABLE_REASONS = [FAILURE_REASON_CHECKS, FAILURE_REASON_CONFLICT];
+function names_merge_fixable(text) {
+  if (text?.includes(FAILURE_MESSAGE_PREFIX) !== true) return false;
+  return MERGE_FIXABLE_REASONS.some((reason) => text.includes(reason));
+}
+function is_checks_failure(failed) {
+  return [failed.out, failed.err].some((text) => names_merge_fixable(text));
+}
+var CODE_SCANNING_CHECK = "CodeQL";
+function names_code_scanning_red(text) {
+  return text?.split(`${FAILURE_REASON_CHECKS}: `)[1]?.includes(CODE_SCANNING_CHECK) === true;
+}
+async function own_alerts_stop(failed) {
+  if ([failed.out, failed.err].every((text) => !names_code_scanning_red(text))) return void 0;
+  const pr_number = await open_pull_number();
+  const note6 = pr_number === void 0 ? void 0 : await git_gh_code_scanning.own_alerts_note(pr_number);
+  if (note6 === void 0) return void 0;
+  return { ...failed, out: [failed.out, note6].join("\n"), cause: run_ship_stop_cause.CAUSE.CHECK };
+}
+async function merge_again(title, failed) {
+  if (!is_checks_failure(failed)) return failed;
+  const alerts = await own_alerts_stop(failed);
+  if (alerts !== void 0) return alerts;
+  const outcome = await merge_outcome();
+  if (outcome.kind === "conflict") return conflict_result(outcome.files, failed.out);
+  if (outcome.kind !== "merged") return failed;
+  console.error(MERGED_AGAIN_NOTE);
+  return await push_merged(title);
+}
+function ignore_wait() {
+}
+async function marked_followup(title, notify, mark2) {
+  mark2(true);
+  try {
+    return await josh_command.josh_run(
+      ["followup", title, ...notify],
+      should_forward_stderr2,
+      void 0,
+      followup_ship_environment.SHIPPED_ENVIRONMENT
+    );
+  } finally {
+    mark2(false);
+  }
+}
+async function followup_attempt(title, notify, mark2, retries) {
+  const result = await marked_followup(title, notify, mark2);
+  if (result.code === SUCCESS_EXIT_CODE8 || retries >= MAX_MERGE_RETRIES) return result;
+  const stop = await merge_again(title, result);
+  return stop ?? await followup_attempt(title, notify, mark2, retries + 1);
+}
+async function followup_stage(title, notify, mark2 = ignore_wait) {
+  return await followup_attempt(title, notify, mark2, 0);
+}
+var run_ship_sync = {
+  CONFLICT_NOTE: CONFLICT_NOTE2,
+  LEFT_TO_CI_NOTE,
+  MAX_MERGE_RETRIES,
+  MERGED_AGAIN_NOTE,
+  MERGED_GATE_NOTE,
+  PAIR_RED_NOTE,
+  PUSHED_NOTE,
+  PUSH_FAILED_NOTE,
+  catch_up,
+  followup_stage,
+  sync_stage
+};
+
+// scripts/run/ship/run-ship-steps.ts
+var should_forward_stderr3 = true;
+var SUCCESS_EXIT_CODE9 = 0;
+var { STAGE: STAGE2 } = run_ship_stage;
+async function josh4(argv) {
+  return await josh_command.josh_run(argv, should_forward_stderr3);
+}
+var PREFLIGHT_STEP = {
+  stage: STAGE2.PREFLIGHT,
+  header: run_ship.PREFLIGHT_HEADER,
+  run: async (args) => await run_ship_preflight.stage({ title: args.title, body_path: args.body_path })
+};
+async function gate_stage(args) {
+  const is_skipped = await run_ship_scoped.is_gate_green();
+  const result = await run_ship_scoped.scoped_gate();
+  if (args.is_review && result.code === SUCCESS_EXIT_CODE9) await run_ship_early_push.push(args);
+  return { ...result, is_skipped };
+}
+var SYNC_STEP = {
+  stage: STAGE2.SYNC,
+  header: run_ship.SYNC_HEADER,
+  run: async (args, state) => await run_ship_sync.sync_stage(args.number, args.title, state.is_dirty === true)
+};
+async function commit_stage(args, state) {
+  const stop = run_ship_stage.is_shipped(state) ? void 0 : await run_ship_sync.catch_up();
+  if (stop !== void 0) return stop;
+  const argv = ["git", "-y", ...run_ship_stage.commit_flags(state), ...args.body, args.title];
+  const { STEP: STEP2 } = run_ship_lap;
+  const environment = {
+    ...core_priority.PRIORITY_ENVIRONMENT,
+    ...run_ship_lap.environment(STEP2.COMMIT)
+  };
+  return await run_ship_lap.timed(
+    STEP2.COMMIT,
+    async () => await josh_command.josh_run(argv, should_forward_stderr3, void 0, environment)
+  );
+}
+var COMMIT_STEPS = [
+  {
+    stage: STAGE2.GATE,
+    header: run_ship.GATE_HEADER,
+    run: async (args) => await gate_stage(args)
+  },
+  {
+    stage: STAGE2.COMMIT,
+    header: run_ship.COMMIT_HEADER,
+    run: async (args, state) => await commit_stage(args, state)
+  }
+];
+function wait_mark(target) {
+  return function mark2(is_merge_waiting) {
+    if (target === void 0) return;
+    try {
+      run_ship_stage.mark_merge_waiting(target, is_merge_waiting);
+    } catch {
+    }
+  };
+}
+function freeing_mark(mark2) {
+  if (!lane_child_marker.is_child_of(process.cwd())) return mark2;
+  return function mark_freeing(is_merge_waiting) {
+    mark2(is_merge_waiting);
+    if (is_merge_waiting) void lane_hand_back_held.record();
+  };
+}
+async function remove_run_records(issue_number) {
+  await run_ship_body_draft.remove(issue_number);
+  await run_investigation_record.remove(issue_number);
+}
+async function followup_stage2(args) {
+  const mark2 = freeing_mark(wait_mark(await run_ship_probe.record_target(args.number)));
+  const result = await run_ship_sync.followup_stage(args.title, args.notify, mark2);
+  if (result.code === SUCCESS_EXIT_CODE9) await remove_run_records(args.number);
+  return result;
+}
+var MERGE_STEPS = [
+  {
+    stage: STAGE2.FOLLOWUP,
+    header: run_ship.FOLLOWUP_HEADER,
+    run: async (args) => await followup_stage2(args)
+  },
+  {
+    stage: STAGE2.REPORT,
+    header: run_ship.REPORT_HEADER,
+    run: async (args) => await josh4(["run:tail", args.number, ...args.cites])
+  }
+];
+var REVIEW_STEP = {
+  stage: STAGE2.REVIEW,
+  header: run_ship.REVIEW_HEADER,
+  run: async (args, state) => await run_ship_review_steps.review_stage(
+    args.number,
+    state.is_review_stale === true,
+    args.unpinned_ok
+  )
+};
+var ROUND_TWO_STEP = {
+  stage: STAGE2.ROUND_TWO,
+  header: run_ship.ROUND_TWO_HEADER,
+  run: async (args) => await run_ship_review_steps.round_two_stage(args.number)
+};
+function steps(args) {
+  if (!args.is_review) return [PREFLIGHT_STEP, SYNC_STEP, ...COMMIT_STEPS, ...MERGE_STEPS];
+  const reviewed_commit = COMMIT_STEPS.map(
+    (step) => step.stage === STAGE2.GATE ? { ...step, beside: ROUND_TWO_STEP } : step
+  );
+  return [PREFLIGHT_STEP, SYNC_STEP, REVIEW_STEP, ...reviewed_commit, ...MERGE_STEPS];
+}
+var run_ship_steps = { PREFLIGHT_STEP, steps };
+
+// scripts/run/ship/run-ship-supervised.ts
+var SUCCESS_EXIT_CODE10 = 0;
+async function supervised_repository() {
+  return run_ship_detach.is_supervised() ? await run_ship_probe.repository_directory() : void 0;
+}
+async function claim_identity(args) {
+  const repository = await supervised_repository();
+  if (repository !== void 0) await run_ship_detach.claim_identity(repository, args.number);
+}
+async function record_result(args, sections) {
+  const repository = await supervised_repository();
+  if (repository === void 0) return;
+  await run_ship_detach.mark_result(repository, args.number, run_ship.exit_code(sections));
+}
+function print_section() {
+  return run_ship_detach.is_supervised() ? SUCCESS_EXIT_CODE10 : run_step_section.print_once("ship");
+}
+var run_ship_supervised = { claim_identity, print_section, record_result };
+
+// scripts/run/ship/run-ship-cli.ts
+var __josh_meta2 = import.meta;
+var __josh_source_url2 = new URL("../../scripts/run/ship/run-ship-cli.ts", __josh_meta2.url).href;
+var __josh_source_filename2 = __josh_file_path2(__josh_source_url2);
+var __josh_source_dirname2 = __josh_dirname2(__josh_source_filename2);
+var ARGV_OFFSET = 2;
+var SUCCESS_EXIT_CODE11 = 0;
+var FAILURE_EXIT_CODE5 = 1;
+var USAGE = 'Usage: josh ship "<title> #<N>" [<follow-up-N> ...] [--cite <N> ...] [--review [--unpinned-ok "<reason>"]] [--detach] [--body-file <path>] [--notify-message <text> | --notify-message-file <path>] | josh ship --log <N>';
+var NO_LOG_NOTE = "no detached ship supervisor log for this issue";
+var LANE_CHILD_DETACH_NOTE = "lane child: shipping through the detached supervisor (--detach implied), so the end of this turn cannot kill it";
+var { PHASE: PHASE3, STAGE: STAGE3 } = run_ship_stage;
+var REREAD_AFTER = /* @__PURE__ */ new Set([STAGE3.SYNC, STAGE3.REVIEW]);
+async function record_timed(step, issue, elapsed_ms) {
+  await lane_ledger_write.record_stage({ stage: step.stage, elapsed_ms, issue: Number(issue) });
+}
+async function run_once(step, args, state) {
+  const started_ms = performance.now();
+  const result = await run_ship_lap.within(
+    args.number,
+    step.stage,
+    async () => await step.run(args, state)
+  );
+  const elapsed_ms = performance.now() - started_ms;
+  if (result.is_skipped !== true) await record_timed(step, args.number, elapsed_ms);
+  return run_ship.section_of(step.header, result);
+}
+async function run_step(step, args, state) {
+  const first = [state];
+  return await run_ship_infra_retry.retried(step.stage, async () => {
+    const current = first.pop() ?? await run_ship_probe.read_state();
+    return await run_once(step, args, current);
+  });
+}
+async function emit_phase2(args, context, mark2) {
+  const text = run_ship_stage.event_text(args.number, mark2.stage, mark2.phase, context.started);
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.SHIP_STAGE,
+    run_ship_stage.with_reason(text, mark2.reason)
+  );
+}
+function record(target, write) {
+  if (target === void 0) return;
+  try {
+    write(target);
+  } catch {
+  }
+}
+async function settle(step, args, context, section) {
+  const phase = run_ship_group.settled_phase(section);
+  await emit_phase2(args, context, { stage: step.stage, phase, reason: section.reason });
+  if (phase === PHASE3.FAILED) return;
+  record(context.target, (path2) => {
+    run_ship_stage.mark_done(path2, step.stage);
+  });
+}
+function set_state(context, state) {
+  context.state = state;
+}
+async function run_stage(step, args, context) {
+  if (run_ship_stage.is_done(step.stage, context.done, context.state, args.body.length > 0)) {
+    await emit_phase2(args, context, { stage: step.stage, phase: PHASE3.SKIPPED });
+    return { header: step.header, body: run_ship.SKIPPED_BODY, code: SUCCESS_EXIT_CODE11 };
+  }
+  context.started.push(step.stage);
+  record(context.target, (path2) => {
+    run_ship_stage.mark_started(path2, step.stage);
+  });
+  await emit_phase2(args, context, { stage: step.stage, phase: PHASE3.START });
+  const section = await run_step(step, args, context.state);
+  await settle(step, args, context, section);
+  if (REREAD_AFTER.has(step.stage)) set_state(context, await run_ship_probe.read_state());
+  return section;
+}
+async function open_context(args) {
+  const [target, state, is_stale] = await Promise.all([
+    run_ship_probe.record_target(args.number),
+    run_ship_probe.read_state(),
+    run_ship_handover.watch()
+  ]);
+  const done = target === void 0 ? /* @__PURE__ */ new Set() : run_ship_stage.read_done(target);
+  const started = target === void 0 ? [] : [...run_ship_stage.read_started(target)];
+  record(target, (path2) => {
+    run_ship_stage.clear_waits(path2);
+  });
+  return { target, done, state, started, is_stale };
+}
+async function record_stop(args, stage, failed) {
+  const issue = Number(args.number);
+  await lane_ledger_write.record_stop(
+    await run_ship_reship.with_base(run_ship_stop_cause.record_of(issue, stage, failed))
+  );
+  review_stop_log.record({ issue, stage, findings: run_ship_stop_cause.details_of(stage, failed) });
+}
+async function stopped2(sections, args, step, context) {
+  const failed = sections.at(-1);
+  await record_stop(args, step.stage, failed);
+  if (run_ship_detach.is_supervised()) {
+    record(context.target, run_ship_stage.end_attempt);
+    await run_ship_return.hand_back(args, step.stage, failed);
+  }
+  return sections;
+}
+async function ship_stage(step, args, context, sections) {
+  const failed = await run_ship_group.run(
+    step,
+    async (current) => await run_stage(current, args, context),
+    sections
+  );
+  if (failed !== void 0) {
+    return { sections: await stopped2(sections, args, failed.step, context), is_handed_over: false };
+  }
+  set_state(context, await run_ship_early_push.refresh(step.stage, args.is_review, context.state));
+  if (step.stage !== STAGE3.SYNC) return void 0;
+  const handover = await run_ship_handover.hand_over(args, context.is_stale);
+  return handover === void 0 ? void 0 : { sections: [...sections, handover], is_handed_over: true };
+}
+async function ship(args) {
+  const context = await open_context(args);
+  const sections = [];
+  for (const step of run_ship_steps.steps(args)) {
+    const outcome = await ship_stage(step, args, context, sections);
+    if (outcome !== void 0) return outcome;
+  }
+  record(context.target, (path2) => {
+    run_ship_stage.clear(path2);
+  });
+  return { sections, is_handed_over: false };
+}
+async function print_log(number) {
+  const repository = await run_ship_probe.repository_directory();
+  const log = repository === void 0 ? void 0 : run_ship_detach.read_log(repository, number);
+  if (log === void 0) {
+    console.error(NO_LOG_NOTE);
+    return FAILURE_EXIT_CODE5;
+  }
+  console.info(log);
+  return SUCCESS_EXIT_CODE11;
+}
+async function detach(args) {
+  const repository = await run_ship_probe.repository_directory();
+  if (repository === void 0) {
+    console.info(run_ship_detach.FAILED);
+    return FAILURE_EXIT_CODE5;
+  }
+  const result = await run_ship_detach.detach({ ...args, repository, cwd: process.cwd() });
+  console.error(result.note);
+  console.info(result.verdict);
+  if (result.verdict !== run_ship_detach.LAUNCHED) return FAILURE_EXIT_CODE5;
+  return await run_ship_detach_wait.after_launch(args.number);
+}
+function should_detach(args) {
+  if (args.is_detach) return true;
+  return !run_ship_detach.is_supervised() && lane_child_marker.is_child_of(process.cwd());
+}
+async function pre_detach_stop(args, stage, sections) {
+  await record_stop(args, stage, sections[0]);
+  return sections;
+}
+async function pre_detach_checks(args, preflight, checks_of) {
+  const result = await checks_of(args);
+  const checks3 = { header: run_ship.PRE_DETACH_HEADER, body: result.out, code: result.code };
+  if (run_ship.exit_code([checks3, preflight]) !== SUCCESS_EXIT_CODE11) {
+    await record_stop(args, STAGE3.PREFLIGHT, run_ship.with_checks(preflight, result));
+  }
+  return [checks3, preflight];
+}
+async function pre_detach_sections(args) {
+  const preflight = await run_stage(run_ship_steps.PREFLIGHT_STEP, args, await open_context(args));
+  if (preflight.preconditions?.includes(run_ship_preflight.SCOPED_PRECONDITION)) {
+    return await pre_detach_stop(args, STAGE3.PREFLIGHT, [preflight]);
+  }
+  const conflict = await run_ship_conflict_probe.probe();
+  if (conflict !== void 0) {
+    return await pre_detach_stop(args, STAGE3.SYNC, [
+      run_ship.section_of(run_ship.SYNC_HEADER, conflict),
+      preflight
+    ]);
+  }
+  return await pre_detach_checks(args, preflight, run_ship_pre_detach_pinned.timed_checks);
+}
+async function detach_after_preflight(args) {
+  const sections = await run_ship_reship.is_due(args.number) ? await pre_detach_checks(
+    args,
+    await run_ship_reship.skipped(args.number),
+    run_ship_reship.checks
+  ) : await pre_detach_sections(args);
+  const code = run_ship.exit_code(sections);
+  if (code === SUCCESS_EXIT_CODE11) return await detach(args);
+  console.info(run_ship.format_report(sections));
+  return code;
+}
+async function run_ship_command(given) {
+  const args = await run_ship_pre_detach_pinned.with_recorded_reason(given);
+  if (should_detach(args)) {
+    if (!args.is_detach) console.error(LANE_CHILD_DETACH_NOTE);
+    return await detach_after_preflight(args);
+  }
+  await run_ship_supervised.claim_identity(args);
+  const { sections, is_handed_over } = await ship(args);
+  if (!is_handed_over) await run_ship_supervised.record_result(args, sections);
+  console.info(run_ship.format_report(sections));
+  return run_ship.exit_code(sections);
+}
+async function run_governed(args) {
+  const printed = run_ship_supervised.print_section();
+  return printed === SUCCESS_EXIT_CODE11 ? await run_ship_command(args) : printed;
+}
+async function run4(argv) {
+  const command = run_ship_args.parse(argv);
+  if (command === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE5;
+  }
+  return command.kind === "log" ? await print_log(command.number) : await run_governed(await run_ship_body_draft.with_draft(command.args));
+}
+async function main(argv) {
+  process.exitCode = await run4(argv);
+}
+var run_ship_cli = { run: run4 };
+if (process.argv[1] === fileURLToPath2(__josh_source_url2)) await main(process.argv.slice(ARGV_OFFSET));
+export {
+  run_ship_cli
+};