@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-GWTBIGYC.js

@@ -0,0 +1,550 @@
+import {
+  run_hold_block
+} from "./chunk-RFXON3FK.js";
+import {
+  run_cli_fault
+} from "./chunk-HRLGFRAV.js";
+import {
+  run_halfrun_resume,
+  run_hold_session
+} from "./chunk-PVRDJU2B.js";
+import {
+  run_label,
+  run_maintenance
+} from "./chunk-KN46UC77.js";
+import {
+  telegram_test
+} from "./chunk-SD4EX75H.js";
+import {
+  test_e2e_stamp
+} from "./chunk-VHLDQ3PH.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  git_gh_repo
+} from "./chunk-CTXJVMHW.js";
+import {
+  run_preflight
+} from "./chunk-GAVSK6P6.js";
+import {
+  git_gh_pr_read
+} from "./chunk-5IHEBIPD.js";
+import {
+  run_stage
+} from "./chunk-UWLLZQJB.js";
+import {
+  run_ship_lap
+} from "./chunk-HRN73FQJ.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  run_hold
+} from "./chunk-F5N2QIFD.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/lib/stdout-on-stderr.ts
+function set_stdout_write(stream_write) {
+  process.stdout.write = stream_write;
+}
+async function run(work) {
+  const saved = { write: process.stdout.write.bind(process.stdout) };
+  set_stdout_write(process.stderr.write.bind(process.stderr));
+  try {
+    return await work();
+  } finally {
+    set_stdout_write(saved.write);
+  }
+}
+var stdout_on_stderr = { run };
+
+// scripts/run/run-prrun-resume.ts
+var PRRUN_MERGED = "prrun-merged";
+var PRRUN_MERGE = "prrun-merge";
+var PRRUN_GATE = "prrun-gate";
+function is_untouched(facts) {
+  return facts.head === facts.stop_head && facts.pr_head === facts.stop_head && !facts.is_dirty;
+}
+function decide(facts) {
+  if (facts.is_merged) return PRRUN_MERGED;
+  return is_untouched(facts) ? PRRUN_MERGE : PRRUN_GATE;
+}
+function stop_head_of(read, issue) {
+  const hold = run_halfrun_resume.hold_of(read);
+  return hold?.issue === issue ? hold.prrun_stop_head : void 0;
+}
+async function read_merge_state() {
+  return await git_gh_command.pr_get_merge_state(await git_branch.current());
+}
+async function read_facts(stop_head) {
+  const [state, head, is_dirty] = await Promise.all([
+    read_merge_state(),
+    git_command.head_commit(),
+    run_hold.is_tree_dirty()
+  ]);
+  return {
+    is_merged: state?.is_merged === true,
+    stop_head,
+    head,
+    pr_head: state?.head_sha,
+    is_dirty
+  };
+}
+async function resume_token(issue) {
+  const target = await run_halfrun_resume.hold_target();
+  if (target === void 0) return void 0;
+  const stop_head = stop_head_of(run_hold.read_hold(target), issue);
+  return stop_head === void 0 ? void 0 : decide(await read_facts(stop_head));
+}
+async function adopt(issue) {
+  const target = await run_halfrun_resume.hold_target();
+  if (target === void 0 || stop_head_of(run_hold.read_hold(target), issue) === void 0) {
+    return false;
+  }
+  return run_halfrun_resume.take_over(target, issue);
+}
+async function mark_stop_at(target, issue) {
+  const head = await git_command.head_commit();
+  return run_halfrun_resume.mark_stop_at(target, issue, { prrun_stop_head: head });
+}
+var run_prrun_resume = {
+  PRRUN_GATE,
+  PRRUN_MERGE,
+  PRRUN_MERGED,
+  adopt,
+  decide,
+  mark_stop_at,
+  resume_token,
+  stop_head_of
+};
+
+// scripts/run/hold/run-hold-adopt.ts
+var ADOPTED = "adopted";
+var NO_RECORD = "none";
+var FOREIGN = "foreign";
+var UNREADABLE = "unreadable";
+function rekey(target, issue) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "unreadable") return UNREADABLE;
+  const hold = run_halfrun_resume.hold_of(read);
+  if (hold === void 0) return NO_RECORD;
+  if (hold.issue !== run_hold.UNNUMBERED_ISSUE && hold.issue !== issue) return FOREIGN;
+  stamp_file.write_stamp(target, { ...hold, issue });
+  return ADOPTED;
+}
+function no_record_message(issue) {
+  return `run:hold --adopt: this tree holds no record to adopt \u2014 claim it with \`pnpm josh run:hold ${issue}\`.`;
+}
+function foreign_message(issue) {
+  return `run:hold --adopt: this tree is held for another issue, so it is not handed to issue ${issue}; \`--adopt\` only re-keys a \`new\` run's unnumbered record.`;
+}
+async function adopt2(target, issue) {
+  const result = rekey(target, issue);
+  if (result === ADOPTED) await run_label.mark(issue);
+  return result;
+}
+var run_hold_adopt = {
+  ADOPTED,
+  NO_RECORD,
+  UNREADABLE,
+  adopt: adopt2,
+  foreign_message,
+  no_record_message
+};
+
+// scripts/run/hold/run-stop-notify.ts
+var TITLE_PLACEHOLDER = "<title>";
+var PR_PLACEHOLDER = "<pr-url>";
+var HALFRUN = "halfrun";
+var PRRUN = "prrun";
+function reference_of(facts) {
+  return issue_cite.plain_for("telegram", facts.issue);
+}
+function commit_title(facts) {
+  return shell_quote.single_quoted(`${facts.title ?? TITLE_PLACEHOLDER} ${reference_of(facts)}`);
+}
+function with_urls(values, facts) {
+  const with_issue = facts.issue_url === void 0 ? values : { ...values, "issue-url": facts.issue_url };
+  return facts.pr_url === void 0 ? with_issue : { ...with_issue, "pr-url": facts.pr_url };
+}
+function halfrun_values(facts) {
+  const title = commit_title(facts);
+  const body = [
+    "halfrun ready for manual verification",
+    run_stage.next_line(HALFRUN, facts.issue),
+    `Without an agent: pnpm josh git -y ${title} && pnpm josh followup ${title}`
+  ].join("\n");
+  const values = {
+    "task-type": "confirmation",
+    body,
+    recommended: `Verify by hand, then prrun ${reference_of(facts)}`,
+    alternative: [`fullrun ${reference_of(facts)}`]
+  };
+  return with_urls(values, facts);
+}
+function human_review_values(facts, directory) {
+  const body = [
+    "needs-human-review: implemented and gated, stopped before the commit",
+    run_stage.next_line(HALFRUN, facts.issue),
+    `Working tree: ${directory}`
+  ].join("\n");
+  const values = {
+    "task-type": "confirmation",
+    body,
+    recommended: `Review the working tree, then prrun ${reference_of(facts)}`,
+    alternative: [`fullrun ${reference_of(facts)}`]
+  };
+  return with_urls(values, facts);
+}
+function prrun_values(facts) {
+  const body = [
+    `prrun ready to merge: ${facts.pr_url ?? PR_PLACEHOLDER}`,
+    run_stage.next_line(PRRUN, facts.issue),
+    `After a manual merge, without an agent: pnpm josh followup ${commit_title(facts)}`
+  ].join("\n");
+  const values = {
+    "task-type": "confirmation",
+    body,
+    recommended: `fullrun ${reference_of(facts)}`,
+    alternative: ["Merge by hand, then pnpm josh followup"]
+  };
+  return with_urls(values, facts);
+}
+async function issue_facts(issue) {
+  const slug = await git_gh_repo.repo_get_name_with_owner();
+  const title = await git_gh_issue_read.issue_get_title(issue);
+  return {
+    issue,
+    title,
+    issue_url: slug === void 0 ? void 0 : issue_cite.issue_url(slug, issue)
+  };
+}
+async function prrun_facts(issue) {
+  const pr_url = await git_gh_pr_read.pr_get_url(await git_command.branch());
+  return { ...await issue_facts(issue), pr_url };
+}
+async function send_composed(target, compose) {
+  const { values, title } = await compose();
+  const titled = title === void 0 ? values : { ...values, "issue-title": title };
+  await stdout_on_stderr.run(async () => {
+    await telegram_test.send_values(titled);
+  });
+  run_hold_session.mark_notified(target);
+}
+async function send(target, compose) {
+  try {
+    await send_composed(target, compose);
+  } catch (error) {
+    console.error(`\u26A0\uFE0F  run:hold could not send the stop confirmation: ${String(error)}`);
+  }
+}
+async function send_halfrun(target, issue) {
+  await send(target, async () => {
+    const facts = await issue_facts(issue);
+    return { values: halfrun_values(facts), title: facts.title };
+  });
+}
+async function send_prrun(target, issue) {
+  await send(target, async () => {
+    const facts = await prrun_facts(issue);
+    return { values: prrun_values(facts), title: facts.title };
+  });
+}
+async function send_human_review(target, issue) {
+  await send(target, async () => {
+    const facts = await issue_facts(issue);
+    const directory = await git_command.repository_root();
+    return { values: human_review_values(facts, directory), title: facts.title };
+  });
+}
+var run_stop_notify = {
+  halfrun_values,
+  human_review_values,
+  prrun_values,
+  send_halfrun,
+  send_human_review,
+  send_prrun
+};
+
+// scripts/run/hold/run-hold-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var RELEASE_FLAG = "--release";
+var FORCE_FLAG = "--force";
+var FULLRUN_FLAG = "--fullrun";
+var HALFRUN_STOP_FLAG = "--halfrun-stop";
+var HALFRUN_ROUND_FLAG = "--halfrun-round";
+var PRRUN_STOP_FLAG = "--prrun-stop";
+var HUMAN_REVIEW_STOP_FLAG = "--human-review-stop";
+var ADOPT_FLAG = "--adopt";
+var MAX_CLAIM_ARGUMENTS = 2;
+var USAGE = "Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --halfrun-round | --human-review-stop | --prrun-stop]] | josh run:hold --adopt <issue-number> | josh run:release [<issue-number> | --force]";
+var COMMAND = "run:hold";
+var HOLD_VERDICT = "hold";
+var BUSY_VERDICT = "busy";
+var UNKNOWN_VERDICT = "unknown";
+var RELEASED_VERDICT = "released";
+var NONE_VERDICT = "none";
+var HELD_VERDICT = "held";
+var E2E_OWED_VERDICT = "e2e-owed";
+var FORCE_RELEASE_KIND = "force-release";
+var HALFRUN_STOP_KIND = "halfrun-stop";
+var HUMAN_REVIEW_STOP_KIND = "human-review-stop";
+var PRRUN_STOP_KIND = "prrun-stop";
+var ADOPT_KIND = "adopt";
+var HALFRUN_ROUND_KIND = "halfrun-round";
+var STOP_KINDS = /* @__PURE__ */ new Set([
+  HALFRUN_STOP_KIND,
+  HUMAN_REVIEW_STOP_KIND,
+  PRRUN_STOP_KIND
+]);
+function is_stop_request(request) {
+  return STOP_KINDS.has(request.kind);
+}
+var TAKE_OVER_KINDS = /* @__PURE__ */ new Set([ADOPT_KIND, HALFRUN_ROUND_KIND]);
+function is_take_over_request(request) {
+  return TAKE_OVER_KINDS.has(request.kind);
+}
+var FORCE_RELEASE_REQUEST = { kind: FORCE_RELEASE_KIND };
+function release_request(claimant) {
+  return { kind: "release", claimant };
+}
+var STOP_KIND_BY_FLAG = /* @__PURE__ */ new Map([
+  [HALFRUN_STOP_FLAG, HALFRUN_STOP_KIND],
+  [HUMAN_REVIEW_STOP_FLAG, HUMAN_REVIEW_STOP_KIND],
+  [PRRUN_STOP_FLAG, PRRUN_STOP_KIND]
+]);
+function numbered_claim(issue, flag) {
+  if (flag === void 0) return { kind: "claim", issue };
+  const stop_kind = STOP_KIND_BY_FLAG.get(flag);
+  if (stop_kind !== void 0) return { kind: stop_kind, issue };
+  if (flag === HALFRUN_ROUND_FLAG) return { kind: HALFRUN_ROUND_KIND, issue };
+  return flag === FULLRUN_FLAG ? { kind: "claim", issue, is_fullrun: true } : void 0;
+}
+function parse_claim(argv) {
+  const [first, flag] = argv;
+  if (first === void 0) return { kind: "claim", issue: run_hold.UNNUMBERED_ISSUE };
+  if (argv.length > MAX_CLAIM_ARGUMENTS || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(first)) {
+    return void 0;
+  }
+  return numbered_claim(first, flag);
+}
+function parse_release_argument(first) {
+  if (first === FORCE_FLAG) return FORCE_RELEASE_REQUEST;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(first) ? release_request(first) : void 0;
+}
+function parse_release(argv) {
+  const [first] = argv;
+  if (first === void 0) return release_request(run_hold.UNNUMBERED_ISSUE);
+  return argv.length > 1 ? void 0 : parse_release_argument(first);
+}
+function parse_adopt(argv) {
+  const [issue] = argv;
+  if (issue === void 0 || argv.length > 1) return void 0;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? { kind: ADOPT_KIND, issue } : void 0;
+}
+function parse_request(argv) {
+  if (argv[0] === RELEASE_FLAG) return parse_release(argv.slice(1));
+  if (argv[0] === ADOPT_FLAG) return parse_adopt(argv.slice(1));
+  return parse_claim(argv);
+}
+function report(message, verdict, code) {
+  console.error(message);
+  console.info(verdict);
+  return code;
+}
+function report_busy(message) {
+  return report(message, BUSY_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_hold() {
+  console.info(HOLD_VERDICT);
+  return SUCCESS_EXIT_CODE;
+}
+function take_free_tree(target, request) {
+  const is_taken = run_hold.create_hold(target, request.issue, /* @__PURE__ */ new Date(), request.is_fullrun);
+  if (is_taken) return report_hold();
+  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
+}
+function replace_stale(target, request, hold) {
+  console.error(run_hold.stale_message(hold));
+  run_hold.release_hold(target);
+  return take_free_tree(target, request);
+}
+function take_tree(target, request, read) {
+  if (read.kind === "held") return report_hold();
+  return read.kind === "stale" ? replace_stale(target, request, read.hold) : take_free_tree(target, request);
+}
+function report_preflight(decision) {
+  console.error(`${decision.reason}
+${decision.advice}`);
+  console.info(decision.verdict);
+  return SUCCESS_EXIT_CODE;
+}
+async function preflight_gate(issue, is_linked) {
+  if (is_linked || issue === run_hold.UNNUMBERED_ISSUE) return void 0;
+  const decision = await run_preflight.check(issue);
+  if (decision.verdict === run_preflight.CLEAN_VERDICT) return void 0;
+  return report_preflight(decision);
+}
+async function claim(target, request, is_linked) {
+  const gate = await run_ship_lap.timed(
+    "preflight",
+    async () => await preflight_gate(request.issue, is_linked)
+  );
+  if (gate !== void 0) return gate;
+  const read = run_hold.read_hold(target);
+  const blocked = await run_hold_block.blocking_message(read, request.issue);
+  if (blocked !== void 0) return report_busy(blocked);
+  const code = await run_ship_lap.timed("take_tree", async () => take_tree(target, request, read));
+  if (code === SUCCESS_EXIT_CODE) run_maintenance.sweep();
+  return code;
+}
+function remove_record(target, was_present) {
+  run_hold.release_hold(target);
+  console.info(was_present ? RELEASED_VERDICT : NONE_VERDICT);
+  return SUCCESS_EXIT_CODE;
+}
+function report_held(hold) {
+  return report(run_hold.foreign_release_message(hold), HELD_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_unreadable_record() {
+  return report(run_hold.unreadable_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+}
+function release_record(target, claimant) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "free") return remove_record(target, false);
+  if (read.kind === "unreadable") return report_unreadable_record();
+  if (!run_hold.is_own_hold(read.hold, claimant)) return report_held(read.hold);
+  return remove_record(target, true);
+}
+async function release(target, claimant) {
+  const code = release_record(target, claimant);
+  const is_own_end = code === SUCCESS_EXIT_CODE && claimant !== run_hold.UNNUMBERED_ISSUE;
+  if (is_own_end) await run_label.unmark(claimant);
+  return code;
+}
+function force_release(target) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "held" || read.kind === "stale") {
+    console.error(run_hold.forced_release_message(read.hold));
+  }
+  return remove_record(target, read.kind !== "free");
+}
+function report_unknown() {
+  return report(run_hold.unknown_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_usage() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE;
+}
+var SEND_BY_KIND = {
+  [HALFRUN_STOP_KIND]: run_stop_notify.send_halfrun,
+  [HUMAN_REVIEW_STOP_KIND]: run_stop_notify.send_human_review,
+  [PRRUN_STOP_KIND]: run_stop_notify.send_prrun
+};
+async function marked_stop(target, request) {
+  if (request.kind === HUMAN_REVIEW_STOP_KIND) {
+    await lane_state.record_change({
+      issue: request.issue,
+      state: "human-review",
+      command: "run:hold --human-review-stop"
+    });
+  }
+  await SEND_BY_KIND[request.kind](target, request.issue);
+  return report_hold();
+}
+async function e2e_refusal(request) {
+  if (request.kind === PRRUN_STOP_KIND || await test_e2e_stamp.is_current_tree()) return void 0;
+  return report(
+    "run:hold: `pnpm josh test:e2e` has not answered green on this tree \u2014 run it, then mark the stop again.",
+    E2E_OWED_VERDICT,
+    FAILURE_EXIT_CODE
+  );
+}
+async function mark_stop(target, request) {
+  const refusal = await e2e_refusal(request);
+  if (refusal !== void 0) return refusal;
+  const mark = request.kind === PRRUN_STOP_KIND ? await run_prrun_resume.mark_stop_at(target, request.issue) : run_halfrun_resume.mark_stop_at(target, request.issue);
+  if (mark === run_halfrun_resume.MARKED) return await marked_stop(target, request);
+  if (mark === run_halfrun_resume.UNREADABLE) return report_unreadable_record();
+  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
+}
+async function adopt3(target, issue) {
+  const result = await run_hold_adopt.adopt(target, issue);
+  if (result === run_hold_adopt.ADOPTED) return report_hold();
+  if (result === run_hold_adopt.UNREADABLE) return report_unreadable_record();
+  if (result === run_hold_adopt.NO_RECORD) {
+    return report(run_hold_adopt.no_record_message(issue), NONE_VERDICT, FAILURE_EXIT_CODE);
+  }
+  return report(run_hold_adopt.foreign_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE);
+}
+async function reopen_round(target, issue) {
+  const result = await run_halfrun_resume.reopen(target, issue);
+  if (result === run_halfrun_resume.MARKED) return report_hold();
+  if (result === run_halfrun_resume.UNREADABLE) return report_unreadable_record();
+  return report(run_halfrun_resume.no_stop_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE);
+}
+async function take_over(target, request) {
+  const { kind, issue } = request;
+  return kind === ADOPT_KIND ? await adopt3(target, issue) : await reopen_round(target, issue);
+}
+async function dispatch(request, target, is_linked) {
+  if (request.kind === "claim") return await claim(target, request, is_linked);
+  if (is_take_over_request(request)) return await take_over(target, request);
+  if (is_stop_request(request)) return await mark_stop(target, request);
+  if (request.kind === FORCE_RELEASE_KIND) return force_release(target);
+  return await release(target, request.claimant);
+}
+async function answer(request) {
+  const directory = await run_cli_fault.directory_of(COMMAND, run_hold.worktree_directory);
+  if (directory === void 0) return report_unknown();
+  const is_linked = await run_hold.is_linked_worktree();
+  return await dispatch(request, run_hold.hold_path(directory), is_linked);
+}
+async function run2(argv) {
+  const request = parse_request(argv);
+  if (request === void 0) return report_usage();
+  try {
+    return await answer(request);
+  } catch (error) {
+    return report(run_cli_fault.message(COMMAND, error), UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+  }
+}
+var run_hold_cli = {
+  BUSY_VERDICT,
+  HELD_VERDICT,
+  HOLD_VERDICT,
+  NONE_VERDICT,
+  RELEASED_VERDICT,
+  UNKNOWN_VERDICT,
+  USAGE,
+  parse_request,
+  run: run2
+};
+
+export {
+  stdout_on_stderr,
+  run_prrun_resume,
+  run_hold_cli
+};

package/dist/commands/chunk-GZL6ISVM.js

@@ -0,0 +1,72 @@
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-yield.ts
+var YIELD_REASON = "it gave its lane back to an earlier lane holding one of its planned files";
+var YIELD_MARK = " yielded its lane: ";
+var NAMED_ISSUE = /#([1-9]\d*)\b/gu;
+var YIELD_TEXT = {
+  name: "its own lane:plan",
+  cause: "`lane:plan` gave its lane back to an earlier lane holding one of its planned files",
+  closed_head: "Its lane was given back by `pnpm josh lane:plan` after the Issue was closed.",
+  open_head: "Gave its lane back: `pnpm josh lane:plan` found an earlier lane holding one of its planned files.",
+  open_tail: "The lane closed before any implementation edit. The Issue stays in the run: it is offered again once the holding lane ends, keeping its place in line.",
+  stays: "The Issue stays in the run: it is offered again once the holding lane ends."
+};
+var YIELD_AT_MARK = " \xB7 at: ";
+async function record_yield(issue, reason, at) {
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.NOTE,
+    `${issue_cite.plain_for("program", String(issue))}${YIELD_MARK}${reason}${YIELD_AT_MARK}${at}`
+  );
+}
+function is_yield_note(event) {
+  return event.kind === run_event_stream.EVENT_KIND.NOTE && event.text.includes(YIELD_MARK);
+}
+function is_yield(event) {
+  return event.kind === run_event_stream.EVENT_KIND.WITHDRAW && event.text.includes(` withdrawn by ${YIELD_TEXT.name}:`);
+}
+function is_deciding(event, issue) {
+  if (run_event_scope.issue_named(event) !== issue) return false;
+  if (event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH) return true;
+  return is_yield_note(event) || event.kind === run_event_stream.EVENT_KIND.WITHDRAW && !is_yield(event);
+}
+function latest_yield(events, issue) {
+  const newest = events.findLast((event) => is_deciding(event, issue));
+  return newest !== void 0 && is_yield_note(newest) ? newest : void 0;
+}
+function is_yielded(events, issue) {
+  return latest_yield(events, issue) !== void 0;
+}
+function holder_of(note) {
+  const yielder = Number(run_event_scope.issue_named(note));
+  return [...note.text.matchAll(NAMED_ISSUE)].map((match) => Number(match[1])).findLast((issue) => issue !== yielder);
+}
+function withdraw_reason(events, issue) {
+  const note = latest_yield(events, issue);
+  const holder = note === void 0 ? void 0 : holder_of(note);
+  const holding_issue = issue_cite.plain_for("program", holder ?? "");
+  return holder === void 0 ? YIELD_REASON : `yielded to ${holding_issue}, which held one of its planned files; re-queues after ${holding_issue} merges`;
+}
+var lane_yield = {
+  YIELD_REASON,
+  YIELD_TEXT,
+  holder_of,
+  is_yield,
+  is_yield_note,
+  is_yielded,
+  record_yield,
+  withdraw_reason
+};
+
+export {
+  lane_yield
+};

package/dist/commands/chunk-HALHQILI.js

@@ -0,0 +1,51 @@
+import {
+  reproduction_measure
+} from "./chunk-6TIVDEKG.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  report_format_reference
+} from "./chunk-Q6SKKQVJ.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/review/live-evidence.ts
+var EVIDENCE_HEADING = "## \u5B9F\u6A5F\u8A3C\u8DE1";
+var EVIDENCE_FORMAT = `under ${EVIDENCE_HEADING}, a backticked command followed by a fenced block holding the output it actually printed (prose such as "confirmed" is not accepted) \u2014 format: ${report_format_reference.pointer(report_format_reference.COMPLETION_REPORT_HEADING)}`;
+function verdict_for(paths, body = "") {
+  if (test_declared_logic.runtime_files(paths).length === 0) return "exempt";
+  return reproduction_measure.has_command_output(body, EVIDENCE_HEADING) ? "satisfied" : "required";
+}
+async function assert_checked_out(branch_name) {
+  const current = await git_command.branch();
+  if (current === branch_name) return;
+  throw new Error(
+    `The ${EVIDENCE_HEADING} check reads this checkout's diff, which is ${current}, not ${branch_name}; run followup from ${branch_name}'s checkout.`
+  );
+}
+async function check(branch_name) {
+  await assert_checked_out(branch_name);
+  const [names, body] = await Promise.all([
+    git_command.diff_main_names(),
+    git_gh_command.pr_get_body(branch_name)
+  ]);
+  return verdict_for(names.split("\n"), body);
+}
+function refusal_message() {
+  return [
+    `Merge refused: this pull request changes runtime code but its body has no ${EVIDENCE_HEADING} section.`,
+    "Run the acceptance criteria for real, then add the section:",
+    EVIDENCE_FORMAT,
+    "Update the body with `gh api -X PATCH repos/{owner}/{repo}/pulls/<N> -F body=@<path>`, then re-run."
+  ].join("\n");
+}
+var live_evidence = { EVIDENCE_FORMAT, EVIDENCE_HEADING, check, refusal_message, verdict_for };
+
+export {
+  live_evidence
+};