@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-UN6BPKQ5.js

@@ -0,0 +1,922 @@
+import {
+  test_pinned,
+  test_pinned_ledger,
+  test_pinned_record
+} from "./chunk-K3LHBJDY.js";
+import {
+  run_ship_planned
+} from "./chunk-QGTLTPXT.js";
+import {
+  gate_skip
+} from "./chunk-WKXMY7MW.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  test_pinned_logic
+} from "./chunk-I36PDO6I.js";
+import {
+  observation_ledger_home
+} from "./chunk-N5FT5LYP.js";
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  gate_tree,
+  review_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  core_budget,
+  core_priority
+} from "./chunk-TWI7UTVE.js";
+import {
+  run_ship_detach
+} from "./chunk-Z7C2O5JC.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  GATE_COMMAND
+} from "./chunk-TBIX5FRN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_location_environment
+} from "./chunk-B77ZMVHS.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/gate/check-related-unplanned.ts
+async function read_unplanned() {
+  try {
+    return await run_ship_planned.unplanned();
+  } catch (error) {
+    error_text.trace_swallowed("check_related_unplanned.notice", error);
+    return void 0;
+  }
+}
+async function notice() {
+  const found = await read_unplanned();
+  if (found === void 0) return void 0;
+  await lane_ledger_write.record_unplanned_notice({ issue: found.issue, files: [...found.files] });
+  return found.text;
+}
+async function show() {
+  const text = await notice();
+  if (text !== void 0) console.info(text);
+}
+var check_related_unplanned = { notice, read_unplanned, show };
+
+// scripts/run/review/run-review-pinned.ts
+var UNPINNED_OK_FLAG = "--unpinned-ok";
+var OK_ARGUMENT_COUNT = 2;
+var STOP_NOTE = 'Pin each unpinned place with a test that turns red without it, then re-run `pnpm josh run:review`; for a change no test can pin, leave the tree as it is and pass the reason with `pnpm josh run:review --unpinned-ok "<reason>"` \u2014 on this tree and a green gate it judges this answer (or, cut at its first unpinned place, checks the whole change) and re-runs neither the gate nor the pair (`pnpm josh ship --review` forwards it).';
+function ok_reason_of(argv) {
+  const [flag, reason = ""] = argv;
+  if (flag !== UNPINNED_OK_FLAG || argv.length !== OK_ARGUMENT_COUNT) return void 0;
+  return reason.trim() === "" ? void 0 : reason;
+}
+function verdict_of(summary, reason) {
+  const { report_text } = test_pinned_logic;
+  if (summary.unpinned.length === 0) {
+    return summary.is_unchecked === true ? { kind: "unchecked", text: report_text(summary, test_pinned_record.UNCHECKED_NOTE) } : { kind: "clear", text: report_text(summary) };
+  }
+  if (reason === void 0) return { kind: "stop", text: report_text(summary, `${STOP_NOTE}
+`) };
+  const note = `Unpinned accepted by the implementer: ${reason}
+`;
+  return { kind: "accepted", text: report_text(summary, note) };
+}
+var run_review_pinned = { STOP_NOTE, UNPINNED_OK_FLAG, ok_reason_of, verdict_of };
+
+// scripts/run/review/run-review-pinned-accepted.ts
+import path from "node:path";
+var RECORD_NAME = "josh-unpinned-ok.json";
+var RECORDED_NOTE = "Unpinned accepted by an earlier run on this branch: ";
+async function record_path() {
+  const [git_directory] = await git_command.git_directories();
+  return git_directory === void 0 ? void 0 : path.join(git_directory, RECORD_NAME);
+}
+async function write(reason, unpinned) {
+  const target = await record_path();
+  if (target === void 0) return;
+  stamp_file.replace_stamp(target, { branch: await git_command.branch(), reason, unpinned });
+}
+function to_accepted(record) {
+  const { branch, reason, unpinned } = record;
+  if (typeof branch !== "string" || typeof reason !== "string") return void 0;
+  return test_pinned_record.is_text_list(unpinned) ? { branch, reason, unpinned } : void 0;
+}
+function read_record(target) {
+  const raw = target === void 0 ? void 0 : stamp_file.read_stamp_text(target);
+  const record = raw === void 0 ? void 0 : test_pinned_record.parsed(raw);
+  return record === void 0 ? void 0 : to_accepted(record);
+}
+async function recorded() {
+  const accepted = read_record(await record_path());
+  return accepted?.branch === await git_command.branch() ? accepted : void 0;
+}
+function covering_reason(accepted, unpinned) {
+  const known = new Set(accepted?.unpinned);
+  return unpinned.every((site) => known.has(site)) ? accepted?.reason : void 0;
+}
+async function remember(reason, unpinned) {
+  try {
+    await write(reason, unpinned);
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_accepted.remember", error);
+  }
+}
+async function keep_reason(reason) {
+  try {
+    const accepted = await recorded();
+    await write(reason, accepted?.unpinned ?? []);
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_accepted.keep_reason", error);
+  }
+}
+async function earlier_reason(unpinned) {
+  try {
+    return covering_reason(await recorded(), unpinned);
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_accepted.earlier_reason", error);
+    return void 0;
+  }
+}
+async function recorded_reason() {
+  try {
+    const accepted = await recorded();
+    return accepted?.reason;
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_accepted.recorded_reason", error);
+    return void 0;
+  }
+}
+async function judge(summary, reason) {
+  if (summary.unpinned.length === 0) return run_review_pinned.verdict_of(summary, reason);
+  if (reason !== void 0) {
+    await remember(reason, summary.unpinned);
+    return run_review_pinned.verdict_of(summary, reason);
+  }
+  const earlier = summary.is_cut === true ? void 0 : await earlier_reason(summary.unpinned);
+  if (earlier === void 0) return run_review_pinned.verdict_of(summary, void 0);
+  const note = `${RECORDED_NOTE}${earlier}
+`;
+  return { kind: "accepted", text: test_pinned_logic.report_text(summary, note) };
+}
+function stop_path(summary, reason) {
+  if (reason === void 0) return "no-reason";
+  return summary.is_cut === true ? "truncated" : "new-site";
+}
+async function unpinned_stop(summary) {
+  const stop = { path: stop_path(summary, await recorded_reason()), hunks: summary.unpinned.length };
+  const { is_cut, remaining } = summary;
+  return is_cut === true && remaining !== void 0 ? { ...stop, remaining } : stop;
+}
+var run_review_pinned_accepted = {
+  RECORD_NAME,
+  judge,
+  keep_reason,
+  recorded_reason,
+  unpinned_stop
+};
+
+// scripts/run/review/run-review.ts
+var ADOPT = "adopt";
+var BLOCKED = "blocked";
+function adopt_verdict(is_gate_green) {
+  return is_gate_green ? ADOPT : BLOCKED;
+}
+var GATE_GREEN = "green";
+var GATE_RUNNING = "running";
+var GATE_RED = "red";
+var GATE_MOVED = "moved";
+function gate_state(is_green, is_running, is_moved = false) {
+  if (is_green) return GATE_GREEN;
+  if (is_running) return GATE_RUNNING;
+  if (is_moved) return GATE_MOVED;
+  return GATE_RED;
+}
+var MOVED_EXIT_CODE = 2;
+var UNPINNED_EXIT_CODE = 3;
+var CODE_ONLY_FLAG = "--code-only";
+function is_gate_settled(state) {
+  return state !== GATE_RUNNING;
+}
+var SECONDS_DECIMALS = 1;
+var NO_OVERLAP = 0;
+function format_seconds(seconds) {
+  return `${seconds.toFixed(SECONDS_DECIMALS)}s`;
+}
+function span_seconds(from, to) {
+  return Math.max(NO_OVERLAP, (Date.parse(to) - Date.parse(from)) / MS_PER_SECOND);
+}
+function overlap_seconds(timing) {
+  const start2 = Math.max(Date.parse(timing.gate_started_at), Date.parse(timing.review_started_at));
+  const end = Math.min(Date.parse(timing.gate_ended_at), Date.parse(timing.review_ended_at));
+  return Math.max(NO_OVERLAP, (end - start2) / MS_PER_SECOND);
+}
+function format_timing(timing) {
+  const gate = span_seconds(timing.gate_started_at, timing.gate_ended_at);
+  const review = span_seconds(timing.review_started_at, timing.review_ended_at);
+  return [
+    `gate:    ${timing.gate_started_at} \u2192 ${timing.gate_ended_at} (${format_seconds(gate)})`,
+    `review:  ${timing.review_started_at} \u2192 ${timing.review_ended_at} (${format_seconds(review)})`,
+    `overlap: ${format_seconds(overlap_seconds(timing))}`
+  ].join("\n");
+}
+var run_review = {
+  ADOPT,
+  BLOCKED,
+  CODE_ONLY_FLAG,
+  GATE_GREEN,
+  GATE_MOVED,
+  GATE_RED,
+  GATE_RUNNING,
+  MOVED_EXIT_CODE,
+  UNPINNED_EXIT_CODE,
+  adopt_verdict,
+  format_timing,
+  gate_state,
+  is_gate_settled,
+  overlap_seconds
+};
+
+// scripts/run/review/run-review-steps.ts
+import { setTimeout as sleep } from "node:timers/promises";
+var PNPM = "pnpm";
+var DIRECTORY_FLAG = "--dir";
+var JOSH_SCRIPT = "josh";
+var GATE_LOG_PREFIX = "josh-run-review-gate-log-";
+var TIMING_PREFIX = "josh-run-review-timing-";
+var START_TREE_PREFIX = "josh-run-review-start-tree-";
+var start_tree_stamp = file_map_stamp.create(START_TREE_PREFIX, PROJECT_ROOT);
+var POLL_INTERVAL_MS = 1e3;
+var MAX_JOIN_WAIT_MS = 6e5;
+var MAX_OPEN_WAIT_MS = 42e4;
+function gate_log_path(root = PROJECT_ROOT) {
+  return stamp_file.stamp_path(GATE_LOG_PREFIX, root);
+}
+function timing_path(target = PROJECT_ROOT) {
+  return stamp_file.stamp_path(TIMING_PREFIX, target);
+}
+function josh_argv(root, josh_args) {
+  return {
+    command: PNPM,
+    args: [DIRECTORY_FLAG, root, JOSH_SCRIPT, ...josh_args]
+  };
+}
+function launch_josh(josh_args, log_path2, root = PROJECT_ROOT) {
+  return detached_launch.launch(
+    {
+      argv: josh_argv(root, josh_args),
+      cwd: root,
+      log_path: log_path2,
+      env: {
+        ...git_location_environment.location_free_environment(),
+        ...core_priority.UNMARKED_ENVIRONMENT
+      }
+    },
+    (note) => process.stderr.write(`${note}
+`)
+  );
+}
+function launch_gate(root = PROJECT_ROOT) {
+  return launch_josh([GATE_COMMAND], gate_log_path(root), root);
+}
+function to_timing(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const { gate_started_at, review_started_at } = value;
+  if (typeof gate_started_at !== "string" || typeof review_started_at !== "string") return void 0;
+  return { gate_started_at, review_started_at };
+}
+function read_timing_start(target = PROJECT_ROOT) {
+  const raw = stamp_file.read_stamp_text(timing_path(target));
+  if (raw === void 0) return void 0;
+  try {
+    return to_timing(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+function is_green_on_start_tree(base) {
+  const start2 = start_tree_stamp.read();
+  if (start2 === void 0) return false;
+  return gate_skip.reusable_green_gate(start2.files, base) !== void 0;
+}
+async function read_gate_state() {
+  const is_running = file_map_stamp.is_writer_running(review_stamps.in_flight_stamp.read());
+  const tree = await gate_tree.read_gate_tree();
+  const is_green = gate_skip.reusable_green_gate(tree.files, tree.base) !== void 0;
+  return run_review.gate_state(is_green, is_running, is_green_on_start_tree(tree.base));
+}
+async function mark_gate_starting() {
+  const tree = await review_tree.read_changed_tree();
+  review_stamps.in_flight_stamp.write(tree);
+  start_tree_stamp.write(tree);
+}
+async function wait_for_gate_finish(max_wait_ms = MAX_JOIN_WAIT_MS, now = () => Date.now()) {
+  const started = now();
+  let state = await read_gate_state();
+  await poll.poll_until(() => run_review.is_gate_settled(state) || now() - started >= max_wait_ms, {
+    attempts: Infinity,
+    interval_ms: POLL_INTERVAL_MS,
+    sleeper: async (milliseconds) => {
+      await sleep(milliseconds);
+      state = await read_gate_state();
+    }
+  });
+  return state;
+}
+function read_gate_log(root = PROJECT_ROOT) {
+  return stamp_file.read_stamp_text(gate_log_path(root));
+}
+function write_timing_start(start2, target = PROJECT_ROOT) {
+  stamp_file.write_stamp(timing_path(target), start2);
+}
+function complete_timing(ended, target = PROJECT_ROOT) {
+  const start2 = read_timing_start(target);
+  if (start2 === void 0) return void 0;
+  return { ...start2, ...ended };
+}
+var run_review_steps = {
+  MAX_JOIN_WAIT_MS,
+  MAX_OPEN_WAIT_MS,
+  POLL_INTERVAL_MS,
+  complete_timing,
+  gate_log_path,
+  launch_gate,
+  launch_josh,
+  mark_gate_starting,
+  read_gate_log,
+  read_gate_state,
+  read_timing_start,
+  start_tree_stamp,
+  timing_path,
+  wait_for_gate_finish,
+  write_timing_start
+};
+
+// scripts/run/review/run-review-pinned-steps.ts
+import { randomUUID } from "node:crypto";
+import { setTimeout as sleep2 } from "node:timers/promises";
+var PINNED_COMMAND = "test:pinned";
+var REMAINING_ORIGIN = "pre-detach";
+var LAUNCH_PREFIX = "josh-run-review-pinned-launch-";
+var LOG_PREFIX = "josh-run-review-pinned-log-";
+var MS_PER_SECOND2 = 1e3;
+var LOST_NOTE = "its process ended without an answer";
+var STOP_SIGNAL = "SIGTERM";
+var GRACE_MS = 12e4;
+var READ_COMMAND = "pnpm josh run:review --pinned";
+var STILL_RUNNING_NOTE = `it is still running on this tree; wait for its answer with \`${READ_COMMAND}\` (a lane child: the ship's pre-detach reads it)`;
+var TIMED_OUT_NOTE = `no answer within ${String(GRACE_MS / MS_PER_SECOND2)}s of the gate and the review`;
+var QUEUED_NOTE = "it was still waiting for cores when the gate and the review ended";
+var FIXING_NOTE = "round 1 has fixes to make \u2014 it is left running, and the round's `josh review:record` starts it again on the fixed tree for the ship's pre-detach to read";
+var ALONE_GRACE_MS = 9e5;
+var ALONE_TIMED_OUT_NOTE = `no answer within ${String(ALONE_GRACE_MS / MS_PER_SECOND2)}s of the read`;
+function launch_path(root = PROJECT_ROOT) {
+  return stamp_file.stamp_path(LAUNCH_PREFIX, root);
+}
+function log_path(root = PROJECT_ROOT) {
+  return stamp_file.stamp_path(LOG_PREFIX, root, ".log");
+}
+function launch_with({ root, token, argv, origin, reason, tree }) {
+  const launched = run_review_steps.launch_josh(argv, log_path(root), root);
+  if (launched.kind === "launched") {
+    const { pid } = launched;
+    stamp_file.write_stamp(launch_path(root), {
+      pid,
+      token,
+      reason,
+      start: process_identity.read_start(pid),
+      tree,
+      launched_at: Date.now(),
+      origin
+    });
+  }
+  return launched;
+}
+function launch(root = PROJECT_ROOT, reason, tree) {
+  const token = randomUUID();
+  const origin = test_pinned_ledger.BACKGROUND_ORIGIN;
+  const argv = test_pinned_record.launch_argv(token, reason, origin);
+  return launch_with({ root, token, argv, origin, reason, tree });
+}
+function launch_remaining(root = PROJECT_ROOT, tree) {
+  const token = randomUUID();
+  const origin = REMAINING_ORIGIN;
+  const argv = test_pinned_record.launch_argv(token, void 0, origin, true);
+  return launch_with({ root, token, argv, origin, tree });
+}
+function optional_text(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function origin_of(value) {
+  return typeof value === "string" ? test_pinned_ledger.origin_of(value) : void 0;
+}
+function to_launch(value) {
+  const { pid, token, reason, start: start2, tree, launched_at, origin } = value;
+  if (typeof pid !== "number" || typeof token !== "string") return void 0;
+  return {
+    pid,
+    token,
+    reason: optional_text(reason),
+    start: optional_text(start2),
+    tree: optional_text(tree),
+    launched_at: typeof launched_at === "number" ? launched_at : void 0,
+    origin: origin_of(origin)
+  };
+}
+function read_launch(root) {
+  const raw = stamp_file.read_stamp_text(launch_path(root));
+  if (raw === void 0) return void 0;
+  try {
+    return to_launch(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+function read_answer(root, { pid, token, start: start2 }) {
+  const summary = test_pinned_record.read(token, root);
+  if (summary !== void 0) return summary;
+  if (process_identity.is_same_process(pid, start2) !== false) return void 0;
+  return test_pinned_record.read(token, root) ?? test_pinned_record.not_run_summary(new Error(LOST_NOTE));
+}
+function signal_group(pid) {
+  try {
+    process.kill(-pid, STOP_SIGNAL);
+  } catch {
+  }
+}
+function discard(launched) {
+  signal_group(launched.pid);
+  if (launched.launched_at === void 0) return;
+  void test_pinned_ledger.record_discarded(Date.now() - launched.launched_at, launched.origin);
+}
+function stop_last(launched) {
+  if (process_identity.is_same_process(launched.pid, launched.start) === true) discard(launched);
+}
+function stop_current(launched) {
+  if (process_identity.is_same_process(launched.pid, launched.start) !== false) discard(launched);
+}
+function clear(root = PROJECT_ROOT) {
+  const last = read_launch(root);
+  if (last !== void 0) {
+    stop_last(last);
+    test_pinned_record.clear(last.token, root);
+  }
+  stamp_file.remove_stamp(launch_path(root));
+}
+function is_queued(root) {
+  return core_budget.live_reservations().some(
+    ({ reservation }) => reservation.command === PINNED_COMMAND && reservation.checkout === root && reservation.admitted_at === void 0
+  );
+}
+function stopped(launched, note) {
+  stop_current(launched);
+  return test_pinned_record.not_run_summary(new Error(note));
+}
+async function poll_within_grace(root, launched, now, grace_ms = GRACE_MS) {
+  const started = now();
+  let summary = read_answer(root, launched);
+  await poll.poll_until(() => summary !== void 0 || now() - started >= grace_ms, {
+    attempts: Infinity,
+    interval_ms: run_review_steps.POLL_INTERVAL_MS,
+    sleeper: async (milliseconds) => {
+      await sleep2(milliseconds);
+      summary = read_answer(root, launched);
+    }
+  });
+  return summary;
+}
+function given_up(launched, note, is_left_running) {
+  if (!is_left_running) return stopped(launched, note);
+  return test_pinned_record.not_run_summary(new Error(`${note} \u2014 ${STILL_RUNNING_NOTE}`));
+}
+async function poll_answer(root, launched, now, is_left_running) {
+  const summary = read_answer(root, launched);
+  if (summary !== void 0) return summary;
+  if (is_queued(root)) return given_up(launched, QUEUED_NOTE, is_left_running);
+  const late = await poll_within_grace(root, launched, now);
+  return late ?? given_up(launched, TIMED_OUT_NOTE, is_left_running);
+}
+function launched_reason(root = PROJECT_ROOT) {
+  return read_launch(root)?.reason;
+}
+function carry_reason(reason, root = PROJECT_ROOT) {
+  const launched = read_launch(root);
+  if (launched !== void 0) stamp_file.write_stamp(launch_path(root), { ...launched, reason });
+}
+function launched_tree(root = PROJECT_ROOT) {
+  return read_launch(root)?.tree;
+}
+function is_remaining(root = PROJECT_ROOT) {
+  return read_launch(root)?.origin === REMAINING_ORIGIN;
+}
+async function wait_for_answer(root = PROJECT_ROOT, now = () => Date.now(), is_left_running = true) {
+  const launched = read_launch(root);
+  if (launched === void 0) return void 0;
+  return await poll_answer(root, launched, now, is_left_running);
+}
+function answer_now(root = PROJECT_ROOT, pending_note = FIXING_NOTE) {
+  const launched = read_launch(root);
+  if (launched === void 0) return void 0;
+  return read_answer(root, launched) ?? test_pinned_record.not_run_summary(new Error(pending_note));
+}
+function is_answered(root = PROJECT_ROOT) {
+  const launched = read_launch(root);
+  return launched !== void 0 && test_pinned_record.read(launched.token, root) !== void 0;
+}
+function is_pending(root = PROJECT_ROOT) {
+  const launched = read_launch(root);
+  return launched !== void 0 && read_answer(root, launched) === void 0;
+}
+function is_live(root = PROJECT_ROOT) {
+  const launched = read_launch(root);
+  return launched !== void 0 && process_identity.is_same_process(launched.pid, launched.start) === true;
+}
+async function wait_alone(root = PROJECT_ROOT, now = () => Date.now()) {
+  const launched = read_launch(root);
+  if (launched === void 0) return void 0;
+  const summary = await poll_within_grace(root, launched, now, ALONE_GRACE_MS);
+  return summary ?? stopped(launched, ALONE_TIMED_OUT_NOTE);
+}
+var run_review_pinned_steps = {
+  FIXING_NOTE,
+  answer_now,
+  carry_reason,
+  clear,
+  is_answered,
+  is_live,
+  is_pending,
+  is_remaining,
+  launch,
+  launch_remaining,
+  launched_reason,
+  launched_tree,
+  log_path,
+  wait_alone,
+  wait_for_answer
+};
+
+// scripts/run/review/run-review-pinned-tree.ts
+import { createHash } from "node:crypto";
+function digest_of({ files, base }) {
+  const entries = Object.entries(files);
+  if (base === void 0 || entries.length === 0) return void 0;
+  const code = entries.filter(([file]) => !run_record_path.is_run_record(file)).toSorted(([left], [right]) => left.localeCompare(right));
+  return createHash("sha256").update(JSON.stringify([base, code])).digest("hex");
+}
+async function key() {
+  return digest_of(await gate_tree.read_gate_tree());
+}
+var run_review_pinned_tree = { digest_of, key };
+
+// scripts/run/review/run-review-pinned-join.ts
+import { setTimeout as sleep3 } from "node:timers/promises";
+var PENDING_NOTE = "`josh test:pinned` is still running; the hunks below are unpinned by the verdicts it already reached; the round is not stopped on them:";
+var RESTARTED_NOTE = "started again on the moved tree \u2014 it is left running for the ship's pre-detach to read";
+async function moved_tree(root) {
+  const launched = run_review_pinned_steps.launched_tree(root);
+  if (launched === void 0) return void 0;
+  const current = await run_review_pinned_tree.key();
+  return current === launched ? void 0 : current;
+}
+function restart(root, tree) {
+  const reason = run_review_pinned_steps.launched_reason(root);
+  run_review_pinned_steps.clear(root);
+  return run_review_pinned_steps.launch(root, reason, tree).kind === "launched";
+}
+async function restart_if_moved(root = PROJECT_ROOT) {
+  const tree = await moved_tree(root);
+  return tree !== void 0 && restart(root, tree);
+}
+async function is_restarted(root) {
+  try {
+    return await restart_if_moved(root);
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_join.is_restarted", error);
+    return false;
+  }
+}
+async function cached_summary() {
+  try {
+    const report = await test_pinned.cached(test_pinned_logic.DEFAULT_MAX_HUNKS);
+    return report.unpinned.length === 0 && !test_pinned_logic.has_unchecked(report) ? void 0 : test_pinned_record.partial_summary(report, PENDING_NOTE);
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_join.cached_summary", error);
+    return void 0;
+  }
+}
+async function fixing_answer(root, note) {
+  const cached = run_review_pinned_steps.is_pending(root) ? await cached_summary() : void 0;
+  return cached ?? run_review_pinned_steps.answer_now(root, note);
+}
+async function graceless_note(root, is_fixing) {
+  const is_fresh = await is_restarted(root);
+  if (is_fixing) return run_review_pinned_steps.FIXING_NOTE;
+  return is_fresh ? RESTARTED_NOTE : void 0;
+}
+async function wait_for_join(root = PROJECT_ROOT, now, is_fixing = false) {
+  if (run_ship_detach.is_supervised()) {
+    return await run_review_pinned_steps.wait_for_answer(root, now, false);
+  }
+  const note = await graceless_note(root, is_fixing);
+  return note === void 0 ? await run_review_pinned_steps.wait_for_answer(root, now) : await fixing_answer(root, note);
+}
+async function is_launched_on_current_tree(root) {
+  const launched = run_review_pinned_steps.launched_tree(root);
+  if (launched === void 0) return false;
+  try {
+    return launched === await run_review_pinned_tree.key();
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_join.is_launched_on_current_tree", error);
+    return false;
+  }
+}
+async function waited_answer(root) {
+  const summary = await run_review_pinned_steps.wait_alone(root);
+  return run_review_pinned_steps.is_answered(root) ? summary : void 0;
+}
+async function settle_elsewhere(root) {
+  if (run_review_pinned_steps.is_live(root)) await run_review_pinned_steps.wait_alone(root);
+  run_review_pinned_steps.clear(root);
+}
+async function answer_on_tree(root = PROJECT_ROOT) {
+  if (await is_launched_on_current_tree(root)) return await waited_answer(root);
+  await settle_elsewhere(root);
+  return void 0;
+}
+async function finished_on_tree(root = PROJECT_ROOT) {
+  if (!run_review_pinned_steps.is_answered(root)) return void 0;
+  return await is_launched_on_current_tree(root) ? run_review_pinned_steps.answer_now(root) : void 0;
+}
+async function poll_pause() {
+  await sleep3(run_review_steps.POLL_INTERVAL_MS);
+}
+function is_ended(root) {
+  return run_review_pinned_steps.is_answered(root) || !run_review_pinned_steps.is_live(root);
+}
+async function is_coming_on_tree(root) {
+  return !is_ended(root) && await is_launched_on_current_tree(root);
+}
+async function wait_on_tree(root, is_within, pause) {
+  await poll.poll_until(async () => !is_within() || !await is_coming_on_tree(root), {
+    attempts: Infinity,
+    interval_ms: run_review_steps.POLL_INTERVAL_MS,
+    sleeper: pause
+  });
+}
+async function settled_on_tree(root, grace_ms, now = () => Date.now(), pause = poll_pause) {
+  const started = now();
+  await wait_on_tree(root, () => now() - started < grace_ms, pause);
+  return await finished_on_tree(root);
+}
+var run_review_pinned_join = {
+  answer_on_tree,
+  finished_on_tree,
+  restart_if_moved,
+  settled_on_tree,
+  wait_for_join
+};
+
+// scripts/run/review/run-review-pinned-remaining.ts
+var MOVED_NOTE = "the tree moved while collecting remaining verdicts";
+async function is_current(tree) {
+  return tree !== void 0 && tree === await run_review_pinned_tree.key();
+}
+async function start(root = PROJECT_ROOT) {
+  try {
+    const tree = await run_review_pinned_tree.key();
+    if (tree === void 0) return { kind: "failed", note: "could not read the current tree" };
+    run_review_pinned_steps.clear(root);
+    return run_review_pinned_steps.launch_remaining(root, tree);
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_remaining.start", error);
+    return { kind: "failed", note: String(error) };
+  }
+}
+function is_failed(summary) {
+  return summary?.counts === void 0 && summary?.is_unchecked === true;
+}
+async function recover_failed(summary, root) {
+  try {
+    const report = await test_pinned.cached(test_pinned_logic.DEFAULT_MAX_HUNKS);
+    if (report.is_stale === true || report.unpinned.length === 0) return summary;
+    const known = test_pinned_record.summary_of(report, root);
+    return { ...known, is_cut: true, is_unchecked: true, text: `${known.text}${summary.text}` };
+  } catch (error) {
+    error_text.trace_swallowed("run_review_pinned_remaining.recover_failed", error);
+    return summary;
+  }
+}
+async function current_answer(root) {
+  const summary = await run_review_pinned_steps.wait_alone(root);
+  const tree = await run_review_pinned_tree.key();
+  if (tree === void 0 || run_review_pinned_steps.launched_tree(root) !== tree) {
+    return test_pinned_record.not_run_summary(MOVED_NOTE);
+  }
+  const answer = is_failed(summary) ? await recover_failed(summary, root) : summary;
+  return await is_current(tree) ? answer : test_pinned_record.not_run_summary(MOVED_NOTE);
+}
+async function relaunched_answer(root) {
+  const launched = await start(root);
+  return launched.kind === "launched" ? await current_answer(root) : test_pinned_record.not_run_summary(launched.note);
+}
+async function read(root = PROJECT_ROOT) {
+  if (!run_review_pinned_steps.is_remaining(root)) return void 0;
+  if (run_review_pinned_steps.launched_tree(root) === await run_review_pinned_tree.key()) {
+    return await current_answer(root);
+  }
+  return await run_review_pinned_join.answer_on_tree(root) ?? await relaunched_answer(root);
+}
+function incomplete(summary) {
+  return {
+    ...summary,
+    text: `${summary.text}Remaining probe incomplete: no current-tree answer
+`
+  };
+}
+function collected(summary, answer) {
+  if (answer === void 0) return incomplete(summary);
+  return answer.counts === void 0 && answer.is_unchecked === true ? { ...summary, text: `${summary.text}${answer.text}` } : answer;
+}
+function is_collectable(summary, root) {
+  return summary.is_cut === true && run_review_pinned_steps.launched_reason(root) === void 0;
+}
+async function collect_current(summary, root) {
+  const tree = await run_review_pinned_tree.key();
+  const answer = await read(root) ?? await relaunched_answer(root);
+  return await is_current(tree) ? collected(summary, answer) : test_pinned_record.not_run_summary(MOVED_NOTE);
+}
+async function collect(summary, root = PROJECT_ROOT) {
+  return summary !== void 0 && is_collectable(summary, root) ? await collect_current(summary, root) : summary;
+}
+var run_review_pinned_remaining = { collect, read, start };
+
+// scripts/run/review/run-review-join-read.ts
+var DUE_PREFIX = "josh-run-review-join-due-";
+function due_path(root) {
+  return stamp_file.stamp_path(DUE_PREFIX, root);
+}
+function mark_due(root = PROJECT_ROOT) {
+  try {
+    stamp_file.replace_stamp(due_path(root), { due: true });
+  } catch (error) {
+    error_text.trace_swallowed("run_review_join_read.mark_due", error);
+  }
+}
+function is_due(root = PROJECT_ROOT) {
+  return stamp_file.read_stamp_text(due_path(root)) !== void 0;
+}
+async function verdict(wait) {
+  const summary = await wait();
+  if (summary === void 0) return void 0;
+  if (summary.is_partial === true) {
+    return { summary, is_stop: false, text: test_pinned_logic.report_text(summary) };
+  }
+  const judged = await run_review_pinned_accepted.judge(
+    summary,
+    run_review_pinned_steps.launched_reason()
+  );
+  return { summary, is_stop: judged.kind === "stop", text: judged.text };
+}
+async function read_with(wait, root = PROJECT_ROOT) {
+  stamp_file.remove_stamp(due_path(root));
+  return await verdict(wait);
+}
+async function read2(root = PROJECT_ROOT, is_fixing = false) {
+  return await read_with(
+    async () => await run_review_pinned_remaining.collect(
+      await run_review_pinned_join.wait_for_join(root, void 0, is_fixing),
+      root
+    ),
+    root
+  );
+}
+async function read_finished(root = PROJECT_ROOT) {
+  return await read_with(
+    async () => await run_review_pinned_remaining.read(root) ?? await run_review_pinned_remaining.collect(
+      await run_review_pinned_join.finished_on_tree(root),
+      root
+    ),
+    root
+  );
+}
+async function read_remaining() {
+  return await read_with(
+    async () => await run_review_pinned_remaining.read() ?? await run_review_pinned_remaining.collect(await run_review_pinned_steps.wait_alone())
+  );
+}
+var run_review_join_read = {
+  is_due,
+  mark_due,
+  read: read2,
+  read_finished,
+  read_remaining,
+  read_with,
+  verdict
+};
+
+// scripts/review/review-record-pinned.ts
+function started_line() {
+  return `test:pinned restarted in the background on the tree this round's fixes moved. Where it names unpinned places, the ship's pre-detach stops on them: pin each with a test that turns red without it, or ship with \`--unpinned-ok "<reason>"\`.`;
+}
+async function restart_if_moved2(root = PROJECT_ROOT) {
+  try {
+    const is_started = await run_review_pinned_join.restart_if_moved(root);
+    if (is_started) console.info(started_line());
+    return is_started;
+  } catch (error) {
+    error_text.trace_swallowed("review_record_pinned.restart_if_moved", error);
+    return false;
+  }
+}
+var CHOICE_LINE = 'Unpinned before the ship: pin each place above with a test that turns red without it, or ship with `--unpinned-ok "<reason>"`.\n';
+function show_stop(joined) {
+  if (joined === void 0) return;
+  const text = joined.is_stop ? test_pinned_logic.report_text(joined.summary, CHOICE_LINE) : joined.text;
+  if (joined.is_stop || [joined.summary.is_unchecked, joined.summary.is_partial].includes(true)) {
+    console.info(text.trimEnd());
+  }
+}
+async function read_skipped_join(root = PROJECT_ROOT) {
+  try {
+    if (run_review_join_read.is_due(root) || run_review_pinned_steps.is_remaining(root)) {
+      show_stop(await run_review_join_read.read_finished(root));
+    }
+  } catch (error) {
+    error_text.trace_swallowed("review_record_pinned.read_skipped_join", error);
+  }
+  await check_related_unplanned.show();
+}
+async function is_round_recorded(root) {
+  const issue = lane_child_marker.marked_issue();
+  if (issue === void 0) return false;
+  const content = await observation_ledger_home.read(root);
+  return content !== void 0 && review_finding_ledger.has_issue_record(content, Number(issue));
+}
+async function is_restartable_before_record(root) {
+  if (!lane_child_marker.is_child_of(root) || run_ship_detach.is_supervised()) return false;
+  return !await is_round_recorded(root);
+}
+async function restart_in_lane(root = PROJECT_ROOT) {
+  try {
+    return await is_restartable_before_record(root) && await restart_if_moved2(root);
+  } catch (error) {
+    error_text.trace_swallowed("review_record_pinned.restart_in_lane", error);
+    return false;
+  }
+}
+var review_record_pinned = {
+  CHOICE_LINE,
+  read_skipped_join,
+  restart_if_moved: restart_if_moved2,
+  restart_in_lane,
+  started_line
+};
+
+export {
+  check_related_unplanned,
+  run_review_pinned,
+  run_review_pinned_accepted,
+  GATE_GREEN,
+  run_review,
+  run_review_steps,
+  run_review_pinned_steps,
+  run_review_pinned_tree,
+  run_review_pinned_join,
+  run_review_pinned_remaining,
+  run_review_join_read,
+  review_record_pinned
+};