@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/commands/git-followup-workflow.js

@@ -0,0 +1,2012 @@
+#!/usr/bin/env tsx
+import {
+  followup_ship_environment
+} from "./chunk-LBLII7BS.js";
+import {
+  acceptance_map_check
+} from "./chunk-PZTWQYRI.js";
+import {
+  run_step_section
+} from "./chunk-RVHBWSIG.js";
+import {
+  issue_declared_size
+} from "./chunk-7V5UVKFG.js";
+import {
+  git_followup_issue_close,
+  settled_together
+} from "./chunk-72EW7AVI.js";
+import "./chunk-CADFBQJJ.js";
+import {
+  issue_body_or_comment
+} from "./chunk-PDAY76AN.js";
+import {
+  epic_close
+} from "./chunk-DP7WIGQ4.js";
+import {
+  split_measure
+} from "./chunk-KHWTJ4F7.js";
+import {
+  git_followup_pending
+} from "./chunk-73KBUQKI.js";
+import "./chunk-LOSOLCCW.js";
+import {
+  observations_flush
+} from "./chunk-QEIO2ZNQ.js";
+import {
+  git_pr_merge_checked
+} from "./chunk-HJKZDDDI.js";
+import {
+  MAX_CHECK_RERUNS,
+  followup_job_rerun
+} from "./chunk-MZHOPRI6.js";
+import "./chunk-XDQOWUVT.js";
+import "./chunk-HRT4KWP4.js";
+import "./chunk-P4D5RESF.js";
+import "./chunk-ZAJD6T6E.js";
+import "./chunk-HIPO6HUG.js";
+import {
+  observation_ledger_prepare
+} from "./chunk-RYZ3RQRH.js";
+import "./chunk-6NRTLH6I.js";
+import {
+  removed_tests_check
+} from "./chunk-4HBVHYNL.js";
+import {
+  live_evidence
+} from "./chunk-KVJDDECB.js";
+import "./chunk-SK2LJBFS.js";
+import {
+  review_record
+} from "./chunk-BCK5LW4F.js";
+import "./chunk-HZBTXKT2.js";
+import "./chunk-NMLCPYBN.js";
+import {
+  git_followup_label
+} from "./chunk-SNFLV7VV.js";
+import {
+  josh_command
+} from "./chunk-2VRITY55.js";
+import {
+  git_next_issues
+} from "./chunk-ELWNRE6E.js";
+import "./chunk-HLKAFSN4.js";
+import "./chunk-7ZECP3J6.js";
+import "./chunk-3HU3LPIF.js";
+import "./chunk-2CXAVVST.js";
+import {
+  git_closes_keyword
+} from "./chunk-J3TKZLHA.js";
+import "./chunk-IZVM2TTH.js";
+import "./chunk-2IESYBZH.js";
+import {
+  split_assess
+} from "./chunk-5PAEXYIY.js";
+import "./chunk-RQRLW4XK.js";
+import "./chunk-TPKFVVJQ.js";
+import "./chunk-BPSJSHYD.js";
+import "./chunk-VDGNXSP3.js";
+import {
+  confirmation_options,
+  telegram_notify
+} from "./chunk-WJ4NEDNI.js";
+import {
+  github_issue_url
+} from "./chunk-S4X5PJV7.js";
+import "./chunk-5HVYOIIK.js";
+import "./chunk-D4SZK7H2.js";
+import "./chunk-OJ4LGBVD.js";
+import "./chunk-3RIQ36LH.js";
+import "./chunk-2ADQ5XRD.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import "./chunk-HXCZ3KWS.js";
+import "./chunk-HOSZITJM.js";
+import {
+  issue_watch_gate
+} from "./chunk-D3SHCUBC.js";
+import {
+  issue_watch
+} from "./chunk-NFEBQED3.js";
+import {
+  DEFAULT_STABLE_READS,
+  WATCH_CONFIRMED_STABLE_READS,
+  git_gh_command,
+  git_pr_checks
+} from "./chunk-RX5JSPPH.js";
+import "./chunk-U7XU5RG3.js";
+import "./chunk-GJYMI2CM.js";
+import "./chunk-U2UH4VM4.js";
+import "./chunk-WGULS5DA.js";
+import {
+  is_retry_pending,
+  note_unreadable_stop,
+  require_pr_number
+} from "./chunk-23GH6B3D.js";
+import "./chunk-GU5ML3Y3.js";
+import {
+  gh_comment_input
+} from "./chunk-BJKEXXY6.js";
+import {
+  run_progress_clock
+} from "./chunk-RGGEQM6G.js";
+import "./chunk-3WWQFCGX.js";
+import "./chunk-LAYSCY4L.js";
+import {
+  followup_checks_event,
+  followup_ci_path,
+  followup_coderabbit_wait,
+  git_followup_stages
+} from "./chunk-E2ZCUKHT.js";
+import {
+  CHECK_STATUS_FAIL,
+  CHECK_STATUS_PASS,
+  CODERABBIT_CHECK_NAME,
+  FAILURE_MESSAGE_PREFIX,
+  MissingContextError,
+  PrConflictError,
+  is_coderabbit_check,
+  is_required_check,
+  is_required_match,
+  matches_any,
+  parse_pr_state_snapshot
+} from "./chunk-WVR4RUFP.js";
+import "./chunk-HH2KDLTP.js";
+import "./chunk-HE5S4XRE.js";
+import {
+  review_interaction
+} from "./chunk-V5OIPYA6.js";
+import "./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 {
+  review_attest
+} from "./chunk-KIILCKQR.js";
+import "./chunk-WG6GYBRJ.js";
+import "./chunk-CRNPPKP2.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-KB3OQWDT.js";
+import "./chunk-FGL6DBZU.js";
+import {
+  review_stamps
+} from "./chunk-L6LU2633.js";
+import "./chunk-CGLLAEKZ.js";
+import "./chunk-WL5JHB3I.js";
+import {
+  observation_ledger
+} from "./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-MGF64OHV.js";
+import "./chunk-RK4HE5NW.js";
+import "./chunk-O26Y2FOJ.js";
+import "./chunk-XH6BGVVP.js";
+import "./chunk-RXAZJMSZ.js";
+import "./chunk-3PEXBHRN.js";
+import {
+  managed_config_scope
+} from "./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 "./chunk-XYAK53TK.js";
+import "./chunk-Y2RNUX4W.js";
+import "./chunk-FCINBCKB.js";
+import {
+  git_branch
+} from "./chunk-Q5Q2QYVU.js";
+import "./chunk-GO3GH7FG.js";
+import {
+  git_error
+} from "./chunk-KVHNQHX3.js";
+import "./chunk-7HCPRVMB.js";
+import "./chunk-RSSJWMQS.js";
+import "./chunk-FNQW6NY7.js";
+import "./chunk-337QQM4C.js";
+import "./chunk-BEE7OAQ5.js";
+import "./chunk-DBKTFB5V.js";
+import "./chunk-UCQJDYE3.js";
+import "./chunk-TCBUX52E.js";
+import "./chunk-KXHXMERX.js";
+import "./chunk-MDLOETXL.js";
+import "./chunk-65E4OZJ7.js";
+import {
+  josh_environment_file
+} from "./chunk-NFKULY26.js";
+import {
+  lane_registry
+} from "./chunk-LRS2OS5J.js";
+import "./chunk-AI5K4QJO.js";
+import "./chunk-7S6VRZOH.js";
+import "./chunk-LULJUD6P.js";
+import "./chunk-TBNQIFWL.js";
+import {
+  run_hold
+} from "./chunk-P4CWLRT2.js";
+import "./chunk-XFPEUYDV.js";
+import "./chunk-5ZTQX7OS.js";
+import "./chunk-HCA5QG2U.js";
+import "./chunk-C2SEDMZ3.js";
+import "./chunk-LRA3PXHS.js";
+import "./chunk-6OP63TBT.js";
+import "./chunk-TVZXG4Y4.js";
+import "./chunk-FIUCHMCF.js";
+import "./chunk-XXNEY4B3.js";
+import {
+  git_gh_helpers
+} from "./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 "./chunk-34LAULSC.js";
+import "./chunk-5Y7QQYTU.js";
+import {
+  ai_review_pull_comment_schema,
+  pull_comment_schema
+} from "./chunk-34DND4BA.js";
+import "./chunk-NSAVEXVR.js";
+import "./chunk-P4KIQRSL.js";
+import {
+  NEEDS_HUMAN_MERGE_LABEL,
+  REPOSITORY_LABELS
+} from "./chunk-QQBMVC5W.js";
+import "./chunk-TUIFS5E7.js";
+import "./chunk-QAHFPCFR.js";
+import "./chunk-66TGK5XL.js";
+import "./chunk-EZSO25UZ.js";
+import "./chunk-2DJLAUYB.js";
+import "./chunk-EW4NPUMQ.js";
+import "./chunk-BF6YX4HE.js";
+import "./chunk-3LZXX5GL.js";
+import "./chunk-W2IA2LV3.js";
+import "./chunk-OHNP3QL2.js";
+import "./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 {
+  issue_number_shape
+} from "./chunk-66NX6EXR.js";
+import "./chunk-3NWAGIA6.js";
+import "./chunk-2FE3C4PH.js";
+import "./chunk-HLUS2M3D.js";
+import {
+  PR_POLL_SCHEDULES,
+  poll
+} from "./chunk-SBGTCT2C.js";
+import "./chunk-AKK56GNX.js";
+import "./chunk-TBIX5FRN.js";
+import "./chunk-IGD6QJPH.js";
+import "./chunk-FFHEGWPK.js";
+import "./chunk-R6QE5VJG.js";
+import "./chunk-4ZHWTTQW.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec,
+  parse_json_array_or_undefined
+} from "./chunk-XDF25GSU.js";
+import "./chunk-EBVS2LKX.js";
+import "./chunk-AQ3PMSXK.js";
+import "./chunk-QVOFWFWC.js";
+import "./chunk-G6BXCWPH.js";
+import "./chunk-CDY4NFQG.js";
+import "./chunk-OKYFQJW3.js";
+import "./chunk-HHBC6QZE.js";
+import "./chunk-QWWTC3XR.js";
+import "./chunk-ILGPZ47M.js";
+import "./chunk-3CCGKX7Y.js";
+import "./chunk-KSR23NYN.js";
+import "./chunk-D5TAR6TV.js";
+import "./chunk-G47ZNQVG.js";
+import {
+  changed_paths
+} from "./chunk-V5FD7DVV.js";
+import "./chunk-36LOGVJ7.js";
+import "./chunk-ENFPR7J2.js";
+import "./chunk-F7XLEK55.js";
+import "./chunk-UGCUSRZF.js";
+import {
+  git_command
+} from "./chunk-AKQYYHP2.js";
+import {
+  git_spawn
+} from "./chunk-CJKPF5DJ.js";
+import "./chunk-RBU2NKHF.js";
+import "./chunk-NKKH3PBE.js";
+import "./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/followup/git-followup-workflow.ts
+import { parseArgs } from "node:util";
+
+// scripts/lane/lane-size-record.ts
+async function measure_and_record(issue) {
+  const declared = await issue_declared_size.read(issue);
+  if (declared === void 0) return;
+  const measurement = await split_measure.read_branch();
+  await lane_ledger_write.record_size({
+    issue: Number(issue),
+    declared,
+    actual: { files: measurement.files, lines: measurement.lines },
+    missed: split_assess.notice(measurement, declared) !== void 0
+  });
+}
+async function record(should_merge, issue) {
+  if (!should_merge || issue === void 0) return;
+  try {
+    await measure_and_record(issue);
+  } catch {
+  }
+}
+var lane_size_record = { record };
+
+// scripts/notify/git-notify.ts
+var DEFAULT_NOTIFY_MESSAGE = "Implementation is complete. Please review.";
+function parse_notify_target(raw_target) {
+  if (raw_target === void 0) return void 0;
+  if (raw_target === "pr") return "pr";
+  if (raw_target === "issue") return "issue";
+  if (raw_target === "both") return "both";
+  throw new Error(`Invalid notify target: ${raw_target}. Use pr, issue, or both.`);
+}
+function split_and_trim(value) {
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function normalize_mention(mention) {
+  return mention.startsWith("@") ? mention : `@${mention}`;
+}
+function parse_notify_mentions(raw_mentions) {
+  if (raw_mentions === void 0) return [];
+  return split_and_trim(raw_mentions).map((mention) => normalize_mention(mention));
+}
+function resolve_notify_message(raw_message) {
+  if (raw_message === void 0 || raw_message.trim().length === 0) return DEFAULT_NOTIFY_MESSAGE;
+  return raw_message;
+}
+function build_notify_config(input) {
+  const parsed_target = parse_notify_target(input.raw_target);
+  if (parsed_target === void 0) return void 0;
+  return {
+    target: parsed_target,
+    message: resolve_notify_message(input.raw_message),
+    mentions: parse_notify_mentions(input.raw_mentions)
+  };
+}
+function note_section(notes) {
+  if (notes === void 0 || notes.length === 0) return [];
+  return ["", ...notes];
+}
+function build_completion_comment_body(input) {
+  const base_lines = [`\u2705 ${input.message}`];
+  const issue_lines = input.issue_number === void 0 ? [] : [`Issue: ${issue_cite.plain_for("telegram", input.issue_number)}`];
+  const pr_lines = input.pr_url === void 0 ? [] : [`PR: ${input.pr_url}`];
+  const note_lines = note_section(input.notes);
+  const mention_lines = input.mentions.length === 0 ? [] : ["", input.mentions.join(" ")];
+  return [...base_lines, ...issue_lines, ...pr_lines, ...note_lines, ...mention_lines].join("\n");
+}
+var git_notify = {
+  build_notify_config,
+  build_completion_comment_body
+};
+
+// scripts/followup/followup-human-merge.ts
+import { z } from "zod";
+var WORKFLOW_PREFIX = ".github/workflows/";
+var FILE_LIMIT = 300;
+var HEAD_CHANGED = "The pull request head changed; rerun followup";
+var FILES_SCHEMA = z.array(
+  z.object({ filename: z.string(), previous_filename: z.string().optional() })
+);
+var PULL_SCHEMA = z.object({
+  base: z.object({ sha: z.string().min(1) }),
+  head: z.object({ sha: z.string().min(1) })
+});
+var COMPARISON_SCHEMA = z.object({ files: FILES_SCHEMA });
+var HumanMergeRequiredError = class extends Error {
+  name = "HumanMergeRequiredError";
+};
+function touches_workflow(files) {
+  return files.some(
+    (file) => file.filename.startsWith(WORKFLOW_PREFIX) || file.previous_filename?.startsWith(WORKFLOW_PREFIX) === true
+  );
+}
+async function comparison_path(branch, expected_head) {
+  const number = await require_pr_number(branch);
+  const pull_raw = await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_api_path(String(number))
+  });
+  const pull = json_value.parse_with(pull_raw, PULL_SCHEMA);
+  if (pull === void 0) throw new Error("Cannot read the pull request comparison commits");
+  if (expected_head !== void 0 && pull.head.sha !== expected_head) {
+    throw new Error(HEAD_CHANGED);
+  }
+  return `${git_gh_api_path.repo_api_path()}/compare/${encodeURIComponent(pull.base.sha)}...${encodeURIComponent(pull.head.sha)}?per_page=1`;
+}
+async function read_files(branch, expected_head) {
+  const raw = await git_gh_exec.exec_gh_api({ path: await comparison_path(branch, expected_head) });
+  const comparison = json_value.parse_with(raw, COMPARISON_SCHEMA);
+  if (comparison === void 0 || comparison.files.length >= FILE_LIMIT) {
+    throw new Error("Cannot authorize a merge without a complete pull request file listing");
+  }
+  return comparison.files;
+}
+async function mark_waiting(branch, issue) {
+  const number = issue ?? git_closes_keyword.parse_closes_issue_number(await git_gh_command.pr_get_body(branch));
+  if (number === void 0) throw new Error("The workflow pull request must identify its Issue");
+  const definition = REPOSITORY_LABELS.find((label) => label.name === NEEDS_HUMAN_MERGE_LABEL);
+  if (definition === void 0) throw new Error("The human merge label definition is missing");
+  await git_gh_command.label_ensure(definition);
+  if (!await git_gh_command.issue_add_label(number, NEEDS_HUMAN_MERGE_LABEL)) {
+    throw new Error("Could not label the Issue waiting for a human merge");
+  }
+}
+async function assert_head(branch, expected_head) {
+  if (expected_head === void 0) return;
+  const state = await git_gh_command.pr_get_merge_state(branch);
+  if (state?.head_sha !== expected_head) {
+    throw new Error(HEAD_CHANGED);
+  }
+}
+async function assert_allowed(branch, issue, expected_head) {
+  const files = await read_files(branch, expected_head);
+  await assert_head(branch, expected_head);
+  if (!touches_workflow(files)) return;
+  const url = await git_gh_command.pr_get_url(branch);
+  if (url === void 0) throw new Error("Could not read the workflow pull request URL");
+  await mark_waiting(branch, issue);
+  throw new HumanMergeRequiredError(
+    `Human merge required: ${url}
+Read the diff on GitHub and merge the pull request there.`
+  );
+}
+var followup_human_merge = { assert_allowed };
+
+// scripts/followup/followup-issue-number.ts
+function parse_issue_number_from_text(input) {
+  if (input === void 0) return void 0;
+  const trimmed = input.trim();
+  const direct_match = /^#?(\d+)$/u.exec(trimmed);
+  if (direct_match?.[1] !== void 0) return direct_match[1];
+  const title_match = /#(\d+)$/u.exec(trimmed);
+  return title_match?.[1];
+}
+function parse_completed_issue_number(raw) {
+  const digits = parse_issue_number_from_text(raw);
+  return digits === void 0 ? void 0 : Number(digits);
+}
+
+// scripts/followup/followup-review-gates.ts
+function is_merge_permitted(status) {
+  return status === "ok" || status === "not-required";
+}
+function is_valid_issue(issue_number) {
+  return issue_number !== void 0 && issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number);
+}
+async function assert_review_attested(should_merge) {
+  if (!should_merge) return;
+  const verdict = await review_attest.check_here();
+  if (!is_merge_permitted(verdict.status)) throw new Error(review_attest.refusal_message(verdict));
+  const refusal = await issue_watch_gate.review_refusal_here();
+  if (refusal !== void 0) throw new Error(refusal);
+}
+async function assert_review_recorded(should_merge, issue_number) {
+  if (!should_merge || !is_valid_issue(issue_number)) return;
+  const issue = Number(issue_number);
+  const verdict = await review_record.check(issue);
+  if (!is_merge_permitted(verdict.status)) throw new Error(review_record.refusal_message(issue));
+  const refusal = await review_interaction.refusal(issue);
+  if (refusal !== void 0) throw new Error(refusal);
+}
+var followup_review_gates = {
+  assert_review_attested,
+  assert_review_recorded,
+  is_valid_issue
+};
+
+// scripts/followup/followup-section.ts
+var SUCCESS_EXIT_CODE = 0;
+var FOLLOWUP = "followup";
+var UNRESOLVED_MESSAGE = "The section that governs `josh followup` could not be printed.";
+var { SHIPPED_ENVIRONMENT, is_ship_run } = followup_ship_environment;
+function print_section(root = process.cwd(), source = process.env) {
+  if (is_ship_run(source)) return;
+  if (run_step_section.print_once(FOLLOWUP, root) !== SUCCESS_EXIT_CODE) {
+    throw new Error(UNRESOLVED_MESSAGE);
+  }
+}
+var followup_section = { SHIPPED_ENVIRONMENT, UNRESOLVED_MESSAGE, print_section };
+
+// scripts/followup/git-followup-cleanup.ts
+function report_failure(step, error) {
+  console.warn("");
+  console.warn(
+    `\u26A0\uFE0F  ${step.label} failed after the merge: ${git_gh_helpers.get_error_message_with_stderr(error)}`
+  );
+  if (step.recovery !== void 0) console.warn(`   Recovery: ${step.recovery}`);
+  console.warn("");
+}
+async function run_step(step) {
+  try {
+    await step.run();
+    return true;
+  } catch (error) {
+    report_failure(step, error);
+    return false;
+  }
+}
+async function run_guarded_step(is_guarded, step) {
+  if (!is_guarded) {
+    await step.run();
+    return true;
+  }
+  return await run_step(step);
+}
+async function run_guarded_steps(is_guarded, steps) {
+  let is_complete = true;
+  for (const step of steps) {
+    const is_done = await run_guarded_step(is_guarded, step);
+    if (!is_done) is_complete = false;
+  }
+  return is_complete;
+}
+var git_followup_cleanup = {
+  run_step,
+  run_guarded_step,
+  run_guarded_steps
+};
+
+// scripts/followup/git-followup-finish.ts
+var MAIN_SYNC = "main:sync";
+async function read_pending_release() {
+  const line = await git_followup_pending.pending_release_line({ is_merge_pending: false });
+  return line === void 0 ? [] : [line];
+}
+async function print_pending_release() {
+  const lines2 = await read_pending_release();
+  for (const line of lines2) console.info(line);
+}
+async function read_next_issues(completed_issue_number, should_merge) {
+  if (!should_merge) return [];
+  return await git_next_issues.fetch_next_issue_lines(
+    parse_completed_issue_number(completed_issue_number)
+  );
+}
+async function print_next_issues(completed_issue_number) {
+  const lines2 = await read_next_issues(completed_issue_number, true);
+  for (const line of lines2) console.info(line);
+}
+async function print_completion(issue_number, should_merge) {
+  const started_ms = performance.now();
+  const [next_lines, release_lines] = await Promise.all([
+    read_next_issues(issue_number, should_merge),
+    read_pending_release()
+  ]);
+  const duration_ms = performance.now() - started_ms;
+  console.info(
+    git_followup_stages.format_stage({ name: git_followup_stages.STAGE.completion, duration_ms })
+  );
+  console.info("");
+  console.info("\u2705 PR followup completed.");
+  for (const line of [...next_lines, ...release_lines]) console.info(line);
+}
+function clear_round_one_snapshot(should_merge) {
+  if (should_merge) review_stamps.clear_round_one();
+}
+async function clear_review_target(should_merge) {
+  if (!should_merge) return;
+  try {
+    await review_attest.clear_here();
+  } catch {
+  }
+}
+async function clear_issue_watch(should_merge) {
+  if (!should_merge) return;
+  try {
+    await issue_watch.clear_here();
+  } catch {
+  }
+}
+async function clear_review_records(should_merge) {
+  clear_round_one_snapshot(should_merge);
+  await clear_review_target(should_merge);
+  await clear_issue_watch(should_merge);
+}
+async function release_worktree_hold(should_merge) {
+  if (!should_merge) return;
+  try {
+    const directory = await run_hold.worktree_directory();
+    if (directory !== void 0) run_hold.release_hold(run_hold.hold_path(directory));
+  } catch {
+  }
+}
+async function end_progress_watcher(should_merge) {
+  if (!should_merge) return;
+  try {
+    const directory = await run_hold.worktree_directory();
+    if (directory === void 0) return;
+    run_progress_clock.end_life(run_progress_clock.life_target_of(directory));
+  } catch {
+  }
+}
+function build_report_steps(issue_number, should_merge) {
+  return [
+    // No `recovery`: the completion output is console text, which nothing re-prints.
+    {
+      label: "The completion output",
+      recovery: void 0,
+      run: async () => {
+        await print_completion(issue_number, should_merge);
+      }
+    }
+  ];
+}
+function build_record_steps(should_merge) {
+  return [
+    {
+      label: "The review records",
+      recovery: void 0,
+      run: async () => {
+        await clear_review_records(should_merge);
+      }
+    },
+    {
+      label: "The working-tree hold release",
+      // **The forced spelling, because the run that wrote the record is this one and it is
+      // ending**. A release names the run it belongs to, so a person
+      // finishing this step by hand is releasing a record they did not write — the plain form
+      // would answer `held` and remove nothing, which is a printed recovery that cannot recover.
+      recovery: "pnpm josh run:release --force",
+      run: async () => {
+        await release_worktree_hold(should_merge);
+      }
+    },
+    {
+      label: "The progress watcher",
+      // No recovery: the record is presence-only and the watcher's own bound ends it regardless,
+      // so there is nothing a person types to finish this step by hand.
+      recovery: void 0,
+      run: async () => {
+        await end_progress_watcher(should_merge);
+      }
+    }
+  ];
+}
+async function is_on_default_branch(root) {
+  const [current, default_branch] = await Promise.all([
+    git_command.branch_at(root),
+    git_command.get_default_branch()
+  ]);
+  return current === default_branch;
+}
+async function sync_main_checkout(should_merge) {
+  if (!should_merge) return;
+  const root = await lane_registry.main_repository_root();
+  if (!await is_on_default_branch(root)) {
+    console.info(`${MAIN_SYNC} skipped: ${root} is not on the default branch`);
+    return;
+  }
+  josh_command.require_success(await josh_command.josh_run_at([MAIN_SYNC], root), MAIN_SYNC);
+}
+function build_sync_steps(should_merge) {
+  return [
+    {
+      label: "The main checkout sync",
+      recovery: "pnpm josh main:sync (in the primary checkout)",
+      run: async () => {
+        await sync_main_checkout(should_merge);
+      }
+    }
+  ];
+}
+function build_finish_steps(issue_number, should_merge) {
+  return [
+    ...build_report_steps(issue_number, should_merge),
+    ...build_record_steps(should_merge),
+    ...build_sync_steps(should_merge)
+  ];
+}
+async function finish(issue_number, should_merge) {
+  return await git_followup_cleanup.run_guarded_steps(
+    should_merge,
+    build_finish_steps(issue_number, should_merge)
+  );
+}
+var git_followup_finish = {
+  finish,
+  build_finish_steps,
+  print_completion,
+  print_next_issues,
+  print_pending_release,
+  clear_review_records,
+  release_worktree_hold,
+  end_progress_watcher,
+  sync_main_checkout
+};
+
+// scripts/followup/git-followup-flush.ts
+var COMMIT_MESSAGE_PREFIX = "Record observation ledger entries";
+function commit_message(issue_number) {
+  return issue_number === void 0 ? COMMIT_MESSAGE_PREFIX : `${COMMIT_MESSAGE_PREFIX} ${issue_cite.plain_for("github", issue_number)}`;
+}
+async function assert_grammar() {
+  const broken = await observation_ledger_prepare.prepare(await git_command.repository_root());
+  if (broken.length > 0) throw new Error(observations_flush.broken_lines_message(broken));
+}
+async function push_or_undo_commit() {
+  try {
+    await git_command.push();
+  } catch (error) {
+    await git_spawn.read(["reset", "--soft", "HEAD~1"]);
+    throw error;
+  }
+}
+async function commit_and_push(paths, issue_number) {
+  await git_spawn.read(["add", "-A", "--", ...paths]);
+  await git_command.commit(commit_message(issue_number));
+  await push_or_undo_commit();
+}
+async function commit_ledger_step(should_merge, issue_number) {
+  if (!should_merge) return;
+  const status_output = await git_command.status();
+  if (!observation_ledger.has_pending_append(status_output)) return;
+  await assert_grammar();
+  const paths = observation_ledger.ledger_paths(await git_command.status()).filter((file_path) => !observation_ledger.is_migration_claim(file_path));
+  if (paths.length === 0) return;
+  await commit_and_push(paths, issue_number);
+  console.info(
+    `\u{1F4A1} Committed ${String(paths.length)} observation ledger path(s) to the pull request.`
+  );
+}
+var git_followup_flush = { COMMIT_MESSAGE_PREFIX, commit_ledger_step };
+
+// scripts/followup/git-followup-merged.ts
+import { z as z2 } from "zod";
+var COMPLETION_MARK = "\u2705 ";
+var PR_LINE_PREFIX = "PR: ";
+var LINE_SEPARATOR = "\n";
+var COMMENTS_SCHEMA = z2.array(
+  z2.object({ body: z2.string().nullish(), created_at: z2.string().nullish() })
+);
+function to_merge_plan(state, is_merge_requested) {
+  const is_merged = state?.is_merged === true;
+  return { is_merged, should_merge: is_merged || is_merge_requested, merged_at: state?.merged_at };
+}
+async function read_merge_plan(branch_name, is_merge_requested) {
+  return to_merge_plan(await git_gh_command.pr_get_merge_state(branch_name), is_merge_requested);
+}
+function is_completion_text(text, pr_url) {
+  if (typeof text !== "string" || !text.startsWith(COMPLETION_MARK)) return false;
+  return text.split(LINE_SEPARATOR).includes(`${PR_LINE_PREFIX}${pr_url}`);
+}
+function is_posted_since(comment, merged_at) {
+  if (typeof comment.created_at !== "string") return false;
+  return Date.parse(comment.created_at) >= Date.parse(merged_at);
+}
+function parse_comments(comments_json = "") {
+  const parsed = COMMENTS_SCHEMA.safeParse(json_value.parse_or_undefined(comments_json));
+  return parsed.success ? parsed.data : [];
+}
+function has_completion_record(input) {
+  return parse_comments(input.comments_json).some(
+    (comment) => is_completion_text(comment.body, input.pr_url) && is_posted_since(comment, input.merged_at)
+  );
+}
+async function is_completion_recorded(input) {
+  const { merged_at, issue_number, pr_url } = input;
+  if (issue_number === void 0 || pr_url === void 0 || merged_at === void 0) return false;
+  const comments_json = await git_gh_command.issue_list_comments(issue_number);
+  return has_completion_record({ comments_json, pr_url, merged_at });
+}
+var git_followup_merged = {
+  has_completion_record,
+  is_completion_recorded,
+  read_merge_plan,
+  to_merge_plan
+};
+
+// scripts/gh/git-ai-review-scan.ts
+var CLAUDE_AUTHORS = /* @__PURE__ */ new Set(["claude[bot]"]);
+var CODERABBIT_AUTHORS = /* @__PURE__ */ new Set(["coderabbitai[bot]"]);
+var CLAUDE_BLOCKER_HEADINGS = [
+  /^#{2,4}\s+Issues\b/mu,
+  /^#{2,4}\s+Problem\b/mu,
+  /^#{3,4}\s+Logic bug\b/imu,
+  /^#{3,4}\s+\d+\.\s+/mu
+];
+var CODERABBIT_ACTIONABLE_PATTERN = /Actionable comments posted:\s*(\d+)/iu;
+var CODERABBIT_RATE_LIMIT_PATTERNS = [
+  /rate limited by coderabbit\.ai/iu,
+  /Rate limit exceeded/iu
+];
+var HEADING_PREFIX_PATTERN = /^#{2,4}\s+/u;
+var NEWLINE_CHAR = "\n";
+var NOT_FOUND_INDEX = -1;
+var EMPTY_COUNT = 0;
+var CLAUDE_DEFAULT_SUMMARY = "Claude Review finding";
+function is_claude_author(login) {
+  return CLAUDE_AUTHORS.has(login);
+}
+function is_coderabbit_author(login) {
+  return CODERABBIT_AUTHORS.has(login);
+}
+function is_claude_blocker(body) {
+  return CLAUDE_BLOCKER_HEADINGS.some((pattern) => pattern.test(body));
+}
+function parse_coderabbit_actionable(body) {
+  const match = CODERABBIT_ACTIONABLE_PATTERN.exec(body);
+  const raw = match?.[1];
+  if (raw === void 0) return EMPTY_COUNT;
+  const count = Number(raw);
+  return Number.isFinite(count) ? count : EMPTY_COUNT;
+}
+function is_coderabbit_rate_limit(body) {
+  return CODERABBIT_RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(body));
+}
+function slice_line_at(body, start_index) {
+  const line_end = body.indexOf(NEWLINE_CHAR, start_index);
+  return line_end === NOT_FOUND_INDEX ? body.slice(start_index) : body.slice(start_index, line_end);
+}
+function extract_heading_text(body, pattern) {
+  const match = pattern.exec(body);
+  if (match === null) return void 0;
+  const line = slice_line_at(body, match.index);
+  return line.replace(HEADING_PREFIX_PATTERN, "").trim();
+}
+function extract_blocker_heading(body) {
+  for (const pattern of CLAUDE_BLOCKER_HEADINGS) {
+    const heading = extract_heading_text(body, pattern);
+    if (heading !== void 0) return heading;
+  }
+  return "";
+}
+function build_none_finding(comment) {
+  return { author_login: comment.author_login, url: comment.url, kind: "none", summary: "" };
+}
+function claude_summary(body) {
+  const heading = extract_blocker_heading(body);
+  return heading.length > 0 ? heading : CLAUDE_DEFAULT_SUMMARY;
+}
+function classify_claude_comment(comment) {
+  if (!is_claude_blocker(comment.body)) return build_none_finding(comment);
+  return {
+    author_login: comment.author_login,
+    url: comment.url,
+    kind: "blocker",
+    summary: claude_summary(comment.body)
+  };
+}
+function build_coderabbit_info(comment, count) {
+  return {
+    author_login: comment.author_login,
+    url: comment.url,
+    kind: "info",
+    summary: `CodeRabbit actionable comments posted: ${String(count)}`
+  };
+}
+function classify_coderabbit_comment(comment) {
+  if (is_coderabbit_rate_limit(comment.body)) return build_none_finding(comment);
+  const count = parse_coderabbit_actionable(comment.body);
+  if (count === EMPTY_COUNT) return build_none_finding(comment);
+  return build_coderabbit_info(comment, count);
+}
+function classify_comment(comment) {
+  if (is_claude_author(comment.author_login)) return classify_claude_comment(comment);
+  if (is_coderabbit_author(comment.author_login)) return classify_coderabbit_comment(comment);
+  return build_none_finding(comment);
+}
+function classify_ai_review_comments(comments) {
+  const classified = comments.map((comment) => classify_comment(comment));
+  return {
+    blockers: classified.filter((entry) => entry.kind === "blocker"),
+    infos: classified.filter((entry) => entry.kind === "info")
+  };
+}
+
+// scripts/gh/git-pr-confirmation.ts
+var CONFIRMATION_RECOVERY = 'send it by hand \u2014 `pnpm josh notify --task-type confirmation --issue-url <url> --body-file <path> --recommended "<choice>"`';
+function build_confirmation_input(input) {
+  return {
+    task_type: "confirmation",
+    repo_name: input.context.repo_name,
+    issue_title: input.context.issue_title,
+    body: input.body,
+    choices: confirmation_options.block(input),
+    issue_url: input.context.issue_url,
+    pr_url: input.context.pr_url
+  };
+}
+async function notify_confirmation(input) {
+  await telegram_notify.send_or_report(build_confirmation_input(input), CONFIRMATION_RECOVERY);
+}
+function has_ignore_reason(reason) {
+  return reason !== void 0 && reason.trim().length > 0;
+}
+var git_pr_confirmation = {
+  notify_confirmation
+};
+
+// scripts/gh/git-pr-ai-review.ts
+function parse_ai_review_comments(raw_json) {
+  if (raw_json === void 0) return void 0;
+  return parse_json_array_or_undefined(raw_json, ai_review_pull_comment_schema);
+}
+function to_review_comment(raw) {
+  return {
+    body: raw.body ?? "",
+    author_login: raw.author?.login ?? "",
+    url: raw.url
+  };
+}
+function format_ai_review_finding(finding) {
+  return gh_comment_input.format({
+    author: finding.author_login,
+    body: finding.summary,
+    url: finding.url
+  });
+}
+function log_info_findings(infos) {
+  if (infos.length === 0) return [];
+  console.warn("\u26A0 CodeRabbit review is non-blocking (temporary policy \u2014 kit#753):");
+  for (const info of infos) {
+    console.warn(format_ai_review_finding(info));
+  }
+  return infos.map((info) => `CodeRabbit skipped (kit#753): ${format_ai_review_finding(info)}`);
+}
+function build_ai_review_blocker_body(blockers) {
+  const lines2 = ["AI reviewer findings remain unresolved.", ""];
+  for (const blocker of blockers) {
+    lines2.push(format_ai_review_finding(blocker));
+  }
+  return lines2.join("\n");
+}
+function build_ai_review_ignore_comment(reason, blockers) {
+  const lines2 = [
+    "Some AI reviewer findings were intentionally left unresolved.",
+    `Reason: ${reason.trim()}`,
+    "Affected comments:"
+  ];
+  for (const blocker of blockers) {
+    lines2.push(format_ai_review_finding(blocker));
+  }
+  return lines2.join("\n");
+}
+async function fetch_review_comments(branch_name) {
+  const parsed = parse_ai_review_comments(await git_gh_command.pr_get_comments(branch_name));
+  return parsed?.map((comment) => to_review_comment(comment));
+}
+var IGNORE_ALTERNATIVE = 'Re-run `pnpm josh followup --ai-review-ignore-reason "<reason>"` if the gate does not apply';
+async function handle_blockers(input) {
+  const body = build_ai_review_blocker_body(input.blockers);
+  if (has_ignore_reason(input.ignore_reason)) {
+    const ignore_comment = build_ai_review_ignore_comment(input.ignore_reason, input.blockers);
+    await git_gh_command.pr_comment(input.branch_name, ignore_comment);
+    return;
+  }
+  await git_pr_confirmation.notify_confirmation({
+    context: input.context,
+    body,
+    recommended: "Fix the findings and re-run `pnpm josh followup`",
+    alternatives: [IGNORE_ALTERNATIVE]
+  });
+  throw new Error(body);
+}
+var UNREADABLE_COMMENTS_BODY = "The AI reviewer comments could not be read, so no finding could be ruled out.\nRe-run `pnpm josh followup` once the read succeeds, or pass an ignore reason.";
+var UNREADABLE_COMMENTS_NOTE = "AI reviewer comments could not be read; the scan was bypassed.";
+async function confirm_unreadable_stop(context) {
+  note_unreadable_stop();
+  if (is_retry_pending()) return;
+  await git_pr_confirmation.notify_confirmation({
+    context,
+    body: UNREADABLE_COMMENTS_BODY,
+    recommended: "Re-run `pnpm josh followup` once the comments can be read",
+    alternatives: [IGNORE_ALTERNATIVE]
+  });
+}
+async function handle_unreadable_comments(input) {
+  if (has_ignore_reason(input.ignore_reason)) {
+    await git_gh_command.pr_comment(
+      input.branch_name,
+      `${UNREADABLE_COMMENTS_BODY}
+Reason: ${input.ignore_reason.trim()}`
+    );
+    return [UNREADABLE_COMMENTS_NOTE];
+  }
+  await confirm_unreadable_stop(input.context);
+  throw new Error(UNREADABLE_COMMENTS_BODY);
+}
+async function handle_ai_review_findings(input) {
+  const review_comments = await fetch_review_comments(input.branch_name);
+  if (review_comments === void 0) return await handle_unreadable_comments(input);
+  const { blockers, infos } = classify_ai_review_comments(review_comments);
+  const skip_notes = log_info_findings(infos);
+  if (blockers.length > 0) await handle_blockers({ ...input, blockers });
+  return skip_notes;
+}
+var git_pr_ai_review = {
+  handle_ai_review_findings
+};
+
+// scripts/gh/git-pr-coderabbit.ts
+var CODERABBIT_AUTHOR = "coderabbitai[bot]";
+var CODERABBIT_FLAG = "_\u26A0\uFE0F Potential issue_";
+var CODERABBIT_RESOLVED = "\u2705 Addressed in commit";
+function parse_pull_comments(raw_json) {
+  if (raw_json === void 0) return void 0;
+  return parse_json_array_or_undefined(raw_json, pull_comment_schema);
+}
+function read_unresolved_cr_urls(comments) {
+  return comments.filter((comment) => comment.user?.login === CODERABBIT_AUTHOR).filter((comment) => (comment.body ?? "").includes(CODERABBIT_FLAG)).filter((comment) => !(comment.body ?? "").includes(CODERABBIT_RESOLVED)).map((comment) => comment.html_url ?? "").filter((url) => url.length > 0);
+}
+function build_ignore_reason_comment(reason, urls) {
+  const lines2 = [
+    "Some CodeRabbit findings were intentionally left unresolved.",
+    `Reason: ${reason.trim()}`,
+    "Affected comments:"
+  ];
+  for (const url of urls) {
+    lines2.push(`- ${url}`);
+  }
+  return lines2.join("\n");
+}
+function log_unresolved_coderabbit(urls) {
+  console.warn("\u26A0 Unresolved CodeRabbit comments are non-blocking (temporary policy \u2014 kit#753):");
+  for (const url of urls) {
+    console.warn(`- ${url}`);
+  }
+}
+var UNREADABLE_CR_NOTE = "CodeRabbit line comments could not be read; unresolved findings were not checked (kit#753).";
+async function report_unreadable_cr(input) {
+  console.warn(`\u26A0 ${UNREADABLE_CR_NOTE}`);
+  if (has_ignore_reason(input.ignore_reason)) {
+    const body = `${UNREADABLE_CR_NOTE}
+Reason: ${input.ignore_reason.trim()}`;
+    await git_gh_command.pr_comment(input.branch_name, body);
+  }
+  return [UNREADABLE_CR_NOTE];
+}
+async function record_unresolved_cr(input) {
+  if (!has_ignore_reason(input.ignore_reason)) {
+    log_unresolved_coderabbit(input.unresolved_urls);
+    return;
+  }
+  const reason_comment = build_ignore_reason_comment(input.ignore_reason, input.unresolved_urls);
+  await git_gh_command.pr_comment(input.branch_name, reason_comment);
+}
+async function handle_coderabbit_findings(input) {
+  const raw = await git_gh_command.pr_get_review_comments(input.branch_name);
+  const comments = parse_pull_comments(raw);
+  if (comments === void 0) return await report_unreadable_cr(input);
+  const unresolved_urls = read_unresolved_cr_urls(comments);
+  if (unresolved_urls.length === 0) return [];
+  await record_unresolved_cr({ ...input, unresolved_urls });
+  return unresolved_urls.map((url) => `CodeRabbit unresolved comment skipped (kit#753): ${url}`);
+}
+var git_pr_coderabbit = {
+  handle_coderabbit_findings
+};
+
+// scripts/gh/git-pr-managed-config.ts
+async function read_branch_paths() {
+  return changed_paths.to_paths(await git_command.diff_main_names());
+}
+var REPORT_HEADING = "This pull request changes files that `josh sync` distributes to every consumer project.";
+var REPORT_PATHS_HEADING = "Distributed paths in this diff:";
+function build_report(hits) {
+  return [REPORT_HEADING, REPORT_PATHS_HEADING, managed_config_scope.format_hits(hits)];
+}
+async function handle_managed_config_changes(input) {
+  if (!input.should_merge) return [];
+  const hits = managed_config_scope.find_managed_paths(await read_branch_paths());
+  if (hits.length === 0) return [];
+  return build_report(hits);
+}
+var git_pr_managed_config = {
+  handle_managed_config_changes
+};
+
+// scripts/followup/followup-check-report.ts
+var REPORT_HEADER = "Checks:";
+function is_required(snapshot, name) {
+  return is_required_check(name) || matches_any(name, snapshot.required_contexts ?? []);
+}
+function failed_lines(snapshot) {
+  if (snapshot === void 0) return [];
+  return snapshot.rollup.filter((check) => check.status === CHECK_STATUS_FAIL).map((check) => {
+    const scope = is_required(snapshot, check.name) ? "required" : "not required";
+    return `- ${check.name} \u2014 failed (${scope})`;
+  });
+}
+function reran_lines(reran) {
+  return [...new Set(reran)].map(
+    (name) => `- ${name} \u2014 re-run once, judged flaky; green on the re-run`
+  );
+}
+function retrigger_lines(is_retriggered) {
+  if (!is_retriggered) return [];
+  return [`- ${CODERABBIT_CHECK_NAME} \u2014 rate limited; review retriggered`];
+}
+function lines(input) {
+  const check_lines = [
+    ...failed_lines(input.snapshot),
+    ...reran_lines(input.reran),
+    ...retrigger_lines(input.is_retriggered)
+  ];
+  if (check_lines.length === 0) return [];
+  return [REPORT_HEADER, ...check_lines];
+}
+var followup_check_report = {
+  lines
+};
+
+// scripts/followup/followup-coderabbit-retrigger.ts
+var RETRIGGER_BODY = "@coderabbitai review";
+var WAIT_OPENER = /please wait/iu;
+var WAIT_CLOSER = /before/iu;
+var TOKEN = /\d+|[a-z]+/giu;
+var DIGITS = /^\d+$/u;
+var SECOND_MS = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var MINUTE_MS = SECONDS_PER_MINUTE * SECOND_MS;
+var UNIT_MS = {
+  h: MINUTES_PER_HOUR * MINUTE_MS,
+  m: MINUTE_MS,
+  s: SECOND_MS
+};
+var MARGIN_SECONDS = 15;
+var MARGIN_MS = MARGIN_SECONDS * SECOND_MS;
+var WINDOW_CAP_MINUTES = 30;
+var WINDOW_CAP_MS = WINDOW_CAP_MINUTES * MINUTE_MS;
+var REVIEW_WAIT_ATTEMPTS = 40;
+var REVIEW_WAIT_INTERVAL_SECONDS = 30;
+var REVIEW_WAIT_INTERVAL_MS = REVIEW_WAIT_INTERVAL_SECONDS * SECOND_MS;
+var NO_TIME = 0;
+var FIRST = 0;
+var NEXT = 1;
+var RATE_LIMITED = "rate-limited";
+var RETRIGGER_CAP = 3;
+var NO_BYPASS = "never bypass the check";
+var BY_HAND = `wait it out, post \`${RETRIGGER_BODY}\` and rerun followup; ${NO_BYPASS}`;
+var AGAIN_NOTE = `CodeRabbit rate-limited again after \`${RETRIGGER_BODY}\` (kit#7079): rerun followup, which retriggers up to ${String(RETRIGGER_CAP)} times per pull request; ${NO_BYPASS}`;
+var CAP_NOTE = `CodeRabbit rate-limited after ${String(RETRIGGER_CAP)} \`${RETRIGGER_BODY}\` (kit#7079): end the run unfinished, parked \`run:stalled\` at stage followup; ${NO_BYPASS}`;
+var UNREADABLE_NOTE = `CodeRabbit rate-limited with no window readable from its comments (kit#5289): no retrigger posted \u2014 ${BY_HAND}`;
+var UNFINISHED_NOTE = `CodeRabbit still reviewing after \`${RETRIGGER_BODY}\` (kit#5289): the merge goes ahead without it`;
+function wait_clause_of(body) {
+  const after_opener = body.split(WAIT_OPENER)[NEXT] ?? "";
+  return after_opener.split(WAIT_CLOSER)[FIRST] ?? "";
+}
+function token_ms(tokens, index) {
+  const token = tokens[index] ?? "";
+  if (!DIGITS.test(token)) return NO_TIME;
+  const unit = (tokens[index + NEXT] ?? "").charAt(FIRST).toLowerCase();
+  return Number(token) * (UNIT_MS[unit] ?? NO_TIME);
+}
+function parse_wait_ms(body) {
+  if (!is_coderabbit_rate_limit(body)) return void 0;
+  const tokens = wait_clause_of(body).match(TOKEN) ?? [];
+  const wait_ms = tokens.reduce((sum, _token, index) => sum + token_ms(tokens, index), NO_TIME);
+  return wait_ms === NO_TIME ? void 0 : wait_ms;
+}
+function is_notice(comment) {
+  return is_coderabbit_author(comment.author?.login ?? "") && is_coderabbit_rate_limit(comment.body ?? "");
+}
+function is_retrigger(comment) {
+  return comment.body?.trim() === RETRIGGER_BODY;
+}
+function written_ms(comment) {
+  return Date.parse(comment.updatedAt ?? "");
+}
+function latest_ms(comments, is_match) {
+  const times = comments.filter((comment) => is_match(comment)).map((comment) => written_ms(comment)).filter((ms) => !Number.isNaN(ms));
+  return times.length === 0 ? void 0 : Math.max(...times);
+}
+function window_end_ms(comments) {
+  const ends = comments.filter((comment) => is_notice(comment)).map((comment) => written_ms(comment) + (parse_wait_ms(comment.body ?? "") ?? NaN)).filter((ms) => !Number.isNaN(ms));
+  return ends.length === 0 ? void 0 : Math.max(...ends);
+}
+function is_awaiting(comments) {
+  const retrigger_ms = latest_ms(comments, is_retrigger) ?? NO_TIME;
+  const notice_ms = latest_ms(comments, is_notice) ?? retrigger_ms;
+  return retrigger_ms > notice_ms;
+}
+function too_long_note(wait_ms) {
+  const minutes = String(Math.ceil(wait_ms / MINUTE_MS));
+  return `CodeRabbit rate-limited for ${minutes} more minutes, over followup's ${String(WINDOW_CAP_MINUTES)} minute wait (kit#5289): no retrigger posted \u2014 ${BY_HAND}`;
+}
+function decide(comments, now_ms) {
+  if (is_awaiting(comments)) return { kind: "await" };
+  const spent = comments.filter((comment) => is_retrigger(comment)).length;
+  if (spent >= RETRIGGER_CAP) return { kind: "stop", note: CAP_NOTE };
+  const end_ms = window_end_ms(comments);
+  if (end_ms === void 0) return { kind: "stop", note: UNREADABLE_NOTE };
+  const wait_ms = Math.max(NO_TIME, end_ms - now_ms) + MARGIN_MS;
+  return wait_ms > WINDOW_CAP_MS ? { kind: "stop", note: too_long_note(wait_ms) } : { kind: "retrigger", wait_ms };
+}
+async function read_comments(branch_name) {
+  const raw = await git_gh_command.pr_get_comments(branch_name);
+  return parse_json_array_or_undefined(raw ?? "", ai_review_pull_comment_schema) ?? [];
+}
+async function read_state(branch_name, observe) {
+  const checks = await git_gh_command.pr_get_checks_snapshot(branch_name);
+  const snapshot = parse_pr_state_snapshot(checks.snapshot_json);
+  await observe(snapshot);
+  return followup_checks_event.coderabbit_of(snapshot);
+}
+async function wait_for_review(branch_name, wait) {
+  const observe = followup_coderabbit_wait.observer_of(wait);
+  let is_started = false;
+  let state = RATE_LIMITED;
+  const is_settled = await poll.poll_until(
+    async () => {
+      state = await read_state(branch_name, observe);
+      is_started ||= state !== RATE_LIMITED;
+      return is_started && state !== "running";
+    },
+    {
+      attempts: REVIEW_WAIT_ATTEMPTS,
+      interval_ms: REVIEW_WAIT_INTERVAL_MS,
+      sleeper: poll.sleep,
+      backoff: { schedule: PR_POLL_SCHEDULES.checks }
+    }
+  );
+  if (state === RATE_LIMITED) return [AGAIN_NOTE];
+  return is_settled ? [] : [UNFINISHED_NOTE];
+}
+async function retrigger(branch_name, wait, wait_ms) {
+  const seconds = String(Math.ceil(wait_ms / SECOND_MS));
+  console.info(`\u23F3 CodeRabbit rate-limited \u2014 waiting ${seconds}s, then \`${RETRIGGER_BODY}\``);
+  await poll.sleep(wait_ms);
+  await git_gh_command.pr_comment(branch_name, RETRIGGER_BODY);
+  await lane_ledger_write.record_stage({
+    stage: lane_ledger_write.CODERABBIT_RETRIGGER_STAGE,
+    elapsed_ms: wait_ms
+  });
+  return { is_retriggered: true, notes: await wait_for_review(branch_name, wait) };
+}
+async function follow(branch_name, wait, decision) {
+  if (decision.kind === "retrigger") return await retrigger(branch_name, wait, decision.wait_ms);
+  return { is_retriggered: true, notes: await wait_for_review(branch_name, wait) };
+}
+async function attempt(branch_name, wait, rounds_left, is_retriggered) {
+  const decision = decide(await read_comments(branch_name), Date.now());
+  if (decision.kind === "stop") return { is_retriggered, notes: [decision.note] };
+  const outcome = await follow(branch_name, wait, decision);
+  if (!outcome.notes.includes(AGAIN_NOTE)) return outcome;
+  if (rounds_left <= 1) return { is_retriggered: true, notes: [CAP_NOTE] };
+  return await attempt(branch_name, wait, rounds_left - 1, true);
+}
+async function run(branch_name, wait) {
+  if (wait.last?.state !== RATE_LIMITED) return { is_retriggered: false, notes: [] };
+  return await attempt(branch_name, wait, RETRIGGER_CAP, false);
+}
+async function settle(snapshot, wait_for_green, branch_name, wait) {
+  const { is_retriggered, notes } = await run(branch_name, wait);
+  if (!is_retriggered) return { snapshot, is_retriggered, notes };
+  return { snapshot: await wait_for_green(), is_retriggered, notes };
+}
+var followup_coderabbit_retrigger = {
+  AGAIN_NOTE,
+  CAP_NOTE,
+  RETRIGGER_BODY,
+  RETRIGGER_CAP,
+  UNFINISHED_NOTE,
+  UNREADABLE_NOTE,
+  decide,
+  parse_wait_ms,
+  run,
+  settle
+};
+
+// scripts/followup/followup-run-rerun.ts
+import { z as z3 } from "zod";
+var PAGE = "per_page=100";
+var FAILED_CONCLUSIONS = /* @__PURE__ */ new Set(["failure", "cancelled", "timed_out"]);
+var LATEST_ATTEMPTS = 40;
+var LATEST_INTERVAL_MS = 15e3;
+var job_schema = z3.looseObject({ name: z3.string(), conclusion: z3.string().nullish() });
+var jobs_page_schema = z3.looseObject({ jobs: z3.array(job_schema) });
+var run_schema = z3.looseObject({
+  id: z3.number(),
+  status: z3.string(),
+  conclusion: z3.string().nullish(),
+  run_attempt: z3.number()
+});
+var runs_page_schema = z3.looseObject({ workflow_runs: z3.array(run_schema) });
+async function read_jobs(run_id, filter) {
+  const rest = `runs/${String(run_id)}/jobs?filter=${filter}&${PAGE}`;
+  const { jobs } = await followup_job_rerun.read_actions(rest, jobs_page_schema);
+  return jobs;
+}
+async function read_run_jobs(head_sha) {
+  const rest = `runs?head_sha=${head_sha}&${PAGE}`;
+  const { workflow_runs } = await followup_job_rerun.read_actions(rest, runs_page_schema);
+  return await Promise.all(
+    workflow_runs.map(async (run3) => ({
+      run_id: run3.id,
+      run: run3,
+      all: await read_jobs(run3.id, "all"),
+      latest: await read_jobs(run3.id, "latest")
+    }))
+  );
+}
+function holds(jobs, context) {
+  return jobs.some((job) => is_required_match(job.name, context));
+}
+function holds_every(jobs, contexts) {
+  return contexts.every((context) => holds(jobs, context));
+}
+function has_failed_job(run3) {
+  return run3.latest.some((job) => FAILED_CONCLUSIONS.has(job.conclusion ?? ""));
+}
+function is_rerun_target(run3, lost) {
+  if (has_failed_job(run3)) return false;
+  return lost.some((context) => holds(run3.all, context) && !holds(run3.latest, context));
+}
+function is_truncated(run3) {
+  if (run3.run.status !== "completed" || run3.run.run_attempt > MAX_CHECK_RERUNS) return false;
+  return run3.run.conclusion === "failure" && !has_failed_job(run3);
+}
+async function await_latest_jobs(runs, lost) {
+  let latest = [];
+  await poll.poll_until(
+    async () => {
+      const per_run = await Promise.all(
+        runs.map(async ({ run_id }) => await read_jobs(run_id, "latest"))
+      );
+      latest = per_run.flat();
+      return holds_every(latest, lost);
+    },
+    {
+      attempts: LATEST_ATTEMPTS,
+      interval_ms: LATEST_INTERVAL_MS,
+      backoff: {
+        seen: () => JSON.stringify(latest.map(({ name, conclusion }) => [name, conclusion]))
+      }
+    }
+  );
+}
+async function rerun_whole(runs, lost) {
+  console.info(`\u{1F501} Rerunning the whole CI run that lost required jobs: ${lost.join(", ")}`);
+  await Promise.all(
+    runs.map(
+      async ({ run_id }) => await git_gh_exec.exec_gh_api({
+        path: followup_job_rerun.actions_api_path(`runs/${String(run_id)}/rerun`),
+        method: "POST",
+        should_retry: false
+      })
+    )
+  );
+  await await_latest_jobs(runs, lost);
+}
+async function rerun_truncated(runs, contexts) {
+  const targets = runs.filter((run3) => is_truncated(run3));
+  if (targets.length === 0) return "none";
+  await rerun_whole(targets, contexts);
+  return "rerun";
+}
+async function recover(missing) {
+  const runs = await read_run_jobs(missing.head_sha);
+  const lost = missing.contexts.filter((context) => runs.some((run3) => holds(run3.all, context)));
+  if (lost.length === 0) return await rerun_truncated(runs, missing.contexts);
+  const latest = runs.flatMap((run3) => run3.latest);
+  if (holds_every(latest, lost)) return "present";
+  const targets = runs.filter((run3) => is_rerun_target(run3, lost));
+  if (targets.length === 0) return "none";
+  const rerun = lost.filter((context) => targets.some((run3) => holds(run3.all, context)));
+  await rerun_whole(targets, rerun);
+  return "rerun";
+}
+async function recover_missing(missing) {
+  try {
+    return await recover(missing);
+  } catch (error) {
+    console.info(`\u26A0\uFE0F CI run rerun failed: ${git_gh_helpers.get_error_message_with_stderr(error)}`);
+    return "none";
+  }
+}
+var followup_run_rerun = {
+  recover_missing
+};
+
+// scripts/followup/git-pr-followup-checks.ts
+var WATCH_FAILED_NOTE = "pr checks --watch failed; falling through to polling";
+function reads_as_empty_rollup(raw_json) {
+  const parsed = json_value.parse_or_undefined(raw_json);
+  if (typeof parsed !== "object" || parsed === null || !("statusCheckRollup" in parsed)) {
+    return false;
+  }
+  const { statusCheckRollup: rollup } = parsed;
+  return Array.isArray(rollup) && rollup.length === 0;
+}
+async function has_no_checks(branch_name) {
+  try {
+    const checks = await git_gh_command.pr_get_checks_snapshot(branch_name);
+    return reads_as_empty_rollup(checks.snapshot_json);
+  } catch {
+    return false;
+  }
+}
+async function handle_watch_failure(branch_name, error) {
+  if (await has_no_checks(branch_name)) throw error;
+  console.info(`\u26A0\uFE0F ${WATCH_FAILED_NOTE}: ${git_gh_helpers.get_error_message_with_stderr(error)}`);
+}
+async function watch_before_polling(branch_name, observe) {
+  console.info("");
+  console.info("\u{1F4CA} Watching PR checks...");
+  try {
+    await git_gh_command.pr_checks_watch(branch_name, observe);
+    return true;
+  } catch (error) {
+    await handle_watch_failure(branch_name, error);
+    return false;
+  }
+}
+async function wait_for_checks(input) {
+  const is_watch_returned = !input.is_skip_watch && await watch_before_polling(input.branch_name, input.observe);
+  const stable_reads = is_watch_returned ? WATCH_CONFIRMED_STABLE_READS : DEFAULT_STABLE_READS;
+  return await git_pr_checks.wait_for_pr_success(
+    input.branch_name,
+    stable_reads,
+    issue_watch_gate.assert_read_here,
+    input.observe
+  );
+}
+function is_checks_failure(error) {
+  if (error instanceof PrConflictError) return false;
+  return error instanceof Error && error.message.startsWith(FAILURE_MESSAGE_PREFIX);
+}
+async function rejudge_missing(input, error) {
+  const outcome = await followup_run_rerun.recover_missing(error.missing);
+  if (outcome === "none") return void 0;
+  if (outcome === "rerun") input.reran?.push(...error.missing.contexts);
+  return await wait_for_checks(input);
+}
+async function stop_reruns_spent(branch_name, error) {
+  const names = await followup_job_rerun.read_rerun_names(branch_name);
+  if (names.length === 0) throw error;
+  throw new Error(followup_job_rerun.reruns_spent_message(names));
+}
+async function wait_after_rerun(input) {
+  try {
+    return { snapshot: await wait_for_checks(input) };
+  } catch (error) {
+    if (!is_checks_failure(error)) throw error;
+    return { failure: error };
+  }
+}
+async function rejudge_failed_jobs(input, error, round) {
+  if (round >= MAX_CHECK_RERUNS) return await stop_reruns_spent(input.branch_name, error);
+  const rerun = await followup_job_rerun.rerun_failed_jobs(input.branch_name, round);
+  if (rerun.length === 0) throw error;
+  input.reran?.push(...rerun);
+  const waited = await wait_after_rerun(input);
+  if ("snapshot" in waited) return waited.snapshot;
+  return await rejudge_failed_jobs(input, waited.failure, round + 1);
+}
+async function rejudge_after_rerun(input, error) {
+  if (!is_checks_failure(error)) throw error;
+  const recovered = error instanceof MissingContextError ? await rejudge_missing(input, error) : void 0;
+  return recovered ?? await rejudge_failed_jobs(input, error, 0);
+}
+async function run_checks(input) {
+  try {
+    return await wait_for_checks(input);
+  } catch (error) {
+    return await rejudge_after_rerun(input, error);
+  }
+}
+function read_coderabbit_skip_notes(snapshot) {
+  return snapshot.rollup.filter((check) => is_coderabbit_check(check.name)).filter((check) => check.status !== CHECK_STATUS_PASS).map(
+    (check) => `CodeRabbit check skipped (kit#753): ${check.name} was ${check.status} at merge time`
+  );
+}
+function log_skip_notes(notes) {
+  for (const note of notes) {
+    console.info(`\u23ED ${note}`);
+  }
+}
+var git_pr_followup_checks = {
+  run_checks,
+  read_coderabbit_skip_notes,
+  log_skip_notes
+};
+
+// scripts/followup/git-pr-followup-wrapup.ts
+var { STAGE, lap } = git_followup_stages;
+var COMPLETION_COMMENT_RECOVERY = "post the completion report by hand \u2014 `gh pr comment <branch>` for the pull request, `gh api repos/{owner}/{repo}/issues/<N>/comments` for the issue";
+var IN_PROGRESS_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress";
+function build_notify_body(input) {
+  return git_notify.build_completion_comment_body({
+    message: input.notify_config.message,
+    issue_number: input.issue_number,
+    pr_url: input.pr_url,
+    mentions: input.notify_config.mentions,
+    notes: input.report_notes
+  });
+}
+async function post_notify_issue(input) {
+  if (input.issue_number === void 0) {
+    throw new Error("Issue number is required for issue notification.");
+  }
+  await issue_body_or_comment.post(input.issue_number, input.body);
+}
+function should_notify_pr(target) {
+  return target === "pr" || target === "both";
+}
+function should_notify_issue(target) {
+  return target === "issue" || target === "both";
+}
+async function post_completion_notification(input) {
+  if (input.notify_config === void 0) return;
+  const body = build_notify_body({
+    notify_config: input.notify_config,
+    issue_number: input.issue_number,
+    pr_url: input.pr_url,
+    report_notes: input.report_notes
+  });
+  const { target } = input.notify_config;
+  if (should_notify_pr(target)) {
+    await git_gh_command.pr_comment(input.branch_name, body);
+  }
+  if (should_notify_issue(target)) {
+    await post_notify_issue({ issue_number: input.issue_number, body });
+  }
+}
+async function notify_step(input) {
+  if (input.is_completion_recorded === true) return;
+  await git_followup_cleanup.run_guarded_step(input.should_merge, {
+    label: "The completion comment",
+    recovery: COMPLETION_COMMENT_RECOVERY,
+    run: async () => {
+      await post_completion_notification({
+        branch_name: input.branch_name,
+        issue_number: input.issue_number,
+        notify_config: input.notify_config,
+        pr_url: input.pr_url,
+        report_notes: input.report_notes
+      });
+    }
+  });
+}
+async function epic_close_step(input) {
+  await git_followup_cleanup.run_guarded_step(input.should_merge, {
+    label: "The epic auto-close",
+    recovery: void 0,
+    run: async () => {
+      await epic_close.close_completed_epics({
+        issue_number: input.issue_number,
+        is_merged: input.should_merge
+      });
+    }
+  });
+}
+async function in_progress_step(input) {
+  if (!input.should_merge) return;
+  await git_followup_cleanup.run_guarded_step(input.should_merge, {
+    label: "The `in-progress` label removal",
+    recovery: IN_PROGRESS_RECOVERY,
+    run: async () => {
+      await git_followup_label.strip_in_progress(input.issue_number);
+    }
+  });
+}
+async function issue_close_step(input) {
+  if (!input.should_merge) return;
+  await git_followup_cleanup.run_guarded_step(input.should_merge, {
+    label: "The merged issue close",
+    recovery: git_followup_issue_close.CLOSE_RECOVERY,
+    run: async () => {
+      await git_followup_issue_close.ensure_issue_closed({
+        issue_number: input.closes_number,
+        pr_url: input.pr_url
+      });
+    }
+  });
+}
+async function run_tail_steps(input) {
+  if (!input.should_merge) {
+    await notify_step(input);
+    await epic_close_step(input);
+    return;
+  }
+  await Promise.all([
+    notify_step(input),
+    epic_close_step(input),
+    in_progress_step(input),
+    issue_close_step(input)
+  ]);
+}
+async function merge_step(input) {
+  await issue_watch_gate.assert_read_here();
+  await git_pr_merge_checked.merge_checked(input);
+}
+async function send_beside_merge(input) {
+  if (!input.should_merge || input.is_merged === true) {
+    await input.send_completion();
+    return STAGE.telegram;
+  }
+  await input.before_merge?.(input.checked?.head_sha);
+  await settled_together(input.send_completion(), merge_step(input));
+  return STAGE.telegram_and_merge;
+}
+async function run_wrapup(input, log) {
+  lap(log, await send_beside_merge(input));
+  await run_tail_steps(input);
+  lap(log, STAGE.completion_and_epic_close);
+}
+var git_pr_followup_wrapup = {
+  run_wrapup
+};
+
+// scripts/followup/git-pr-followup.ts
+var { STAGE: STAGE2, lap: lap2 } = git_followup_stages;
+var { run_checks: run_checks2, read_coderabbit_skip_notes: read_coderabbit_skip_notes2, log_skip_notes: log_skip_notes2 } = git_pr_followup_checks;
+var REPO_NAME_SEPARATOR = "/";
+function parse_repo_name(name_with_owner) {
+  if (name_with_owner === void 0) return void 0;
+  const parts = name_with_owner.split(REPO_NAME_SEPARATOR);
+  return parts.at(-1);
+}
+function build_telegram_input(input) {
+  return {
+    task_type: input.task_type,
+    repo_name: input.context.repo_name,
+    issue_title: input.context.issue_title,
+    body: input.body,
+    issue_url: input.context.issue_url,
+    pr_url: input.context.pr_url
+  };
+}
+function build_issue_url(pr_url, issue_number) {
+  if (issue_number === void 0) return void 0;
+  const target = github_issue_url.parse_pull(pr_url);
+  if (target === void 0) return void 0;
+  return `${target.base_url}/issues/${issue_number}`;
+}
+var { parse_closes_issue_number } = git_closes_keyword;
+async function warn_if_missing_closes(branch_name) {
+  const body = await git_gh_command.pr_get_body(branch_name);
+  const closes_number = parse_closes_issue_number(body);
+  if (closes_number !== void 0) return closes_number;
+  console.warn("");
+  console.warn(
+    '\u26A0\uFE0F  PR body is missing a "closes #N" keyword \u2014 the linked Issue will not auto-close on merge.'
+  );
+  console.warn("   Recovery: pnpm josh pr  (or: pnpm josh git -y --skip-commit --skip-push)");
+  console.warn("");
+  return void 0;
+}
+async function read_issue_title(issue_number, closes_number) {
+  const number = issue_number ?? await closes_number;
+  if (number === void 0) return void 0;
+  return await git_gh_command.issue_get_title(number);
+}
+async function read_run_context(input) {
+  const closes = warn_if_missing_closes(input.branch_name);
+  const [closes_number, name_with_owner, pr_url, issue_title] = await Promise.all([
+    closes,
+    git_gh_command.repo_get_name_with_owner(),
+    git_gh_command.pr_get_url(input.branch_name),
+    read_issue_title(input.issue_number, closes)
+  ]);
+  const issue_number = input.issue_number ?? closes_number;
+  return {
+    issue_number,
+    closes_number,
+    context: {
+      repo_name: parse_repo_name(name_with_owner),
+      issue_title,
+      issue_url: build_issue_url(pr_url, issue_number),
+      pr_url
+    }
+  };
+}
+async function completion_sender(context, skip_notes, is_merge_pending) {
+  const pending_line = await git_followup_pending.pending_release_line({ is_merge_pending });
+  const lines2 = pending_line === void 0 ? skip_notes : [pending_line, ...skip_notes];
+  const input = build_telegram_input({ task_type: "completion", context, body: lines2.join("\n") });
+  return async function send_completion() {
+    await telegram_notify.send_or_report(input, void 0);
+  };
+}
+async function send_nothing() {
+}
+async function run_comment_scans(input, context, log) {
+  const comment_notes = await git_pr_coderabbit.handle_coderabbit_findings({
+    branch_name: input.branch_name,
+    ignore_reason: input.coderabbit_ignore_reason
+  });
+  lap2(log, STAGE2.coderabbit_comments);
+  const ai_review_notes = await git_pr_ai_review.handle_ai_review_findings({
+    branch_name: input.branch_name,
+    ignore_reason: input.ai_review_ignore_reason,
+    context
+  });
+  lap2(log, STAGE2.ai_review_comments);
+  return [...comment_notes, ...ai_review_notes];
+}
+function wait_for_green_of(input, context, issue_number, log) {
+  return async function wait_for_green() {
+    return await run_checks2({
+      branch_name: input.branch_name,
+      is_skip_watch: input.is_skip_watch,
+      reran: log.reran,
+      observe: followup_coderabbit_wait.all(
+        followup_checks_event.observer_of(issue_number, context.pr_url),
+        followup_coderabbit_wait.observer_of(log.coderabbit),
+        followup_ci_path.observer_of(log.ci_path)
+      )
+    });
+  };
+}
+async function wait_for_review_green(input, context, issue_number, log) {
+  const wait_for_green = wait_for_green_of(input, context, issue_number, log);
+  const checked = await wait_for_green();
+  lap2(log, STAGE2.checks_wait);
+  const settled = await followup_coderabbit_retrigger.settle(
+    checked,
+    wait_for_green,
+    input.branch_name,
+    log.coderabbit
+  );
+  if (settled.is_retriggered) lap2(log, STAGE2.coderabbit_retrigger);
+  return settled;
+}
+async function run_review_checks(input, context, log, issue_number) {
+  if (input.is_merged === true) return { notes: [], report: [] };
+  git_followup_stages.hold_issue(log, issue_number);
+  const managed = await git_pr_managed_config.handle_managed_config_changes({
+    should_merge: input.should_merge
+  });
+  const settled = await wait_for_review_green(input, context, issue_number, log);
+  const { snapshot } = settled;
+  const check_notes = [...settled.notes, ...read_coderabbit_skip_notes2(snapshot)];
+  log_skip_notes2(check_notes);
+  const scan_notes = await run_comment_scans(input, context, log);
+  const report = [...managed, ...followup_check_report.lines({ ...settled, reran: log.reran })];
+  return { notes: [...report, ...check_notes, ...scan_notes], report, snapshot };
+}
+async function prepare_notify(input, issue_number, context, checks) {
+  const is_recorded = await git_followup_merged.is_completion_recorded({
+    merged_at: input.is_merged === true ? input.merged_at : void 0,
+    issue_number,
+    pr_url: context.pr_url
+  });
+  if (is_recorded) return { is_recorded, send: send_nothing };
+  return { is_recorded, send: await completion_sender(context, checks.notes, input.should_merge) };
+}
+async function run_stages(input, log) {
+  const { issue_number, closes_number, context } = await read_run_context(input);
+  lap2(log, STAGE2.closes_and_context);
+  const checks = await run_review_checks(input, context, log, issue_number);
+  const notify = await prepare_notify(input, issue_number, context, checks);
+  await git_pr_followup_wrapup.run_wrapup(
+    {
+      branch_name: input.branch_name,
+      issue_number,
+      closes_number,
+      notify_config: input.notify_config,
+      pr_url: context.pr_url,
+      should_merge: input.should_merge,
+      report_notes: checks.report,
+      is_merged: input.is_merged,
+      is_completion_recorded: notify.is_recorded,
+      send_completion: notify.send,
+      checked: checks.snapshot,
+      wait_for_green: wait_for_green_of(input, context, issue_number, log),
+      before_merge: input.before_merge
+    },
+    log
+  );
+  return issue_number;
+}
+async function run2(input) {
+  const log = git_followup_stages.new_log();
+  try {
+    return await run_stages(input, log);
+  } catch (error) {
+    lap2(log, git_followup_stages.stopped_lap(error));
+    throw error;
+  } finally {
+    git_followup_stages.print_stages(log);
+    await git_followup_stages.record_waits(log);
+  }
+}
+var git_pr_followup = {
+  run: run2
+};
+
+// scripts/followup/git-followup-workflow.ts
+josh_environment_file.load_environment_file();
+var HELP_TEXT = `
+\u{1F6A6} PR Followup Workflow
+
+Usage:
+  jf-git-followup [issue] [options]
+
+Options:
+  --branch                     Target branch name (default: current branch)
+  --issue-number               Issue number for completion messages
+  --notify-target              pr | issue | both
+  --notify-message             Completion message header
+  --notify-message-file        Read the completion message from a file (\`-\` reads stdin). Use this
+                               whenever the message carries a backtick or a \`$\` \u2014 inside shell
+                               double quotes the shell evaluates them before this command runs
+  --notify-mentions            Comma-separated mentions (user,org/team)
+  --coderabbit-ignore-reason   Reason text when keeping CodeRabbit findings unresolved
+  --ai-review-ignore-reason    Reason text when keeping AI reviewer (Claude Review / CodeRabbit
+                               summary) findings unresolved
+  --skip-watch                 Skip the two-minute check look-ahead and only evaluate latest status
+  --no-merge                   Skip merging the PR (merge is on by default)
+  --merge                      (Deprecated \u2014 merge is now the default; kept for backward compatibility)
+  -h, --help                   Show this help
+`;
+function display_help() {
+  console.info(HELP_TEXT);
+}
+function parse_cli_arguments() {
+  return parseArgs({
+    options: {
+      branch: { type: "string" },
+      "issue-number": { type: "string" },
+      "notify-target": { type: "string" },
+      "notify-message": { type: "string" },
+      "notify-message-file": { type: "string" },
+      "notify-mentions": { type: "string" },
+      "coderabbit-ignore-reason": { type: "string" },
+      "ai-review-ignore-reason": { type: "string" },
+      "skip-watch": { type: "boolean" },
+      "no-merge": { type: "boolean" },
+      merge: { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    },
+    allowPositionals: true
+  });
+}
+async function resolve_branch_name(raw_branch) {
+  if (raw_branch !== void 0 && raw_branch.trim().length > 0) return raw_branch.trim();
+  return await git_branch.current();
+}
+function build_notify_config2(values) {
+  return git_notify.build_notify_config({
+    raw_target: values["notify-target"] ?? "issue",
+    raw_message: cli_body.resolve({
+      inline: values["notify-message"],
+      file_path: values["notify-message-file"],
+      inline_flag: "--notify-message",
+      file_flag: "--notify-message-file"
+    }),
+    raw_mentions: values["notify-mentions"]
+  });
+}
+function is_merge_resolved(values) {
+  return values["no-merge"] !== true;
+}
+var { assert_review_attested: assert_review_attested2, assert_review_recorded: assert_review_recorded2, is_valid_issue: is_valid_issue2 } = followup_review_gates;
+async function assert_live_evidence(should_merge, branch_name) {
+  if (!should_merge) return;
+  const verdict = await live_evidence.check(branch_name);
+  if (verdict !== "required") return;
+  throw new Error(live_evidence.refusal_message());
+}
+async function assert_acceptance_mapped(should_merge, issue_number, branch_name) {
+  if (!should_merge || !is_valid_issue2(issue_number)) return;
+  const refusal = await acceptance_map_check.refusal(issue_number, branch_name);
+  if (refusal !== void 0) throw new Error(refusal);
+}
+async function assert_removed_tests_disposed(should_merge, branch_name) {
+  if (!should_merge) return;
+  const refusal = await removed_tests_check.refusal(branch_name);
+  if (refusal !== void 0) throw new Error(refusal);
+}
+async function assert_merge_gates(should_merge, issue_number, branch_name) {
+  await assert_review_attested2(should_merge);
+  await assert_review_recorded2(should_merge, issue_number);
+  await assert_live_evidence(should_merge, branch_name);
+  await assert_acceptance_mapped(should_merge, issue_number, branch_name);
+  await assert_removed_tests_disposed(should_merge, branch_name);
+}
+async function prepare_merge(plan, issue_number, branch_name) {
+  if (plan.is_merged) return;
+  await assert_merge_gates(plan.should_merge, issue_number, branch_name);
+  if (is_valid_issue2(issue_number)) await lane_size_record.record(plan.should_merge, issue_number);
+  await git_followup_flush.commit_ledger_step(plan.should_merge, issue_number);
+}
+function answer_help_or_open(values) {
+  if (values.help !== true) {
+    followup_section.print_section();
+    return false;
+  }
+  display_help();
+  return true;
+}
+async function main() {
+  const cli = parse_cli_arguments();
+  if (answer_help_or_open(cli.values)) return;
+  const issue_number = cli.values["issue-number"] ?? parse_issue_number_from_text(cli.positionals[0] ?? void 0);
+  const branch_name = await resolve_branch_name(cli.values.branch);
+  const plan = await git_followup_merged.read_merge_plan(branch_name, is_merge_resolved(cli.values));
+  await prepare_merge(plan, issue_number, branch_name);
+  const used_issue_number = await git_pr_followup.run({
+    branch_name,
+    issue_number,
+    notify_config: build_notify_config2(cli.values),
+    coderabbit_ignore_reason: cli.values["coderabbit-ignore-reason"],
+    ai_review_ignore_reason: cli.values["ai-review-ignore-reason"],
+    is_skip_watch: cli.values["skip-watch"] === true,
+    should_merge: plan.should_merge,
+    is_merged: plan.is_merged,
+    merged_at: plan.merged_at,
+    before_merge: async (head) => {
+      await followup_human_merge.assert_allowed(branch_name, issue_number, head);
+    }
+  });
+  await git_followup_finish.finish(used_issue_number ?? issue_number, plan.should_merge);
+}
+try {
+  await main();
+  console.info("");
+} catch (error) {
+  if (error instanceof HumanMergeRequiredError) console.info(error.message);
+  else git_error.handle(error);
+}
+var git_followup_workflow = {
+  answer_help_or_open,
+  assert_acceptance_mapped,
+  assert_live_evidence,
+  assert_removed_tests_disposed,
+  parse_issue_number_from_text,
+  prepare_merge,
+  resolve_branch_name,
+  is_merge_resolved
+};
+export {
+  git_followup_workflow
+};