@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-GABDPTDK.js

@@ -1,907 +0,0 @@
-import {
-  test_pinned,
-  test_pinned_ledger,
-  test_pinned_record
-} from "./chunk-J3PCRUVY.js";
-import {
-  run_ship_planned
-} from "./chunk-PKXTISWR.js";
-import {
-  gate_skip
-} from "./chunk-F57LACNC.js";
-import {
-  test_pinned_logic
-} from "./chunk-RAQ3E6OT.js";
-import {
-  review_finding_ledger
-} from "./chunk-KVURNO74.js";
-import {
-  observation_ledger_home
-} from "./chunk-QXBOECGL.js";
-import {
-  review_stamps
-} from "./chunk-S5GX3H4P.js";
-import {
-  gate_tree,
-  review_tree
-} from "./chunk-R36VZIKU.js";
-import {
-  file_map_stamp
-} from "./chunk-M32UPB2D.js";
-import {
-  run_record_path
-} from "./chunk-WL5JHB3I.js";
-import {
-  core_budget,
-  core_priority
-} from "./chunk-ZCHZU6NX.js";
-import {
-  run_ship_detach
-} from "./chunk-FJM2HWKW.js";
-import {
-  detached_launch
-} from "./chunk-HDVSZ6CZ.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-KIS7JFNP.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-IXZZSST7.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) };
-}
-var run_review_pinned_accepted = { RECORD_NAME, judge, keep_reason, recorded_reason };
-
-// 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
-};