@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-NZ2UKIY5.js

@@ -0,0 +1,445 @@
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  lane_breakdown_laps
+} from "./chunk-E5CGA7FC.js";
+import {
+  lane_breakdown_calls,
+  lane_breakdown_implement
+} from "./chunk-UWLANGIR.js";
+import {
+  lane_breakdown
+} from "./chunk-2MDLCJZ4.js";
+import {
+  lane_net_time
+} from "./chunk-LAUKNN57.js";
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-breakdown-pinned.ts
+var MAX_SHOWN = 5;
+var DISCARDED_LABEL = "background test:pinned probes discarded";
+var TYPE_CHECK_LABEL = "type check";
+function is_lane_row(entry, issue) {
+  return entry.kind === lane_ledger.KIND.TEST_PINNED && entry.issue === issue;
+}
+function is_discarded(entry) {
+  return entry.discarded === true;
+}
+function is_in_pre_detach(entry, breakdown) {
+  const at_ms = Date.parse(entry.at);
+  return breakdown.pre_detach.some((span) => at_ms >= span.from_ms && at_ms <= span.to_ms);
+}
+function rows_of(entries, issue, breakdown) {
+  return entries.filter((entry) => is_lane_row(entry, issue)).filter((entry) => !is_discarded(entry) && is_in_pre_detach(entry, breakdown));
+}
+function discarded_text(entries, issue) {
+  const rows = entries.filter((entry) => is_lane_row(entry, issue)).filter((entry) => is_discarded(entry));
+  if (rows.length === 0) return "";
+  const elapsed_ms = rows.reduce((sum, row) => sum + row.elapsed_ms, 0);
+  return `${DISCARDED_LABEL} ${String(rows.length)}, ${lane_breakdown.minutes_text(elapsed_ms)}`;
+}
+function probe_text(probe) {
+  const tests = probe.tests === void 0 ? "" : ` ${String(probe.tests)} test files`;
+  const pinned_by = probe.pinned_by === void 0 ? "" : ` (${TYPE_CHECK_LABEL})`;
+  return `${probe.file}${tests} ${lane_breakdown.minutes_text(probe.elapsed_ms)}${pinned_by}`;
+}
+function skipped_counts(rewired, over_cap) {
+  const named = [
+    [rewired, "rewired"],
+    [over_cap, "over cap"]
+  ];
+  return named.filter(([count2]) => count2 > 0).map(([count2, label]) => `${String(count2)} ${label}`);
+}
+function detail_text(rows) {
+  if (rows.length === 0) return "";
+  const probes = rows.flatMap((row) => row.probes).toSorted((left, right) => right.elapsed_ms - left.elapsed_ms);
+  const held = rows.reduce((sum, row) => sum + row.held, 0);
+  const rewired = rows.reduce((sum, row) => sum + (row.rewired ?? 0), 0);
+  const over_cap = rows.reduce((sum, row) => sum + (row.over_cap ?? 0), 0);
+  const total = held + rewired + over_cap + probes.length;
+  const head = `test:pinned ${String(total)} hunks, ${String(held)} cached, ${String(probes.length)} probed`;
+  const counts = [head, ...skipped_counts(rewired, over_cap)];
+  return ` (${[...counts, ...probes.slice(0, MAX_SHOWN).map((probe) => probe_text(probe))].join(", ")})`;
+}
+var lane_breakdown_pinned = { detail_text, discarded_text, rows_of };
+
+// scripts/lane/lane-breakdown-related.ts
+var LABEL = "test:related";
+function is_lane_row2(entry, issue) {
+  return entry.kind === lane_ledger.KIND.TEST_RELATED && entry.issue === issue;
+}
+function top_hub(rows) {
+  const tally = /* @__PURE__ */ new Map();
+  for (const { over_cap_hub } of rows) {
+    if (over_cap_hub !== void 0) tally.set(over_cap_hub, (tally.get(over_cap_hub) ?? 0) + 1);
+  }
+  return [...tally].toSorted((first, second) => second[1] - first[1])[0]?.[0];
+}
+function over_cap_text(entries, issue) {
+  const rows = entries.filter((entry) => is_lane_row2(entry, issue));
+  const over_cap = Math.max(0, ...rows.map((row) => row.over_cap ?? 0));
+  if (over_cap === 0) return "";
+  const capped = rows.filter((row) => (row.over_cap ?? 0) > 0).length;
+  const hub = top_hub(rows);
+  const text2 = `${LABEL} ${String(over_cap)} over cap, in ${String(capped)} of ${String(rows.length)} runs`;
+  return hub === void 0 ? text2 : `${text2}, hub ${hub}`;
+}
+var lane_breakdown_related = { over_cap_text };
+
+// scripts/lane/lane-check-stats.ts
+var DECIMALS = 1;
+var WHOLE_GATE_LABEL = "gate (whole)";
+var COLUMNS = ["check", "median (s)", "max (s)", "runs", "reused", "no-op", "fallback"];
+var FALLBACK_COLUMNS = ["fallback reason", "runs"];
+var RELATED_LABEL = "test:related";
+function is_gate(entry) {
+  return entry.kind === lane_ledger.KIND.GATE;
+}
+function cell(milliseconds) {
+  return milliseconds === void 0 ? lane_stage_stats.NOT_MEASURED : (milliseconds / MS_PER_SECOND).toFixed(DECIMALS);
+}
+function header(columns) {
+  return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => "---"))];
+}
+function count(runs, is_counted) {
+  return String(runs.filter((check) => is_counted(check)).length);
+}
+function check_row(label, checks) {
+  const runs = checks.filter((check) => check.label === label);
+  const timed = runs.filter((check) => check.is_reused !== true && check.is_unmoved !== true);
+  const elapsed = timed.map((check) => check.elapsed_ms);
+  return lane_stats.to_row([
+    label,
+    cell(lane_stats.median(elapsed)),
+    cell(lane_stats.peak(elapsed)),
+    String(runs.length),
+    count(runs, (check) => check.is_reused === true),
+    count(runs, (check) => check.is_unmoved === true),
+    count(runs, (check) => check.fallback !== void 0)
+  ]);
+}
+function whole_gate(gate) {
+  return {
+    label: WHOLE_GATE_LABEL,
+    elapsed_ms: gate.elapsed_ms,
+    is_passed: gate.is_passed,
+    is_reused: gate.is_reused
+  };
+}
+function is_push_miss(entry) {
+  return entry.kind === lane_ledger.KIND.PUSH_MISS;
+}
+function is_related_lap(entry) {
+  return entry.kind === lane_ledger.KIND.SHIP_LAP && entry.step.split(" \u203A ").at(-1) === RELATED_LABEL;
+}
+function related_checks(entries) {
+  return entries.filter(is_related_lap).map((entry) => ({
+    label: RELATED_LABEL,
+    elapsed_ms: entry.elapsed_ms,
+    is_reused: entry.is_reused
+  }));
+}
+function push_reason(miss) {
+  return `pre-push ${miss.scope}: ${miss.reason}`;
+}
+function fallback_table(checks, misses) {
+  const fallbacks = checks.map((check) => check.fallback).filter((reason) => reason !== void 0);
+  const reasons = [...fallbacks, ...misses.map((miss) => push_reason(miss))];
+  const kinds = [...new Set(reasons)];
+  const rows = kinds.map(
+    (kind) => lane_stats.to_row([kind, String(reasons.filter((reason) => reason === kind).length)])
+  );
+  return [...header(FALLBACK_COLUMNS), ...rows].join("\n");
+}
+function table(entries, window) {
+  const windowed = lane_stats.in_window(entries, window);
+  const gates = windowed.filter(is_gate);
+  const checks = [...gates.flatMap((gate) => gate.checks ?? []), ...related_checks(windowed)];
+  const rows = [...gates.map((gate) => whole_gate(gate)), ...checks];
+  const labels = [...new Set(rows.map((row) => row.label))];
+  return [
+    [...header(COLUMNS), ...labels.map((label) => check_row(label, rows))].join("\n"),
+    fallback_table(checks, windowed.filter(is_push_miss))
+  ].join("\n\n");
+}
+var lane_check_stats = { WHOLE_GATE_LABEL, cell, header, table };
+
+// scripts/lane/lane-ci-path-stats.ts
+var COLUMNS2 = ["followup critical path", "runs", "median (s)", "max (s)"];
+function settled({ last_check, check_ms }) {
+  if (last_check === void 0) return void 0;
+  const elapsed_ms = check_ms?.[last_check];
+  return elapsed_ms === void 0 ? void 0 : { name: last_check, elapsed_ms };
+}
+function last_check_of(entry) {
+  if (entry.kind !== lane_ledger.KIND.STAGE || entry.stage !== lane_ledger_write.CI_WAIT_STAGE) {
+    return void 0;
+  }
+  return settled(entry);
+}
+function name_row(name, lasts) {
+  const elapsed = lasts.filter((last) => last.name === name).map((last) => last.elapsed_ms);
+  return lane_stats.to_row([
+    name,
+    String(elapsed.length),
+    lane_check_stats.cell(lane_stats.median(elapsed)),
+    lane_check_stats.cell(lane_stats.peak(elapsed))
+  ]);
+}
+function table2(entries, window) {
+  const lasts = lane_stats.in_window(entries, window).filter((entry) => entry.kind !== lane_ledger.KIND.STAGE || entry.has_rerun !== true).map((entry) => last_check_of(entry)).filter((last) => last !== void 0);
+  const names = [...new Set(lasts.map((last) => last.name))];
+  return [...lane_check_stats.header(COLUMNS2), ...names.map((name) => name_row(name, lasts))].join(
+    "\n"
+  );
+}
+function latest_check(entries, issue) {
+  return entries.filter((entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue).map((entry) => last_check_of(entry)).findLast((found) => found !== void 0);
+}
+function last_check_name(entries, issue) {
+  return latest_check(entries, issue)?.name;
+}
+function last_check_text(entries, issue) {
+  const last = latest_check(entries, issue);
+  return last === void 0 ? "" : ` (last check: ${last.name} ${lane_check_stats.cell(last.elapsed_ms)}s)`;
+}
+var lane_ci_path_stats = { last_check_name, last_check_text, table: table2 };
+
+// scripts/lane/lane-elapsed-time.ts
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write"]);
+var AUTOMATIC_STAGES = /* @__PURE__ */ new Set([
+  "gate",
+  "pre-detach",
+  "followup",
+  lane_ledger.CI_WAIT_STAGE
+]);
+function tool_spans(calls) {
+  return calls.flatMap(
+    (call) => call.duration_ms === void 0 || EDIT_TOOLS.has(call.tool ?? "") ? [] : { from_ms: call.started_ms, to_ms: call.started_ms + call.duration_ms }
+  );
+}
+function stage_spans(entries, issue) {
+  return entries.flatMap(
+    (entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue && AUTOMATIC_STAGES.has(entry.stage) ? { from_ms: Date.parse(entry.at) - entry.elapsed_ms, to_ms: Date.parse(entry.at) } : []
+  );
+}
+function human_spans(entries, events, issue, span) {
+  return lane_net_time.hold_waits(
+    entries,
+    events.filter((event) => event.kind === "park"),
+    issue,
+    span
+  );
+}
+function tool_ms(span, calls) {
+  return tool_spans(calls).reduce((sum, call) => sum + lane_breakdown.covered_ms(span, [call]), 0);
+}
+function partition(span, human, automatic, calls) {
+  const total_ms = span.to_ms - span.from_ms;
+  const human_ms = lane_breakdown.covered_ms(span, human);
+  const occupied_ms = lane_breakdown.covered_ms(span, [...human, ...automatic]);
+  const remainder_ms = total_ms - occupied_ms;
+  return {
+    total_ms,
+    human_ms,
+    automatic_ms: occupied_ms - human_ms,
+    work_ms: calls.length > 0 ? remainder_ms : 0,
+    unclassified_ms: calls.length > 0 ? 0 : remainder_ms,
+    tool_ms: tool_ms(span, calls),
+    within_target: total_ms <= lane_stage_budget.TARGET_MINUTES * MS_PER_MINUTE
+  };
+}
+function of(entries, events, issue, calls) {
+  const span = lane_net_time.span_of(entries, issue);
+  if (span === void 0) return void 0;
+  const human = human_spans(entries, events, issue, span);
+  const automatic = [
+    ...lane_net_time.automatic_waits(entries, events, issue, span),
+    ...stage_spans(entries, issue),
+    ...tool_spans(calls)
+  ];
+  return partition(span, human, automatic, calls);
+}
+function text(timing) {
+  const minutes = lane_breakdown.minutes_text;
+  const status = timing.within_target ? "within target" : "over target";
+  return [
+    `End-to-end ${minutes(timing.total_ms)} (${status}); ${lane_stage_budget.DESCRIPTION}`,
+    `Exclusive wall clock: off-tool work ${minutes(timing.work_ms)}; automatic wait ${minutes(timing.automatic_ms)}; human wait ${minutes(timing.human_ms)}; unclassified (missing transcripts) ${minutes(timing.unclassified_ms)}`,
+    `Tool cumulative ${minutes(timing.tool_ms)} (parallel calls overlap; not additive to wall clock). Off-tool work includes unrecorded activity; automatic wait includes tool responses, gate, CI, yield, outage and sleep. Legacy net excludes more than human wait.`
+  ].join("\n");
+}
+var lane_elapsed_time = { of, text };
+
+// scripts/lane/lane-breakdown-text.ts
+var HEADING = "Net time by stage, longest first";
+var EXCLUDED = "waits taken out (park, outage, usage limit, yield, split run, host sleep)";
+var SLEPT = "of which host sleep";
+var YIELDED = "of which yield wait";
+var HOLDER = "yield wait: holder remaining";
+var GAP = "yield wait: redispatch gap (offer + launch)";
+var UNSPLIT = "yield wait: no holder named, unsplit";
+var OUTSIDE = "outside calls";
+var DRIVER = "(outside lane net)";
+function part_text(part) {
+  return `${part.name} ${lane_breakdown.minutes_text(part.ms)}`;
+}
+function budget_of(name) {
+  const stages = {
+    [lane_breakdown.PLAN_STAGE]: "plan",
+    [lane_breakdown.IMPLEMENT_STAGE]: "implement",
+    [lane_breakdown.DRIVER_FOLLOWUP_STAGE]: "followup"
+  };
+  const ship = lane_breakdown.is_ship_stage(name) ? "ship" : void 0;
+  return stages[name] ?? ship;
+}
+function over_text(stage) {
+  const budget = budget_of(stage.name);
+  const over = budget === void 0 ? void 0 : lane_stage_budget.over_minutes(budget, stage.ms);
+  return over === void 0 ? "" : `, over budget +${String(over)} min`;
+}
+function kind_text(kind, untimed) {
+  const count2 = untimed.get(kind.name) ?? 0;
+  return count2 > 0 ? `${part_text(kind)} + ${String(count2)} backgrounded, untimed` : part_text(kind);
+}
+function detail_text2(detail) {
+  const kinds = detail.kinds.map((kind) => kind_text(kind, detail.untimed));
+  const count2 = String(detail.background);
+  const background = detail.background > 0 ? [`${count2} backgrounded calls, their waits in editing & thinking`] : [];
+  return ` (${[...kinds, ...background].join(", ")})`;
+}
+function reason_text(reason) {
+  return reason === void 0 ? "" : ` (${reason})`;
+}
+function outside_text(outside) {
+  if (outside === void 0) return void 0;
+  const minutes = `${OUTSIDE} ${lane_breakdown.minutes_text(outside.ms)}`;
+  const count2 = String(outside.background);
+  const background = outside.background > 0 ? [`${count2} backgrounded calls, their waits in it`] : [];
+  return ` (${[minutes, ...background].join(", ")})`;
+}
+function suffix_of(name, report) {
+  const suffixes = {
+    [lane_breakdown.PLAN_STAGE]: outside_text(report.plan_outside),
+    [lane_breakdown.IMPLEMENT_STAGE]: detail_text2(report.detail),
+    [lane_breakdown.PRE_DETACH_STAGE]: report.pinned
+  };
+  return suffixes[name] ?? reason_text(report.breakdown.reasons?.get(name));
+}
+function implement_calls(detail) {
+  return detail.kinds.flatMap(
+    (kind) => (detail.calls?.get(kind.name) ?? []).map(
+      (group) => `${kind.name} \u203A ${lane_breakdown_calls.group_text(group)}`
+    )
+  );
+}
+function calls_of(name, report) {
+  if (name === lane_breakdown.IMPLEMENT_STAGE) return implement_calls(report.detail);
+  if (name !== lane_breakdown.PLAN_STAGE) return [];
+  return (report.plan_calls ?? []).map((group) => lane_breakdown_calls.group_text(group));
+}
+function stage_entry(stage, report) {
+  const laps = report.laps?.get(stage.name) ?? [];
+  return {
+    text: `${part_text(stage)}${over_text(stage)}${suffix_of(stage.name, report)}`,
+    laps: laps.map((lap) => part_text(lap)),
+    calls: calls_of(stage.name, report)
+  };
+}
+function yield_lines(breakdown) {
+  const split = breakdown.yield_split;
+  if (split === void 0 || breakdown.yield_ms === 0) return [];
+  const named = [
+    { name: HOLDER, ms: split.holder_ms },
+    { name: GAP, ms: split.gap_ms }
+  ];
+  const unsplit = [{ name: UNSPLIT, ms: split.unsplit_ms }];
+  return [
+    ...split.holder_ms + split.gap_ms > 0 ? named : [],
+    ...split.unsplit_ms > 0 ? unsplit : []
+  ].map((part) => part_text(part));
+}
+function excluded_entry(breakdown) {
+  const yielded = `${YIELDED} ${lane_breakdown.minutes_text(breakdown.yield_ms)}`;
+  const slept = `${SLEPT} ${lane_breakdown.minutes_text(breakdown.slept_ms)}`;
+  const excluded = `${EXCLUDED} ${lane_breakdown.minutes_text(breakdown.excluded_ms)}, ${yielded}, ${slept}`;
+  return { text: excluded, laps: yield_lines(breakdown), calls: [] };
+}
+function driver_entry(stage, report) {
+  const laps = report.laps?.get(lane_breakdown.FOLLOWUP_STAGE) ?? [];
+  return {
+    text: `${part_text(stage)} ${DRIVER}${over_text(stage)}${report.critical ?? ""}`,
+    laps: laps.map((lap) => part_text(lap)),
+    calls: []
+  };
+}
+function entries_of(report) {
+  const { breakdown } = report;
+  const notes = [report.discarded, report.related].filter((text2) => text2 !== void 0 && text2 !== "").map((text2) => ({ text: text2, laps: [], calls: [] }));
+  return [
+    ...breakdown.stages.map((stage) => stage_entry(stage, report)),
+    ...notes,
+    excluded_entry(breakdown),
+    ...(breakdown.driver ?? []).map((stage) => driver_entry(stage, report))
+  ];
+}
+function bullets_of(entry) {
+  return [`- ${entry.text}`, ...[...entry.laps, ...entry.calls].map((lap) => `  - ${lap}`)];
+}
+function inline_of(entry) {
+  return entry.laps.length > 0 ? `${entry.text} [${entry.laps.join(", ")}]` : entry.text;
+}
+function report_of(issue, breakdown, entries, events = []) {
+  const calls = lane_breakdown_implement.read(issue, breakdown);
+  const rows = lane_breakdown_pinned.rows_of(entries, issue, breakdown);
+  const timing = lane_elapsed_time.of(entries, events, issue, calls);
+  return {
+    elapsed: timing === void 0 ? void 0 : lane_elapsed_time.text(timing),
+    breakdown,
+    detail: lane_breakdown_implement.of(calls, breakdown),
+    laps: lane_breakdown_laps.of(entries, issue, breakdown, calls),
+    pinned: lane_breakdown_pinned.detail_text(rows),
+    discarded: lane_breakdown_pinned.discarded_text(entries, issue),
+    related: lane_breakdown_related.over_cap_text(entries, issue),
+    critical: lane_ci_path_stats.last_check_text(entries, issue),
+    plan_calls: lane_breakdown_implement.plan_calls(calls, breakdown),
+    plan_outside: lane_breakdown_implement.plan_outside(calls, breakdown)
+  };
+}
+function comment(issue, minutes, report) {
+  const lead = `${HEADING}, ${String(minutes)} min of net time`;
+  const source = `(\`pnpm josh lane:breakdown ${String(issue)}\`):`;
+  return [
+    `${lead} ${source}`,
+    "",
+    ...entries_of(report).flatMap((entry) => bullets_of(entry)),
+    ...report.elapsed === void 0 ? [] : [report.elapsed]
+  ].join("\n");
+}
+function line(report) {
+  return `${HEADING}: ${entries_of(report).map((entry) => inline_of(entry)).join("; ")}.`;
+}
+var lane_breakdown_text = { budget_of, comment, line, report_of };
+
+export {
+  lane_breakdown_related,
+  lane_check_stats,
+  lane_ci_path_stats,
+  lane_breakdown_text
+};

package/dist/commands/chunk-OB3WF3DW.js

@@ -0,0 +1,24 @@
+import {
+  time_format
+} from "./chunk-4P5F7CLB.js";
+
+// scripts/lint/lint-timing.ts
+var MARK = " timing \u2014 ";
+var SEPARATOR = " \xB7 ";
+function line(timing) {
+  const tools = [
+    `prettier ${time_format.format_seconds(timing.prettier_ms)}`,
+    `eslint ${time_format.format_seconds(timing.eslint_ms)}`
+  ];
+  return `${timing.label}${MARK}${[...tools, ...timing.facts].join(SEPARATOR)}
+`;
+}
+function detail_of(label, output) {
+  const prefix = `${label}${MARK}`;
+  return output.split("\n").find((text) => text.startsWith(prefix))?.slice(prefix.length);
+}
+var lint_timing = { detail_of, line };
+
+export {
+  lint_timing
+};

package/dist/commands/chunk-OBMXXG5D.js

@@ -0,0 +1,181 @@
+import {
+  path_decision
+} from "./chunk-EYR2X5MZ.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  release_approval_prune
+} from "./chunk-G6H2TOAA.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
+};