@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-SQZZHK6X.js

@@ -0,0 +1,119 @@
+import {
+  run_event_retry
+} from "./chunk-MFZVRWRS.js";
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  run_event_scope
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+
+// scripts/backlog/backlog-offer-exclude.ts
+var LIST_SEPARATOR = ",";
+function exclude_of(settled, in_flight) {
+  return [.../* @__PURE__ */ new Set([...settled, ...in_flight])];
+}
+function exclude_argv(exclude) {
+  return exclude.length === 0 ? [] : ["--exclude", exclude.join(LIST_SEPARATOR)];
+}
+var backlog_offer_exclude = { exclude_argv, exclude_of };
+
+// scripts/backlog/backlog-drive-restore.ts
+var ISSUE_IN_EVENT = /#([1-9]\d*)\b/u;
+var SETTLED_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.MERGE,
+  run_event_stream.EVENT_KIND.PARK,
+  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
+  run_event_stream.EVENT_KIND.SPLIT,
+  run_event_stream.EVENT_KIND.WITHDRAW,
+  run_event_stream.EVENT_KIND.OUTAGE,
+  run_event_stream.EVENT_KIND.USAGE_LIMIT
+]);
+var DONE_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.MERGE,
+  run_event_stream.EVENT_KIND.PARK,
+  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
+  run_event_stream.EVENT_KIND.SPLIT,
+  run_event_stream.EVENT_KIND.WITHDRAW
+]);
+function issue_of(event) {
+  return ISSUE_IN_EVENT.exec(event.text)?.[1];
+}
+function update_active(active, event) {
+  const issue = issue_of(event);
+  if (issue === void 0) return;
+  if (event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH) active.add(issue);
+  if (SETTLED_KINDS.has(event.kind)) active.delete(issue);
+}
+function active_issues(events) {
+  const active = /* @__PURE__ */ new Set();
+  for (const event of events) update_active(active, event);
+  return active;
+}
+function settled_issues(events) {
+  const settled = run_event_retry.current_attempts(events).filter((event) => DONE_KINDS.has(event.kind) && !lane_yield.is_yield(event));
+  return new Set(
+    settled.map((event) => issue_of(event)).filter((issue) => issue !== void 0).map(Number)
+  );
+}
+function issues_of_kind(events, kind) {
+  return events.filter((event) => event.kind === kind).map((event) => issue_of(event)).filter((issue) => issue !== void 0);
+}
+function withdrawn_issues(events) {
+  const named = issues_of_kind(events, run_event_stream.EVENT_KIND.WITHDRAW);
+  return named.filter(
+    (issue) => run_event_scope.is_withdrawn(events, issue) && !lane_yield.is_yielded(events, issue)
+  );
+}
+function waiting_issues(events) {
+  return [...new Set(issues_of_kind(events, run_event_stream.EVENT_KIND.SAMPLE_WAIT))];
+}
+function left_out(events, carried) {
+  const exclude = [.../* @__PURE__ */ new Set([...carried, ...withdrawn_issues(events)])];
+  return { exclude, waiting: [...waiting_issues(events)] };
+}
+function offer_exclude(events) {
+  const merged = issues_of_kind(events, run_event_stream.EVENT_KIND.MERGE);
+  const settled = [...merged, ...waiting_issues(events), ...withdrawn_issues(events)];
+  return backlog_offer_exclude.exclude_of(settled, active_issues(events));
+}
+function parked_issues(events) {
+  return new Set(
+    issues_of_kind(run_event_retry.current_attempts(events), run_event_stream.EVENT_KIND.PARK).map(
+      Number
+    )
+  );
+}
+function mentioned_issues(events) {
+  const tracked = events.filter(
+    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH || SETTLED_KINDS.has(event.kind)
+  );
+  return new Set(tracked.map((event) => issue_of(event)).filter((issue) => issue !== void 0));
+}
+function restore(lanes, events, merged_issues, dispatched = []) {
+  const active = active_issues(events);
+  const mentioned = mentioned_issues(events);
+  const carried = new Set(dispatched.filter((issue) => !mentioned.has(issue)));
+  return lanes.filter(
+    (issue) => (active.has(issue) || carried.has(issue)) && !merged_issues.includes(Number(issue))
+  );
+}
+var backlog_drive_restore = {
+  DONE_KINDS,
+  active_issues,
+  left_out,
+  mentioned_issues,
+  offer_exclude,
+  restore,
+  withdrawn_issues,
+  settled_issues,
+  parked_issues
+};
+
+export {
+  backlog_offer_exclude,
+  backlog_drive_restore
+};

package/dist/commands/chunk-SRTEE34O.js

@@ -0,0 +1,93 @@
+import {
+  issue_rank
+} from "./chunk-HLKAFSN4.js";
+import {
+  size_estimate
+} from "./chunk-2VY7CJ2R.js";
+import {
+  expected_effect_lint
+} from "./chunk-XZQWEVR3.js";
+import {
+  issue_priority
+} from "./chunk-XI2ABCRX.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  open_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  NOT_DIRECTLY_RUNNABLE_LABELS,
+  has_any_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  parse_json_array_safe
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/issue/git-next-issues.ts
+var FETCH_LIMIT = 20;
+var DISPLAY_LIMIT = 5;
+var HEADER = "\u{1F5D2} Next issues (oldest first on ties):";
+function has_excluded_label(issue) {
+  return has_any_label(issue.labels, NOT_DIRECTLY_RUNNABLE_LABELS);
+}
+function is_candidate(issue, completed_issue_number) {
+  return issue.number !== completed_issue_number && !has_excluded_label(issue);
+}
+function compare_oldest_first(first, second) {
+  if (first.createdAt === second.createdAt) return first.number - second.number;
+  return first.createdAt < second.createdAt ? -1 : 1;
+}
+function dependency_row(issue) {
+  return {
+    key: String(issue.number),
+    blockers: (issue.blockedBy?.nodes ?? []).map((blocker) => String(blocker.number))
+  };
+}
+function order(issues, completed_issue_number) {
+  const candidates = issues.filter((issue) => is_candidate(issue, completed_issue_number)).toSorted(compare_oldest_first);
+  const dependents = issue_rank.count_dependents(candidates.map((issue) => dependency_row(issue)));
+  return issue_rank.rank(candidates, (issue) => ({
+    is_last: issue_priority.is_last(issue.body),
+    labels: (issue.labels ?? []).map((label) => label.name),
+    lost_minutes: issue_priority.lost_minutes(issue.body),
+    gain_minutes: expected_effect_lint.weekly_minutes(issue.body),
+    dependents: dependents.get(String(issue.number)) ?? 0,
+    estimated_lines: size_estimate.declared_size(issue.body ?? "")?.lines
+  }));
+}
+function prioritize(issues, completed_issue_number) {
+  return order(issues, completed_issue_number).slice(0, DISPLAY_LIMIT);
+}
+function format_lines(issues) {
+  if (issues.length === 0) return [];
+  const rows = issues.map(
+    (issue, index) => `  ${String(index + 1)}. ${session_cite.issue(issue.number, issue.title)}`
+  );
+  return [HEADER, ...rows];
+}
+async function fetch_next_issue_lines(completed_issue_number) {
+  try {
+    const { json } = await git_gh_command.issue_list_recent(FETCH_LIMIT);
+    if (json === void 0) return [];
+    return format_lines(
+      prioritize(parse_json_array_safe(json, open_issue_schema), completed_issue_number)
+    );
+  } catch {
+    return [];
+  }
+}
+var git_next_issues = {
+  DISPLAY_LIMIT,
+  order,
+  prioritize,
+  format_lines,
+  fetch_next_issue_lines
+};
+
+export {
+  git_next_issues
+};

package/dist/commands/chunk-SYTCTLMD.js

@@ -0,0 +1,285 @@
+import {
+  epic_decide,
+  epic_remove
+} from "./chunk-AN7BFVHU.js";
+import {
+  epic_cli,
+  epic_cli_untrack
+} from "./chunk-LE3M42CF.js";
+import {
+  epic_untrack
+} from "./chunk-M3UGRNNB.js";
+import {
+  issue_plan_notify
+} from "./chunk-RGEB5L37.js";
+import {
+  epic_run
+} from "./chunk-NYWPTYGL.js";
+import {
+  epic_body
+} from "./chunk-LJZERYLG.js";
+import {
+  epic_add,
+  epic_reconcile
+} from "./chunk-VY7ZJMDT.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  backlog_overlap
+} from "./chunk-MDGPJOLK.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/epic/epic-notify.ts
+function body_of(notice, slug) {
+  const rows = notice.children.map((child) => `- ${issue_cite.issue_url(slug, String(child))}`);
+  return [...rows, `Next: ${epic_body.format_run_command(notice.epic_number)}`].join("\n");
+}
+async function send(notice) {
+  const slug = await issue_plan_notify.slug_of(void 0);
+  if (slug === void 0) {
+    console.error("\u26A0\uFE0F  epic could not read the repository; no planning notification was sent.");
+    return;
+  }
+  await issue_plan_notify.send_planning({
+    issue_number: String(notice.epic_number),
+    body: body_of(notice, slug),
+    title: notice.title,
+    repo: slug,
+    command: "epic"
+  });
+}
+var SUCCESS_EXIT_CODE = 0;
+function promoted_number(exit_code, epic_number) {
+  return exit_code === SUCCESS_EXIT_CODE ? epic_number : void 0;
+}
+async function announce(request, epic_number) {
+  if (!request.is_notified) return;
+  if (epic_number === void 0) {
+    console.error("\u26A0\uFE0F  epic has no epic number to announce; no planning notification was sent.");
+    return;
+  }
+  await send({ epic_number, children: request.children, title: request.title });
+}
+var epic_notify = { announce, body_of, promoted_number, send };
+
+// scripts/epic/epic-split-reach.ts
+import { existsSync } from "node:fs";
+var SCRIPTS_DIRECTORY = "scripts/";
+var TYPESCRIPT = ".ts";
+var TEST_SUFFIX = ".test.ts";
+var SEPARATOR = "/";
+function is_scripts_module(path) {
+  return path.startsWith(SCRIPTS_DIRECTORY) && path.endsWith(TYPESCRIPT) && !path.endsWith(TEST_SUFFIX);
+}
+function base_name(path) {
+  return path.slice(path.lastIndexOf(SEPARATOR) + 1);
+}
+function names_module(paths, module) {
+  return [...paths].some((path) => base_name(path) === base_name(module));
+}
+function stranded_of(child, declared, is_present) {
+  const own = [...declared.get(child.number) ?? []].filter((path) => is_scripts_module(path));
+  if (own.some((path) => is_present(path))) return [];
+  return own.map((module) => ({
+    child: child.number,
+    module,
+    importers: [...declared].filter(([number, paths]) => number !== child.number && names_module(paths, module)).map(([number]) => number)
+  }));
+}
+function stranded_modules(children, is_present) {
+  const declared = backlog_overlap.declared_of(children);
+  return children.flatMap((child) => stranded_of(child, declared, is_present)).filter((stranded) => stranded.importers.length > 0);
+}
+function format_stranded(stranded) {
+  const importers = stranded.importers.map((number) => session_cite.issue(number)).join(", ");
+  return `  - ${session_cite.issue(stranded.child)} creates \`${stranded.module}\`, named only by ${importers}`;
+}
+function format_refusal(stranded) {
+  return [
+    "\u2716 This split has a child that cannot merge alone \u2014 the new scripts module it creates is imported only from a sibling, and `scripts/build/pack-boundary.test.ts` refuses an unreachable module:",
+    ...stranded.map((entry) => format_stranded(entry)),
+    "Fold the importing child into the creating one as one Issue, or declare the importer in the creating child; nothing was written."
+  ].join("\n");
+}
+async function refusal_of(children) {
+  const bodies = await Promise.all(
+    children.map(async (number) => ({
+      number,
+      body: await git_gh_command.issue_get_body(String(number))
+    }))
+  );
+  const stranded = stranded_modules(bodies, existsSync);
+  return stranded.length === 0 ? void 0 : format_refusal(stranded);
+}
+var epic_split_reach = { format_refusal, refusal_of, stranded_modules };
+
+// scripts/epic/epic.ts
+var FLAGS = "[--ordered] [--rationale-file <path|->] [--origin <owner/repo#N>] [--notify]";
+var USAGE = [
+  `Usage: josh epic "<title>" <N1> <N2> ... ${FLAGS}`,
+  `       josh epic --promote <N> <N1> <N2> ... ${FLAGS} [--title <title>]`,
+  "       josh epic --add <E> <N1> <N2> ... [--before <M> | --after <M>] [--decision-file <path|->]",
+  "       josh epic --add <E> <N1> <N2> ... [--order-before <M> | --order-after <M>] [--decision-file <path|->]",
+  "       josh epic --remove <E> <M> <N> ... [--decision-file <path|->]",
+  "       josh epic --untrack <E> <N1> <N2> ...",
+  "       josh epic --reconcile <E>",
+  "       josh epic --decide <E> <N1> <N2> ... --decision-file <path|->"
+].join("\n");
+var FAILURE_EXIT_CODE = 1;
+var SUCCESS_EXIT_CODE2 = 0;
+async function is_split_stranded(children) {
+  const refusal = await epic_split_reach.refusal_of(children);
+  if (refusal !== void 0) console.error(refusal);
+  return refusal !== void 0;
+}
+async function run_promotion(argv) {
+  const parsed = epic_cli.parse_promote_arguments(argv);
+  if (parsed === void 0) {
+    console.error(`\u2716 An issue number and at least one child issue number are required.
+${USAGE}`);
+    return FAILURE_EXIT_CODE;
+  }
+  if (await is_split_stranded(parsed.children)) return FAILURE_EXIT_CODE;
+  const exit_code = await epic_run.promote_epic({
+    epic_number: parsed.epic_number,
+    children: parsed.children,
+    rationale: epic_cli.read_rationale(parsed.rationale_path),
+    is_ordered: parsed.is_ordered,
+    origin: parsed.origin,
+    title: parsed.title
+  });
+  await epic_notify.announce(parsed, epic_notify.promoted_number(exit_code, parsed.epic_number));
+  return exit_code;
+}
+function to_add_input(parsed) {
+  return {
+    epic_number: parsed.epic_number,
+    children: parsed.children,
+    position: parsed.position,
+    is_order_only: parsed.is_order_only,
+    decision: epic_cli.read_decision(parsed.decision_path)
+  };
+}
+async function run_qualified_addition(found) {
+  const local = epic_cli.resolve_local_add(found, await git_gh_command.repo_get_name_with_owner());
+  if (local !== void 0) return await epic_add.add_children(to_add_input(local));
+  console.error(epic_cli.format_cross_repo_refusal(found));
+  return FAILURE_EXIT_CODE;
+}
+async function refuse_addition(argv) {
+  const qualified = epic_cli.find_cross_repo_add_target(argv);
+  if (qualified !== void 0) return await run_qualified_addition(qualified);
+  if (epic_cli.is_decision_path_unusable(argv)) {
+    console.error(
+      `\u2716 \`--decision-file\` needs exactly one readable path (\`-\` reads stdin); nothing was written.
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  console.error(
+    `\u2716 An epic number, at least one child issue number, and at most one valid \`--before\` / \`--after\` target are required.
+${USAGE}`
+  );
+  return FAILURE_EXIT_CODE;
+}
+async function run_addition(argv) {
+  const parsed = epic_cli.parse_add_arguments(argv);
+  if (parsed === void 0) return await refuse_addition(argv);
+  return await epic_add.add_children(to_add_input(parsed));
+}
+async function run_removal(argv) {
+  const parsed = epic_cli.parse_remove_arguments(argv);
+  if (parsed === void 0) {
+    console.error(
+      `\u2716 An epic number and at least two child issue numbers are required, and \`--decision-file\` needs exactly one readable path (\`-\` reads stdin).
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_remove.remove_order({
+    epic_number: parsed.epic_number,
+    path: parsed.path,
+    decision: epic_cli.read_decision(parsed.decision_path)
+  });
+}
+async function run_decision(argv) {
+  const parsed = epic_cli.parse_decide_arguments(argv);
+  if (parsed === void 0) {
+    console.error(
+      `\u2716 An epic number, at least one child issue number, and exactly one readable \`--decision-file\` path (\`-\` reads stdin) are required.
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_decide.decide({
+    epic_number: parsed.epic_number,
+    children: parsed.children,
+    decision: epic_cli.read_decision(parsed.decision_path) ?? ""
+  });
+}
+async function run_reconciliation(argv) {
+  const parsed = epic_cli.parse_reconcile_arguments(argv);
+  if (parsed === void 0) {
+    console.error(`\u2716 An epic number is required.
+${USAGE}`);
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_reconcile.reconcile_epic(parsed.epic_number);
+}
+async function create(argv) {
+  const parsed = epic_cli.parse_create_arguments(argv);
+  if (parsed === void 0) {
+    console.error(`\u2716 A title and at least one child issue number are required.
+${USAGE}`);
+    return { kind: "refused" };
+  }
+  if (await is_split_stranded(parsed.children)) return { kind: "refused" };
+  const epic_number = await epic_run.create_epic_number({
+    title: parsed.title,
+    children: parsed.children,
+    rationale: epic_cli.read_rationale(parsed.rationale_path),
+    is_ordered: parsed.is_ordered,
+    origin: parsed.origin
+  });
+  await epic_notify.announce(parsed, epic_number);
+  return { kind: "created", epic: epic_number };
+}
+async function run_creation(argv) {
+  const creation = await create(argv);
+  return creation.kind === "refused" ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE2;
+}
+async function run_untrack(argv) {
+  const parsed = epic_cli_untrack.parse_arguments(argv);
+  if (parsed === void 0) {
+    console.error(
+      `\u2716 An epic number and at least one distinct child issue number are required.
+${USAGE}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  return await epic_untrack.untrack(parsed.epic_number, parsed.children);
+}
+var FLAGGED_FORMS = [
+  [epic_cli_untrack.is_untrack, run_untrack],
+  [epic_cli.is_reconciliation, run_reconciliation],
+  [epic_cli.is_removal, run_removal],
+  [epic_cli.is_decision_entry, run_decision],
+  [epic_cli.is_addition, run_addition],
+  [epic_cli.is_promotion, run_promotion]
+];
+async function run(argv) {
+  const form = FLAGGED_FORMS.find(([is_form]) => is_form(argv));
+  const run_form = form === void 0 ? run_creation : form[1];
+  return await run_form(argv);
+}
+var epic_command = { run, create };
+
+export {
+  epic_command
+};

package/dist/commands/chunk-T6JUDQMW.js

@@ -0,0 +1,181 @@
+import {
+  path_decision
+} from "./chunk-JI2EGXZX.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  release_approval_prune
+} from "./chunk-QSJCZATC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/review/review-level.ts
+var DEFAULT_LEVEL = "medium";
+var REDUCED_LEVEL = "low";
+var TINY_CHANGE_LINES = 20;
+var INERT_PATHS = [
+  ".editorconfig",
+  ".gitignore",
+  "CHANGELOG.md",
+  "LICENSE"
+];
+var INERT_PREFIXES = [];
+var INERT_SUFFIXES = [".code-workspace"];
+function is_inert(path) {
+  const normalized = path.trim();
+  return INERT_PATHS.includes(normalized) || INERT_PREFIXES.some((prefix) => normalized.startsWith(prefix)) || INERT_SUFFIXES.some((suffix) => normalized.endsWith(suffix));
+}
+function is_reduced_path(relative) {
+  return is_inert(relative) || relative.endsWith(".md") || ["docs/", "prompts/", "tests/"].some((prefix) => relative.startsWith(prefix)) || /\.(?:test|spec)\.[cm]?[jt]sx?$/u.test(relative);
+}
+function is_tiny(changed_lines) {
+  return changed_lines !== void 0 && changed_lines >= 0 && changed_lines <= TINY_CHANGE_LINES;
+}
+function level_for(paths, changed_lines) {
+  const changed = paths.map((path) => path.trim()).filter((path) => path !== "");
+  if (changed.length === 0) return DEFAULT_LEVEL;
+  if (changed.every((relative) => is_reduced_path(relative))) return REDUCED_LEVEL;
+  return is_tiny(changed_lines) ? REDUCED_LEVEL : DEFAULT_LEVEL;
+}
+function deciding_paths(paths) {
+  return paths.map((path) => path.trim()).filter((path) => path !== "" && !is_reduced_path(path));
+}
+function format_reason(paths, level) {
+  if (level === REDUCED_LEVEL) {
+    return "every changed path is inert, documentation, a prompt or a test; or the entire diff is at most 20 added/deleted lines";
+  }
+  const deciding = deciding_paths(paths);
+  if (deciding.length === 0) return "no changed paths; the default level stands";
+  return `changed paths that execute or instruct: ${path_decision.format_path_list(deciding)}`;
+}
+var review_level = {
+  DEFAULT_LEVEL,
+  REDUCED_LEVEL,
+  INERT_PATHS,
+  INERT_PREFIXES,
+  INERT_SUFFIXES,
+  is_inert,
+  level_for,
+  deciding_paths,
+  format_reason
+};
+
+// scripts/review/review-round2.ts
+import { z } from "zod";
+var REQUIRED_VERDICT = "required";
+var SKIPPED_VERDICT = "skip";
+var VERDICTS = [REQUIRED_VERDICT, SKIPPED_VERDICT];
+var CODE = {
+  EMPTY: "empty",
+  INERT: "inert",
+  OPEN_FINDING: "open-finding",
+  NO_SNAPSHOT: "no-snapshot",
+  BASE_MOVED: "base-moved",
+  LIVE: "live",
+  LOW: "low"
+};
+var JSON_KEY = "round2";
+var json_schema = z.object({
+  [JSON_KEY]: z.enum(VERDICTS),
+  code: z.enum(Object.values(CODE)),
+  reason: z.string()
+});
+var OPEN_FINDING_REASON = "the ledger does not show every round-1 High/Medium finding closed, so the pass that verifies them is due";
+var NO_SNAPSHOT_REASON = "no round-1 snapshot was recorded, so the fix delta cannot be named \u2014 the round runs rather than assuming it is empty";
+var EMPTY_DELTA_REASON_PREFIX = "the fix delta is empty: round 1 wrote no fix code, so there is no unreviewed fix for a verification pass to read";
+var INERT_DELTA_REASON_PREFIX = "every path round 1 fixed leaves what executes unchanged \u2014 inert, documentation, a prompt, a metrics approval, or a comment-only edit";
+var README_PATH = "README.md";
+var DOCUMENTATION_PREFIX = "docs/";
+var MARKDOWN_EXTENSION = ".md";
+var PROMPTS_PREFIX = "prompts/";
+var BASE_MOVED_REASON = "the change base moved since round 1 was recorded and round 1's tree could not be carried onto the new one \u2014 no recorded round-1 blobs, or the carry conflicts \u2014 so the fix delta cannot be named and the round runs";
+function empty_reason(taken_at) {
+  return `${EMPTY_DELTA_REASON_PREFIX} (round 1 was recorded at ${taken_at})`;
+}
+function inert_reason(delta) {
+  return `${INERT_DELTA_REASON_PREFIX}: ${delta.join(", ")}`;
+}
+function live_reason(deciding) {
+  return `round 1's fixes touched paths that execute, instruct or ship: ${path_decision.format_path_list(deciding)}`;
+}
+function is_documentation(relative) {
+  if (relative === README_PATH || relative.startsWith(PROMPTS_PREFIX)) return true;
+  return relative.startsWith(DOCUMENTATION_PREFIX) && relative.endsWith(MARKDOWN_EXTENSION);
+}
+function is_unexecuted(relative, comment_only) {
+  if (review_level.is_inert(relative) || is_documentation(relative) || release_approval_prune.is_approval(relative)) {
+    return true;
+  }
+  return comment_only.includes(relative);
+}
+function verdict_for_delta(delta, taken_at, comment_only = [], level) {
+  if (level === review_level.REDUCED_LEVEL) {
+    return {
+      verdict: SKIPPED_VERDICT,
+      code: CODE.LOW,
+      reason: `low review level has one round: ${delta.join(", ")}`
+    };
+  }
+  if (delta.length === 0) {
+    return { verdict: SKIPPED_VERDICT, code: CODE.EMPTY, reason: empty_reason(taken_at) };
+  }
+  const deciding = delta.filter((relative) => !is_unexecuted(relative, comment_only));
+  if (deciding.length === 0) {
+    return { verdict: SKIPPED_VERDICT, code: CODE.INERT, reason: inert_reason(delta) };
+  }
+  return { verdict: REQUIRED_VERDICT, code: CODE.LIVE, reason: live_reason(deciding) };
+}
+function required(code, reason) {
+  return { verdict: REQUIRED_VERDICT, code, reason, delta: [] };
+}
+function fix_delta(input, snapshot) {
+  if (file_map_stamp.describes_base(snapshot, input.base)) {
+    return file_map_stamp.changed_since(snapshot, input.tree);
+  }
+  return input.carried_delta?.(snapshot);
+}
+function decide(input) {
+  if (!input.is_round_one_closed) {
+    return required(CODE.OPEN_FINDING, input.open_reason ?? OPEN_FINDING_REASON);
+  }
+  if (input.snapshot === void 0) return required(CODE.NO_SNAPSHOT, NO_SNAPSHOT_REASON);
+  const delta = fix_delta(input, input.snapshot);
+  if (delta === void 0) return required(CODE.BASE_MOVED, BASE_MOVED_REASON);
+  return {
+    ...verdict_for_delta(delta, input.snapshot.taken_at, input.comment_only, input.level),
+    delta
+  };
+}
+function to_json(answer) {
+  return JSON.stringify({ [JSON_KEY]: answer.verdict, code: answer.code, reason: answer.reason });
+}
+function parse_json(text) {
+  const parsed = json_schema.safeParse(json_value.parse_or_undefined(text.trim())).data;
+  return parsed === void 0 ? void 0 : { verdict: parsed[JSON_KEY], code: parsed.code, reason: parsed.reason };
+}
+var review_round2 = {
+  BASE_MOVED_REASON,
+  CODE,
+  decide,
+  EMPTY_DELTA_REASON_PREFIX,
+  empty_reason,
+  INERT_DELTA_REASON_PREFIX,
+  inert_reason,
+  is_unexecuted,
+  JSON_KEY,
+  live_reason,
+  NO_SNAPSHOT_REASON,
+  OPEN_FINDING_REASON,
+  parse_json,
+  REQUIRED_VERDICT,
+  SKIPPED_VERDICT,
+  to_json,
+  verdict_for_delta
+};
+
+export {
+  review_level,
+  review_round2
+};