@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-ZGBXUY7R.js

@@ -0,0 +1,198 @@
+import {
+  review_round_one_blobs
+} from "./chunk-JGX7JIW4.js";
+import {
+  review_round2
+} from "./chunk-T6JUDQMW.js";
+import {
+  path_decision
+} from "./chunk-JI2EGXZX.js";
+import {
+  review_attest,
+  review_checkout
+} from "./chunk-URZ4RDC4.js";
+import {
+  moved_paths
+} from "./chunk-PBAEJ5PT.js";
+import {
+  review_stamps
+} from "./chunk-XSKJAG72.js";
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  release_approval_prune
+} from "./chunk-QSJCZATC.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-reviewed-tree.ts
+var LINE_SUFFIX = /:\d+(?:-\d+)?$/u;
+var UNSETTLED_DIGEST = "unsettled";
+function settled_files(files, unsettled) {
+  const cited = unsettled.map((file) => [
+    file.replace(LINE_SUFFIX, ""),
+    UNSETTLED_DIGEST
+  ]);
+  return { ...files, ...Object.fromEntries(cited) };
+}
+async function record(unsettled = []) {
+  try {
+    const { files, base } = await gate_tree.read_gate_tree();
+    const blobs = review_round_one_blobs.capture(Object.keys(files));
+    review_stamps.reviewed_stamp.write(settled_files(files, unsettled), void 0, base, blobs);
+  } catch {
+  }
+}
+function is_rerecorded_approval(stamp, path) {
+  return release_approval_prune.is_approval(path) && stamp.files[path] !== UNSETTLED_DIGEST;
+}
+function is_pinning_test(stamp, tree, path) {
+  const is_settled = Object.hasOwn(tree.files, path) && stamp.files[path] !== UNSETTLED_DIGEST;
+  return is_settled && test_declared_logic.is_test_file(path);
+}
+function is_no_move(stamp, tree, path) {
+  return is_rerecorded_approval(stamp, path) || is_pinning_test(stamp, tree, path);
+}
+var MOVEMENT = { DELTA: "delta", HELD: "held", UNSETTLED: "unsettled" };
+var UNEXECUTED_NOTE = "passed over documentation, a prompt or an inert path no round executes";
+var CAUSE = {
+  NO_RECORD: "no reviewed tree was recorded",
+  SKIPPED: "a move round 2 would not read \u2014 a revert to the briefed bytes, a file outside the change, or documentation, a prompt or an inert path a recorded High cites",
+  SYNCED: "the default branch changed a file the round covers",
+  UNFIXED: "a file a recorded High cites still holds its round-1 brief bytes, so no fix is in round 2's delta",
+  UNATTESTED: "the round was not attested on this branch",
+  UNREAD: "git did not answer"
+};
+function unsettled_by(cause, path) {
+  return { movement: MOVEMENT.UNSETTLED, cause: path === void 0 ? cause : `${cause}: ${path}` };
+}
+function is_carry_candidate(stamp, path) {
+  const is_settled = Object.hasOwn(stamp.files, path) && stamp.files[path] !== UNSETTLED_DIGEST;
+  return is_settled && review_round2.is_unexecuted(path, []);
+}
+function carry(stamp, tree, parts) {
+  const candidates = parts.synced.filter((path) => is_carry_candidate(stamp, path));
+  const { blobs, base: from } = stamp;
+  const answers = candidates.length === 0 ? void 0 : review_round_one_blobs.carried_each({ blobs, from, to: tree.base, paths: candidates });
+  if (answers === void 0) return { passed: [], noted: [] };
+  return {
+    passed: candidates.filter((path) => answers[path] !== false),
+    noted: candidates.filter((path) => answers[path] === void 0)
+  };
+}
+function moved_files(stamp, tree, parts) {
+  return parts.changed.filter((path) => !is_no_move(stamp, tree, path));
+}
+function is_unexecuted_move(stamp, path) {
+  return stamp.files[path] !== UNSETTLED_DIGEST && review_round2.is_unexecuted(path, []);
+}
+function unexecuted_note(paths) {
+  if (paths.length === 0) return void 0;
+  return `${UNEXECUTED_NOTE}: ${path_decision.format_path_list(paths)}`;
+}
+function is_read_by_round_two(path, tree, briefed) {
+  if (review_round2.is_unexecuted(path, [])) return false;
+  return briefed?.files[path] !== tree.files[path];
+}
+function unread_cause(stamp, path) {
+  const is_cited = stamp.files[path] === UNSETTLED_DIGEST;
+  return is_cited && !review_round2.is_unexecuted(path, []) ? CAUSE.UNFIXED : CAUSE.SKIPPED;
+}
+function moved_standing(stamp, moved, tree, briefed) {
+  if (moved.length === 0) return { movement: MOVEMENT.HELD };
+  const unread = moved.find((path) => !is_read_by_round_two(path, tree, briefed));
+  if (unread === void 0) return { movement: MOVEMENT.DELTA };
+  return unsettled_by(unread_cause(stamp, unread), unread);
+}
+function noted_standing(stamp, moved, tree, briefed) {
+  const unexecuted = moved.filter((path) => is_unexecuted_move(stamp, path));
+  const read = moved.filter((path) => !unexecuted.includes(path));
+  const answer = moved_standing(stamp, read, tree, briefed);
+  const note = unexecuted_note(unexecuted);
+  return note === void 0 || answer.movement === MOVEMENT.UNSETTLED ? answer : { ...answer, note };
+}
+async function standing(stamp, tree, briefed) {
+  const parts = await moved_paths.moved_parts(stamp, tree);
+  if (parts === void 0) return unsettled_by(CAUSE.UNREAD);
+  const { passed, noted } = carry(stamp, tree, parts);
+  const synced = parts.synced.find(
+    (path) => Object.hasOwn(stamp.files, path) && !passed.includes(path)
+  );
+  if (synced !== void 0) return unsettled_by(CAUSE.SYNCED, synced);
+  const moved = moved_files(stamp, tree, parts).filter((path) => !passed.includes(path));
+  return noted_standing(stamp, [...moved, ...noted], tree, briefed);
+}
+async function movement(stamp, tree, briefed) {
+  const answer = await standing(stamp, tree, briefed);
+  return answer.movement;
+}
+async function is_unmoved(stamp, tree) {
+  return await movement(stamp, tree) === MOVEMENT.HELD;
+}
+async function standing_here() {
+  const stamp = review_stamps.reviewed_stamp.read();
+  if (stamp === void 0) return unsettled_by(CAUSE.NO_RECORD);
+  const checkout = await review_checkout.read_checkout();
+  if (!review_attest.is_attested_on(checkout, checkout.root)) return unsettled_by(CAUSE.UNATTESTED);
+  const tree = await gate_tree.read_gate_tree();
+  return await standing(stamp, tree, review_stamps.round_one_stamp.read());
+}
+function high_cited() {
+  const files = review_stamps.reviewed_stamp.read()?.files ?? {};
+  return Object.keys(files).filter((path) => files[path] === UNSETTLED_DIGEST);
+}
+function resume_point(checkout) {
+  const stamp = review_stamps.reviewed_stamp.read();
+  if (stamp === void 0 || !review_attest.is_briefed_since(stamp.taken_at, checkout.root)) {
+    return void 0;
+  }
+  return review_attest.is_attested_on(checkout, checkout.root) ? stamp : void 0;
+}
+var STOPPED_PREFIX = "josh-review-round1-stopped-";
+function stopped_path() {
+  return stamp_file.stamp_path(STOPPED_PREFIX, PROJECT_ROOT);
+}
+function mark_stopped(issue, is_stopped) {
+  if (!is_stopped) {
+    stamp_file.remove_stamp(stopped_path());
+    return;
+  }
+  try {
+    stamp_file.write_text_stamp(stopped_path(), String(issue));
+  } catch {
+  }
+}
+function is_stopped_on(issue) {
+  return stamp_file.read_stamp_text(stopped_path()) === String(issue);
+}
+function discard() {
+  try {
+    review_stamps.reviewed_stamp.remove();
+    stamp_file.remove_stamp(stopped_path());
+  } catch {
+  }
+}
+var review_reviewed_tree = {
+  MOVEMENT,
+  discard,
+  high_cited,
+  is_stopped_on,
+  is_unmoved,
+  mark_stopped,
+  movement,
+  record,
+  resume_point,
+  standing_here
+};
+
+export {
+  review_reviewed_tree
+};

package/dist/commands/chunk-ZGEUWHFF.js

@@ -0,0 +1,297 @@
+import {
+  lane_implement_rate
+} from "./chunk-KP2BVAS5.js";
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  hook_launch
+} from "./chunk-OF4BY4N7.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+
+// scripts/agent/codex-hooks.ts
+var CODEX_EDIT_TOOL = "apply_patch|functions.apply_patch";
+var CODEX_SHELL_TOOLS = "exec_command|functions.exec_command|exec|functions.exec";
+var TOOL_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse"]);
+var UNMATCHED_EVENTS = /* @__PURE__ */ new Set(["UserPromptSubmit"]);
+var JSON_INDENT = "	";
+var CLAUDE_SETTINGS_FILE = ".claude/settings.json";
+var CODEX_HOOKS_FILE = ".codex/hooks.json";
+var GENERATED_SOURCES = /* @__PURE__ */ new Map([
+  [CODEX_HOOKS_FILE, CLAUDE_SETTINGS_FILE]
+]);
+function adapter_command(mode) {
+  return hook_launch.hook_launch_command(`codex-hook-adapter ${mode}`, hook_launch.CODEX_ROOT);
+}
+var ADAPTED_COMMANDS = /* @__PURE__ */ new Map([
+  [hook_launch.hook_launch_command("pretool-guard"), adapter_command("pretool")],
+  [hook_launch.hook_launch_command("format-edited"), adapter_command("posttool")]
+]);
+function codex_handler(handler) {
+  const command = ADAPTED_COMMANDS.get(handler.command) ?? hook_launch.codex_command(handler.command);
+  return { ...handler, command };
+}
+function codex_matcher(event, matcher) {
+  if (UNMATCHED_EVENTS.has(event)) return void 0;
+  if (matcher !== void 0 && TOOL_EVENTS.has(event)) {
+    return `${matcher}|${CODEX_EDIT_TOOL}|${CODEX_SHELL_TOOLS}`;
+  }
+  return matcher;
+}
+function codex_group(event, group) {
+  const matcher = codex_matcher(event, group.matcher);
+  const hooks = group.hooks.map((handler) => codex_handler(handler));
+  return matcher === void 0 ? { hooks } : { matcher, hooks };
+}
+function codex_hook_config(claude) {
+  const events = Object.entries(claude.hooks).map(([event, groups]) => [
+    event,
+    groups.map((group) => codex_group(event, group))
+  ]);
+  return { hooks: Object.fromEntries(events) };
+}
+function codex_hooks_text(claude_settings_text) {
+  const claude = JSON.parse(claude_settings_text);
+  return `${JSON.stringify(codex_hook_config(claude), void 0, JSON_INDENT)}
+`;
+}
+var codex_hooks = {
+  adapter_command,
+  codex_hook_config,
+  codex_hooks_text,
+  CLAUDE_SETTINGS_FILE,
+  CODEX_HOOKS_FILE,
+  GENERATED_SOURCES
+};
+
+// scripts/git/git-path-quoting.ts
+var OCTAL_RADIX = 8;
+var OCTAL_WIDTH = 3;
+var SPACE_CODE = 32;
+var DELETE_CODE = 127;
+var ESCAPES = /* @__PURE__ */ new Map([
+  ["\x07", "a"],
+  ["\b", "b"],
+  ["	", "t"],
+  ["\n", "n"],
+  ["\v", "v"],
+  ["\f", "f"],
+  ["\r", "r"],
+  ['"', '"'],
+  ["\\", "\\"]
+]);
+function escape_character(character) {
+  const short = ESCAPES.get(character);
+  if (short !== void 0) return `\\${short}`;
+  const code = character.codePointAt(0) ?? 0;
+  return code === DELETE_CODE || code < SPACE_CODE ? `\\${code.toString(OCTAL_RADIX).padStart(OCTAL_WIDTH, "0")}` : character;
+}
+function quote(file) {
+  const escaped = Array.from(file, (character) => escape_character(character)).join("");
+  return escaped === file ? file : `"${escaped}"`;
+}
+function unescape_character(escaped) {
+  return [...ESCAPES].find((entry) => entry[1] === escaped)?.[0] ?? String.fromCodePoint(Number.parseInt(escaped, OCTAL_RADIX));
+}
+function unquote(file) {
+  if (!file.startsWith('"') || !file.endsWith('"')) return file;
+  return file.slice(1, -1).replaceAll(
+    /\\([0-7]{3}|a|b|f|n|r|t|v|["\\])/gu,
+    (_match, escaped) => unescape_character(escaped)
+  );
+}
+var git_path_quoting = { quote, unquote };
+
+// scripts/split/declared-growth.ts
+var FALLBACK = 2;
+function factor(ratios, axis) {
+  return ratios?.[axis] ?? FALLBACK;
+}
+function axis_text(ratios, axis) {
+  const source = ratios?.[axis] === void 0 ? "fallback" : "measured";
+  return `${axis} \xD7 ${String(factor(ratios, axis))} (${source})`;
+}
+function text(ratios) {
+  return `growth ${axis_text(ratios, "files")} / ${axis_text(ratios, "lines")}`;
+}
+var declared_growth = { FALLBACK, factor, text };
+
+// scripts/split/split-assess.ts
+var FILE_GUIDE = 8;
+var LINE_GUIDE = 200;
+var CAP_FACTOR = 1.5;
+var FILE_CAP = FILE_GUIDE * CAP_FACTOR;
+var LINE_CAP = LINE_GUIDE * CAP_FACTOR;
+var DEFAULT_GUIDE = {
+  files: FILE_GUIDE,
+  lines: LINE_GUIDE,
+  cap: { files: FILE_CAP, lines: LINE_CAP }
+};
+function guide_for(minutes, measured, growth) {
+  const lines = lane_implement_rate.lines_for(minutes, measured);
+  const correction = growth === void 0 ? {} : { growth };
+  if (lines === void 0 || lines <= LINE_GUIDE) return { ...DEFAULT_GUIDE, ...correction };
+  const files = lines * FILE_GUIDE / LINE_GUIDE;
+  return {
+    files,
+    lines,
+    cap: { files: files * CAP_FACTOR, lines: lines * CAP_FACTOR },
+    ...correction
+  };
+}
+var DECLARED_GROWTH_FACTOR = declared_growth.FALLBACK;
+var SPLIT_VERDICT = "split";
+var SINGLE_VERDICT = "single";
+var SCRIPTS_DIRECTORY = "scripts/";
+var TYPESCRIPT = ".ts";
+var BINARY_MARKER = "-";
+var NUMSTAT_FIELDS = 3;
+function parse_count(field) {
+  if (field === void 0 || field === BINARY_MARKER) return 0;
+  const value = Number(field);
+  return Number.isNaN(value) ? 0 : value;
+}
+function parse_row(row) {
+  const fields = row.split("	");
+  if (fields.length < NUMSTAT_FIELDS) return void 0;
+  const [added, deleted, ...path_parts] = fields;
+  return { path: path_parts.join("	"), changed_lines: parse_count(added) + parse_count(deleted) };
+}
+function parse_numstat(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((row) => parse_row(row)).filter((change) => change !== void 0);
+}
+function is_deliverable(change) {
+  const file = git_path_quoting.unquote(change.path);
+  return !test_declared_logic.is_test_file(file) && !run_record_path.is_run_record(file);
+}
+function is_scripts_module(file) {
+  return file.startsWith(SCRIPTS_DIRECTORY) && file.endsWith(TYPESCRIPT);
+}
+function directory_of(file) {
+  return file.slice(0, file.lastIndexOf("/") + 1);
+}
+function partners_of(files, added) {
+  const modules = files.filter((file) => is_scripts_module(file));
+  const partners = /* @__PURE__ */ new Map();
+  const new_modules = modules.filter((file) => added.has(file));
+  for (const module of new_modules) {
+    const importer = modules.find(
+      (file) => !added.has(file) && !partners.has(file) && directory_of(file) === directory_of(module)
+    );
+    if (importer !== void 0) partners.set(module, importer).set(importer, module);
+  }
+  return partners;
+}
+function units_of(files, added) {
+  const artifacts = codex_hooks.GENERATED_SOURCES;
+  const sources = files.filter((file) => !files.includes(artifacts.get(file) ?? ""));
+  const partners = partners_of(sources, added);
+  return sources.flatMap((file) => {
+    const partner = partners.get(file);
+    const unit = partner === void 0 ? [file] : [file, partner];
+    const generated = files.filter((path) => unit.includes(artifacts.get(path) ?? ""));
+    return partner !== void 0 && sources.indexOf(partner) < sources.indexOf(file) ? [] : [[...unit, ...generated]];
+  });
+}
+function verdict_for(files, lines, guide = DEFAULT_GUIDE) {
+  return files > guide.files || lines > guide.lines ? SPLIT_VERDICT : SINGLE_VERDICT;
+}
+function is_over_cap(files, lines, guide = DEFAULT_GUIDE) {
+  return files > guide.cap.files || lines > guide.cap.lines;
+}
+function measure(changes, guide, added = /* @__PURE__ */ new Set()) {
+  const runtime = changes.filter((change) => is_deliverable(change));
+  const lines = runtime.reduce((total, change) => total + change.changed_lines, 0);
+  const paths = runtime.map((change) => git_path_quoting.unquote(change.path));
+  const files = units_of(paths, added).length;
+  return {
+    files,
+    lines,
+    verdict: verdict_for(files, lines, guide),
+    ...guide !== void 0 && { guide }
+  };
+}
+function assess(raw, guide, added) {
+  return measure(parse_numstat(raw), guide, added);
+}
+var SPLIT_TAIL = "over the guide \u2014 the size condition for a split is met (separability is a separate judgement)";
+var SINGLE_TAIL = "under the guide on both axes \u2014 one Issue, however separable";
+function counted(measurement) {
+  return `${String(measurement.files)} changed file(s), ${String(measurement.lines)} changed line(s), tests excluded`;
+}
+function guide_text(guide) {
+  return `guide ${String(guide.files)} files / ${String(guide.lines)} lines`;
+}
+function policy_text(guide) {
+  const source = guide.lines > LINE_GUIDE ? "measured" : "fallback";
+  return `${guide_text(guide)} (${source}); ${declared_growth.text(guide.growth)}`;
+}
+function reason(measurement, guide = measurement.guide ?? DEFAULT_GUIDE) {
+  const tail = measurement.verdict === SPLIT_VERDICT ? SPLIT_TAIL : SINGLE_TAIL;
+  return `${counted(measurement)} (${policy_text(guide)}) \u2014 ${tail}`;
+}
+function grown_bar(declared, guide) {
+  const grown_files = declared.files * declared_growth.factor(guide.growth, "files");
+  const grown_lines = declared.lines * declared_growth.factor(guide.growth, "lines");
+  const files = Math.min(grown_files, guide.files);
+  const lines = Math.min(grown_lines, guide.lines);
+  const capped = files < grown_files || lines < grown_lines ? ", capped at the guide" : "";
+  const declaration = `declared ${String(declared.files)} files / ${String(declared.lines)} lines`;
+  return {
+    files,
+    lines,
+    text: `${declaration}; ${declared_growth.text(guide.growth)}${capped} = ${String(files)} files / ${String(lines)} lines`
+  };
+}
+function is_sized(declared) {
+  return declared !== void 0 && declared.files > 0 && declared.lines > 0;
+}
+function notice_bar(declared, guide) {
+  const guide_bar = { files: guide.files, lines: guide.lines, text: guide_text(guide) };
+  if (!is_sized(declared)) return guide_bar;
+  const bar = grown_bar(declared, guide);
+  return bar.files === guide.files && bar.lines === guide.lines ? guide_bar : bar;
+}
+var NOTICE_SECTION = "Over the guide before the gate";
+var QUESTION_SECTION = "The question";
+var REASON_PREFIX = issue_body_keys.prefix("no_split_reason");
+var NOTICE_ACTION = `go on to the end; a started Issue is never split, and the merge records the overrun as a pre-split miss \u2014 split-assessment.md \u2192 "${NOTICE_SECTION}"`;
+function notice(measurement, declared, guide = measurement.guide ?? DEFAULT_GUIDE) {
+  const bar = notice_bar(declared, guide);
+  if (measurement.files <= bar.files && measurement.lines <= bar.lines) return void 0;
+  return `split notice: ${counted(measurement)} (${bar.text}; ${policy_text(guide)}) \u2014 over the bar, a warning, not a stop: ${NOTICE_ACTION}`;
+}
+var split_assess = {
+  DECLARED_GROWTH_FACTOR,
+  FILE_CAP,
+  FILE_GUIDE,
+  LINE_CAP,
+  LINE_GUIDE,
+  NOTICE_SECTION,
+  QUESTION_SECTION,
+  REASON_PREFIX,
+  SPLIT_VERDICT,
+  SINGLE_VERDICT,
+  assess,
+  guide_for,
+  is_deliverable,
+  is_over_cap,
+  notice,
+  measure,
+  parse_numstat,
+  policy_text,
+  reason,
+  units_of,
+  verdict_for
+};
+
+export {
+  declared_growth,
+  git_path_quoting,
+  split_assess
+};

package/dist/commands/chunk-ZHSNQ2F7.js

@@ -0,0 +1,161 @@
+import {
+  run_cut,
+  run_cut_handoff
+} from "./chunk-TFDVTU6O.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/run/cut/run-cut-report.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var CUT_VERDICT = "cut";
+var RESUME_VERDICT = "resume";
+var RESUME_IMPL_VERDICT = "resume-impl";
+var FRESH_VERDICT = "fresh";
+var UNDER_THRESHOLD_VERDICT = "under-threshold";
+var STALE_VERDICT = "stale";
+var INCOMPLETE_VERDICT = "incomplete";
+var BAD_HANDOFF_VERDICT = "bad-handoff";
+var HANDED_OFF_VERDICT = "handed-off";
+var BUSY_VERDICT = "busy";
+var NOT_A_LANE_VERDICT = "not-a-lane";
+var UNREADY_VERDICT = "unready";
+var FAILED_VERDICT = "failed";
+var ENDED_VERDICT = "ended";
+var UNREADABLE_VERDICT = "unreadable";
+var UNKNOWN_VERDICT = "unknown";
+var OVER_VERDICT = "over";
+var printed = { verdict: "" };
+function report(verdict, code) {
+  printed.verdict = verdict;
+  console.info(verdict);
+  return code;
+}
+function last_verdict() {
+  return printed.verdict;
+}
+function report_stale(cut_record) {
+  console.error(run_cut.stale_message(cut_record));
+  return report(STALE_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_busy(cut_record) {
+  console.error(run_cut.busy_message(cut_record));
+  return report(BUSY_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_incomplete(cut_record) {
+  console.error(run_cut.incomplete_message(cut_record));
+  return report(INCOMPLETE_VERDICT, FAILURE_EXIT_CODE);
+}
+var HANDOFF_OVERFLOW_NOTE = "--handoff <path> would grow the cut record past its byte bound";
+var HANDOFF_MISSING_NOTE = "this cut resumes into implementation and needs --handoff <path>";
+function report_bad_handoff(note) {
+  console.error(
+    `${note}. Nothing was cut; write the handoff file at ${run_cut_handoff.HANDOFF_PATH} and reissue.`
+  );
+  return report(BAD_HANDOFF_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_handed_off(cut_record) {
+  console.error(run_cut.handed_off_message(cut_record));
+  return report(HANDED_OFF_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_unreadable() {
+  console.error(run_cut.unreadable_message());
+  return report(UNREADABLE_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_fault(message) {
+  console.error(message);
+  return report(UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_unknown() {
+  return report_fault(run_cut.unknown_message());
+}
+function refuse_unready(state) {
+  console.error(
+    `Not ready to cut on ${state.branch} (dirty: ${String(state.is_dirty)}); a cut needs an uncommitted lane branch. Nothing was cut.`
+  );
+  return report(UNREADY_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_under_threshold() {
+  console.error(
+    "The current context is under the shared cut threshold, so nothing was cut; a resume would cost more than the accumulation it would drop. Continue to the gate."
+  );
+  return report(UNDER_THRESHOLD_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_reviewer() {
+  console.error(
+    "This session is a ship reviewer, which its supervisor is waiting on, so nothing was cut and nothing was relaunched. Finish the review in this process and submit its findings the way your review prompt says."
+  );
+  return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_held_cut(issue) {
+  console.error(
+    `The cut is recorded for ${session_cite.issue(issue)} outside a lane, so nothing was relaunched. Keep the hold, send a \`confirmation\` Telegram whose body names the resume command \`fullrun ${issue_cite.plain_for("terminal", issue)}\`, and end the turn; the fresh session's \`pnpm josh run:cut --resume ${issue}\` answers \`resume-impl\` with the handoff.`
+  );
+  return report(CUT_VERDICT, SUCCESS_EXIT_CODE);
+}
+var RELAUNCHED_CUT_MARKER = "cut-relaunched";
+function report_relaunched_cut() {
+  console.error(RELAUNCHED_CUT_MARKER);
+  return report(CUT_VERDICT, SUCCESS_EXIT_CODE);
+}
+function report_over() {
+  console.error(
+    "This session is over the shared context-cut threshold (`pnpm josh cost --cut` answers `over`), so the implementation cut was not resumed here and its record is kept. End this conversation and type the invocation again in a fresh session."
+  );
+  return report(OVER_VERDICT, FAILURE_EXIT_CODE);
+}
+function report_missing_supervisor(issue) {
+  console.error(
+    `The OpenAI supervisor for ${session_cite.issue(issue)} is not live, so this nested process was not cut and can continue. Re-dispatch the lane to recover the supervisor.`
+  );
+  return report(FAILED_VERDICT, FAILURE_EXIT_CODE);
+}
+var run_cut_report = {
+  BAD_HANDOFF_VERDICT,
+  BUSY_VERDICT,
+  CUT_VERDICT,
+  ENDED_VERDICT,
+  FAILED_VERDICT,
+  FAILURE_EXIT_CODE,
+  FRESH_VERDICT,
+  HANDED_OFF_VERDICT,
+  HANDOFF_MISSING_NOTE,
+  HANDOFF_OVERFLOW_NOTE,
+  INCOMPLETE_VERDICT,
+  NOT_A_LANE_VERDICT,
+  OVER_VERDICT,
+  RELAUNCHED_CUT_MARKER,
+  RESUME_IMPL_VERDICT,
+  RESUME_VERDICT,
+  STALE_VERDICT,
+  SUCCESS_EXIT_CODE,
+  UNDER_THRESHOLD_VERDICT,
+  UNKNOWN_VERDICT,
+  UNREADABLE_VERDICT,
+  UNREADY_VERDICT,
+  refuse_unready,
+  last_verdict,
+  report,
+  report_bad_handoff,
+  report_busy,
+  report_fault,
+  report_handed_off,
+  report_held_cut,
+  report_incomplete,
+  report_missing_supervisor,
+  report_over,
+  report_relaunched_cut,
+  report_reviewer,
+  report_stale,
+  report_under_threshold,
+  report_unknown,
+  report_unreadable
+};
+
+export {
+  run_cut_report
+};