@mrciphersmith/keryx 0.3.116 → 0.3.118

package/dist/core.js

@@ -11945,6 +11945,9 @@ function renderMetaprojectGitignoreBlock() {
 # Recommendation journal (flow 392): what the human chose and why they deviated.
 # Personal runtime state, written 0o600.
 .metaproject/data/decisions/
+# \`keryx review mutate\` runs the project's tests in a scratch copy of the tree under here; it is
+# removed when the run ends, but a killed run can leave it behind.
+.metaproject/data/review/mutate-scratch/
 `;
 }
 function escapeRegExp2(value) {
@@ -26582,6 +26585,24 @@ function globToRegExp(glob) {
 }
 
 // src/review/scope.ts
+var SCOPE_DROP_REASONS = [
+  "lockfile",
+  "generated",
+  "vendored",
+  "snapshot",
+  "minified",
+  "binary",
+  "whitespace-only",
+  "comment-only"
+];
+var DEFAULT_CONTEXT_LINES = 20;
+var DEFAULT_REVIEW_SCOPE_CONFIG = {
+  contextLines: DEFAULT_CONTEXT_LINES,
+  detectWhitespaceOnly: true,
+  detectCommentOnly: true,
+  retainCommentBlocks: false,
+  additionalGeneratedDirectories: []
+};
 var LOCKFILE_BASENAMES = new Set([
   "package-lock.json",
   "npm-shrinkwrap.json",
@@ -26628,7 +26649,182 @@ var SOURCE_ROOT_SEGMENTS = new Set([
   "specs",
   "__tests__"
 ]);
+var GENERATED_SUFFIXES = [
+  ".js.map",
+  ".mjs.map",
+  ".cjs.map",
+  ".css.map",
+  ".pb.go",
+  ".pb.cc",
+  ".pb.h",
+  "_pb2.py",
+  "_pb2_grpc.py",
+  ".generated.ts",
+  ".g.dart",
+  ".freezed.dart"
+];
+var MINIFIED_SUFFIXES = [".min.js", ".min.mjs", ".min.cjs", ".min.css"];
 var SNAPSHOT_DIRECTORIES = new Set(["__snapshots__"]);
+var SNAPSHOT_SUFFIXES = [".snap"];
+function classifyPath(path, config = DEFAULT_REVIEW_SCOPE_CONFIG) {
+  const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
+  const segments = normalized.split("/").filter((segment) => segment.length > 0);
+  const basename = segments.at(-1) ?? normalized;
+  const directories = segments.slice(0, -1);
+  for (const segment of directories) {
+    if (VENDOR_DIRECTORIES.has(segment)) {
+      return { reason: "vendored", detail: `vendored: path segment "${segment}/"` };
+    }
+  }
+  const extraGenerated = new Set(config.additionalGeneratedDirectories);
+  let sawSourceRoot = false;
+  for (const segment of directories) {
+    if (GENERATED_DIRECTORIES.has(segment)) {
+      return { reason: "generated", detail: `generated: build-output directory "${segment}/"` };
+    }
+    if (extraGenerated.has(segment)) {
+      return { reason: "generated", detail: `generated: project-configured directory "${segment}/"` };
+    }
+    if (AMBIGUOUS_GENERATED_DIRECTORIES.has(segment) && !sawSourceRoot) {
+      return { reason: "generated", detail: `generated: build-output directory "${segment}/" with no source root above it` };
+    }
+    if (SOURCE_ROOT_SEGMENTS.has(segment)) {
+      sawSourceRoot = true;
+    }
+  }
+  for (const segment of directories) {
+    if (SNAPSHOT_DIRECTORIES.has(segment)) {
+      return { reason: "snapshot", detail: `snapshot: path segment "${segment}/"` };
+    }
+  }
+  if (SNAPSHOT_SUFFIXES.some((suffix) => basename.endsWith(suffix))) {
+    return { reason: "snapshot", detail: `snapshot: filename ends with "${SNAPSHOT_SUFFIXES.find((s) => basename.endsWith(s)) ?? ""}"` };
+  }
+  if (LOCKFILE_BASENAMES.has(basename)) {
+    return { reason: "lockfile", detail: `lockfile: dependency-manager output "${basename}"` };
+  }
+  const minified = MINIFIED_SUFFIXES.find((suffix) => basename.endsWith(suffix));
+  if (minified !== undefined) {
+    return { reason: "minified", detail: `minified: filename ends with "${minified}"` };
+  }
+  const generatedSuffix = GENERATED_SUFFIXES.find((suffix) => basename.endsWith(suffix));
+  if (generatedSuffix !== undefined) {
+    return { reason: "generated", detail: `generated: filename ends with "${generatedSuffix}"` };
+  }
+  return null;
+}
+var HUNK_HEADER = /^@@+ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+function stripDiffPathPrefix(raw) {
+  const withoutTimestamp = raw.split("\t")[0] ?? raw;
+  const trimmed = withoutTimestamp.trim();
+  if (trimmed === "/dev/null") {
+    return trimmed;
+  }
+  return /^[ab]\//.test(trimmed) ? trimmed.slice(2) : trimmed;
+}
+function parseUnifiedDiff(diff) {
+  const files = [];
+  let current;
+  let hunk;
+  let newCursor = 0;
+  let pendingOldPath;
+  const closeHunk = () => {
+    if (hunk !== undefined && current !== undefined) {
+      current.hunks.push(hunk);
+    }
+    hunk = undefined;
+  };
+  const closeFile = () => {
+    closeHunk();
+    if (current !== undefined) {
+      files.push(current);
+    }
+    current = undefined;
+    pendingOldPath = undefined;
+  };
+  for (const line of diff.split(/\r?\n/)) {
+    if (line.startsWith("diff --git ")) {
+      closeFile();
+      const match = /^diff --git (.+?) (\S+)$/.exec(line);
+      const path = match ? stripDiffPathPrefix(match[2]) : "";
+      current = { path, binary: false, hunks: [] };
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      closeHunk();
+      pendingOldPath = stripDiffPathPrefix(line.slice(4));
+      if (current === undefined) {
+        current = { path: pendingOldPath, binary: false, hunks: [] };
+      }
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      closeHunk();
+      const newPath = stripDiffPathPrefix(line.slice(4));
+      if (current === undefined) {
+        current = { path: newPath, binary: false, hunks: [] };
+      }
+      const resolved = newPath === "/dev/null" ? pendingOldPath ?? current.path : newPath;
+      if (resolved.length > 0 && resolved !== "/dev/null") {
+        current.path = resolved;
+      }
+      continue;
+    }
+    if (current !== undefined && (line.startsWith("Binary files ") || line.startsWith("GIT binary patch"))) {
+      closeHunk();
+      current.binary = true;
+      continue;
+    }
+    const header = HUNK_HEADER.exec(line);
+    if (header !== null && current !== undefined) {
+      closeHunk();
+      newCursor = Number.parseInt(header[3], 10);
+      hunk = { header: line, lines: [] };
+      continue;
+    }
+    if (hunk === undefined) {
+      continue;
+    }
+    if (line.startsWith("\\")) {
+      continue;
+    }
+    const marker = line.charAt(0);
+    const anchor = Math.max(1, newCursor);
+    if (marker === "+") {
+      hunk.lines.push({ kind: "add", raw: line, text: line.slice(1), anchor });
+      newCursor += 1;
+      continue;
+    }
+    if (marker === "-") {
+      hunk.lines.push({ kind: "del", raw: line, text: line.slice(1), anchor });
+      continue;
+    }
+    if (marker === " " || line.length === 0) {
+      hunk.lines.push({ kind: "context", raw: line, text: line.slice(1), anchor });
+      newCursor += 1;
+      continue;
+    }
+    closeHunk();
+  }
+  closeFile();
+  return files.filter((file) => file.path.length > 0 && file.path !== "/dev/null");
+}
+function changeBlocks(hunk) {
+  const blocks = [];
+  let start;
+  for (let index = 0;index <= hunk.lines.length; index += 1) {
+    const line = hunk.lines[index];
+    const changed = line !== undefined && line.kind !== "context";
+    if (changed && start === undefined) {
+      start = index;
+    }
+    if (!changed && start !== undefined) {
+      blocks.push({ from: start, to: index, lines: hunk.lines.slice(start, index) });
+      start = undefined;
+    }
+  }
+  return blocks;
+}
 var INDENT_SIGNIFICANT_EXTENSIONS = new Set([
   ".py",
   ".pyi",
@@ -26648,6 +26844,47 @@ var INDENT_SIGNIFICANT_EXTENSIONS = new Set([
   ".coffee",
   ".nim"
 ]);
+function extensionOf(path) {
+  const basename = path.split("/").at(-1) ?? path;
+  const dot = basename.lastIndexOf(".");
+  return dot <= 0 ? "" : basename.slice(dot).toLowerCase();
+}
+var STRING_LITERAL = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`/g;
+function hasUnterminatedQuote(text) {
+  return /["'`]/.test(text.replace(STRING_LITERAL, ""));
+}
+function normalizeForWhitespace(text, indentSignificant) {
+  if (indentSignificant) {
+    return text.replace(/\s+$/, "");
+  }
+  let normalized = "";
+  let cursor = 0;
+  for (const match of text.matchAll(STRING_LITERAL)) {
+    const index = match.index ?? 0;
+    normalized += text.slice(cursor, index).replace(/\s+/g, " ") + match[0];
+    cursor = index + match[0].length;
+  }
+  normalized += text.slice(cursor).replace(/\s+/g, " ");
+  return normalized.trim();
+}
+function isWhitespaceOnly(hunk, block, indentSignificant) {
+  if (!indentSignificant && hunk.lines.some((line) => hasUnterminatedQuote(line.text))) {
+    return false;
+  }
+  const removed = [];
+  const added = [];
+  for (const line of block.lines) {
+    const normalized = normalizeForWhitespace(line.text, indentSignificant);
+    if (normalized.length === 0) {
+      continue;
+    }
+    (line.kind === "del" ? removed : added).push(normalized);
+  }
+  if (removed.length !== added.length) {
+    return false;
+  }
+  return removed.every((value, index) => value === added[index]);
+}
 var C_FAMILY = { line: ["//"], block: true, multilineStringMarkers: ["`"] };
 var HASH_FAMILY = { line: ["#"], block: false, multilineStringMarkers: ['"""', "'''", "<<"] };
 var DASH_FAMILY = { line: ["--"], block: false, multilineStringMarkers: ["[["] };
@@ -26683,6 +26920,332 @@ var COMMENT_STYLES = new Map([
   ...[".py", ".rb", ".sh", ".bash", ".zsh", ".yml", ".yaml", ".toml", ".tf", ".tfvars"].map((extension) => [extension, HASH_FAMILY]),
   ...[".sql", ".lua"].map((extension) => [extension, DASH_FAMILY])
 ]);
+var DIRECTIVE_MARKERS = [
+  "eslint",
+  "ts-ignore",
+  "ts-expect-error",
+  "ts-nocheck",
+  "@ts-",
+  "prettier",
+  "biome-ignore",
+  "rome-ignore",
+  "oxlint",
+  "stylelint",
+  "istanbul ignore",
+  "c8 ignore",
+  "v8 ignore",
+  "coverage:",
+  "nolint",
+  "golangci",
+  "go:build",
+  "go:generate",
+  "go:embed",
+  "deno-lint",
+  "noinspection",
+  "pylint",
+  "mypy",
+  "type: ignore",
+  "noqa",
+  "flake8",
+  "pragma",
+  "nosec",
+  "bandit",
+  "shellcheck",
+  "swiftlint",
+  "codeql",
+  "sonar",
+  "keryx:",
+  "-*- coding",
+  "use strict",
+  "@flow",
+  "@jsx",
+  "clang-format",
+  "editorconfig",
+  "webpackchunkname",
+  "@vite-ignore",
+  "sourcemappingurl"
+];
+function isDirectiveComment(text) {
+  const lowered = text.toLowerCase();
+  if (lowered.trimStart().startsWith("#!")) {
+    return true;
+  }
+  return DIRECTIVE_MARKERS.some((marker) => lowered.includes(marker));
+}
+function commentFlags(lines, style) {
+  let inBlock = false;
+  if (style.block) {
+    const openIndex = lines.findIndex((line) => line.text.includes("/*"));
+    const closeIndex = lines.findIndex((line) => line.text.includes("*/"));
+    inBlock = closeIndex >= 0 && (openIndex < 0 || closeIndex < openIndex);
+  }
+  return lines.map((line) => {
+    const trimmed = line.text.trim();
+    if (inBlock) {
+      const close = trimmed.lastIndexOf("*/");
+      if (close < 0) {
+        return true;
+      }
+      inBlock = false;
+      return trimmed.slice(close + 2).trim().length === 0;
+    }
+    if (trimmed.length === 0) {
+      return true;
+    }
+    if (style.line.some((marker) => trimmed.startsWith(marker))) {
+      return true;
+    }
+    if (style.block && trimmed.startsWith("/*")) {
+      const close = trimmed.lastIndexOf("*/");
+      if (close < 0) {
+        inBlock = true;
+        return true;
+      }
+      return trimmed.slice(close + 2).trim().length === 0;
+    }
+    return false;
+  });
+}
+var BLOCK_COMMENT_DELIMITER = /\/\*|\*\//;
+var QUOTED_BLOCK_DELIMITER = /["'`][^"'`]*(?:\/\*|\*\/)/;
+function isCommentOnly(hunk, block, path) {
+  const style = COMMENT_STYLES.get(extensionOf(path));
+  if (style === undefined) {
+    return false;
+  }
+  if (style.multilineStringMarkers.some((marker) => hunk.lines.some((line) => line.text.includes(marker)))) {
+    return false;
+  }
+  if (style.block) {
+    const changedDelimiter = hunk.lines.some((line) => line.kind !== "context" && BLOCK_COMMENT_DELIMITER.test(line.text));
+    if (changedDelimiter || hunk.lines.some((line) => QUOTED_BLOCK_DELIMITER.test(line.text))) {
+      return false;
+    }
+  }
+  const flags = commentFlags(hunk.lines, style);
+  let sawComment = false;
+  for (let index = block.from;index < block.to; index += 1) {
+    const line = hunk.lines[index];
+    if (line === undefined) {
+      return false;
+    }
+    if (flags[index] !== true) {
+      return false;
+    }
+    if (line.text.trim().length === 0) {
+      continue;
+    }
+    if (isDirectiveComment(line.text)) {
+      return false;
+    }
+    sawComment = true;
+  }
+  return sawComment;
+}
+function emptyCounts() {
+  const droppedByReason = Object.fromEntries(SCOPE_DROP_REASONS.map((reason) => [reason, 0]));
+  return {
+    filesSeen: 0,
+    filesRetained: 0,
+    filesDropped: 0,
+    blocksSeen: 0,
+    blocksRetained: 0,
+    blocksDropped: 0,
+    changedLinesRetained: 0,
+    changedLinesDropped: 0,
+    droppedByReason
+  };
+}
+function resolveConfig(config) {
+  const contextLines = config?.contextLines ?? DEFAULT_REVIEW_SCOPE_CONFIG.contextLines;
+  return {
+    contextLines: Number.isFinite(contextLines) ? Math.max(0, Math.trunc(contextLines)) : DEFAULT_CONTEXT_LINES,
+    detectWhitespaceOnly: config?.detectWhitespaceOnly ?? DEFAULT_REVIEW_SCOPE_CONFIG.detectWhitespaceOnly,
+    detectCommentOnly: config?.detectCommentOnly ?? DEFAULT_REVIEW_SCOPE_CONFIG.detectCommentOnly,
+    retainCommentBlocks: config?.retainCommentBlocks ?? DEFAULT_REVIEW_SCOPE_CONFIG.retainCommentBlocks,
+    additionalGeneratedDirectories: config?.additionalGeneratedDirectories ?? DEFAULT_REVIEW_SCOPE_CONFIG.additionalGeneratedDirectories
+  };
+}
+function windowsFor(blocks, contextLines) {
+  const windows = [];
+  for (const block of blocks) {
+    const anchors = block.lines.map((line) => line.anchor);
+    const first = Math.min(...anchors);
+    const last = Math.max(...anchors);
+    const start = Math.max(1, first - contextLines);
+    const end = last + contextLines;
+    const previous = windows.at(-1);
+    if (previous !== undefined && start <= previous.end) {
+      previous.end = Math.max(previous.end, end);
+      previous.blocks.push(block);
+      continue;
+    }
+    windows.push({ start, end, blocks: [block] });
+  }
+  return windows;
+}
+function keepsCommentBlock(setting, hunk, block) {
+  if (setting === false) {
+    return false;
+  }
+  const added = [];
+  for (let index = block.from;index < block.to; index += 1) {
+    const line = hunk.lines[index];
+    if (line !== undefined && line.kind === "add" && line.text.trim().length > 0) {
+      added.push(line.text);
+    }
+  }
+  if (added.length === 0) {
+    return false;
+  }
+  if (setting === true) {
+    return true;
+  }
+  let pattern;
+  try {
+    pattern = new RegExp(setting, "i");
+  } catch {
+    return true;
+  }
+  return added.some((text) => pattern.test(text));
+}
+function buildReviewScope(diff, config) {
+  const resolved = resolveConfig(config);
+  const counts = emptyCounts();
+  const drops = [];
+  const kept = [];
+  const regions = [];
+  const files = [];
+  for (const file of parseUnifiedDiff(diff)) {
+    counts.filesSeen += 1;
+    const fileChangedLines = file.hunks.reduce((total, current) => total + current.lines.filter((line) => line.kind !== "context").length, 0);
+    const pathDrop = classifyPath(file.path, resolved);
+    if (pathDrop !== null) {
+      counts.filesDropped += 1;
+      counts.changedLinesDropped += fileChangedLines;
+      counts.droppedByReason[pathDrop.reason] += 1;
+      drops.push({
+        path: file.path,
+        reason: pathDrop.reason,
+        detail: pathDrop.detail,
+        granularity: "file",
+        changedLines: fileChangedLines
+      });
+      continue;
+    }
+    if (file.binary) {
+      counts.filesDropped += 1;
+      counts.droppedByReason.binary += 1;
+      drops.push({
+        path: file.path,
+        reason: "binary",
+        detail: "binary: the diff carries no reviewable text for this file",
+        granularity: "file",
+        changedLines: 0
+      });
+      continue;
+    }
+    const indentSignificant = INDENT_SIGNIFICANT_EXTENSIONS.has(extensionOf(file.path));
+    let retainedInFile = 0;
+    for (const hunk of file.hunks) {
+      const retained = [];
+      for (const block of changeBlocks(hunk)) {
+        counts.blocksSeen += 1;
+        const changedLines = block.lines.length;
+        const span = {
+          startLine: Math.min(...block.lines.map((line) => line.anchor)),
+          endLine: Math.max(...block.lines.map((line) => line.anchor))
+        };
+        if (resolved.detectWhitespaceOnly && isWhitespaceOnly(hunk, block, indentSignificant)) {
+          counts.blocksDropped += 1;
+          counts.changedLinesDropped += changedLines;
+          counts.droppedByReason["whitespace-only"] += 1;
+          drops.push({
+            path: file.path,
+            reason: "whitespace-only",
+            detail: indentSignificant ? "whitespace-only: trailing whitespace only (leading whitespace is significant for this file type and was compared)" : "whitespace-only: identical once whitespace is removed, with no change in line count",
+            granularity: "block",
+            startLine: span.startLine,
+            endLine: span.endLine,
+            changedLines
+          });
+          continue;
+        }
+        if (resolved.detectCommentOnly && isCommentOnly(hunk, block, file.path)) {
+          if (keepsCommentBlock(resolved.retainCommentBlocks ?? false, hunk, block)) {
+            kept.push({
+              path: file.path,
+              reason: "kept:comment-rule",
+              detail: `kept:comment-rule: comment-only block in ${extensionOf(file.path)} retained because the repository has a rule about comments`,
+              startLine: span.startLine,
+              endLine: span.endLine,
+              changedLines
+            });
+            counts.keptByReason = { ...counts.keptByReason, "kept:comment-rule": (counts.keptByReason?.["kept:comment-rule"] ?? 0) + 1 };
+            counts.blocksRetained += 1;
+            counts.changedLinesRetained += changedLines;
+            retained.push(block);
+            continue;
+          }
+          counts.blocksDropped += 1;
+          counts.changedLinesDropped += changedLines;
+          counts.droppedByReason["comment-only"] += 1;
+          drops.push({
+            path: file.path,
+            reason: "comment-only",
+            detail: `comment-only: every changed line is a comment in ${extensionOf(file.path)} and none is a tool directive`,
+            granularity: "block",
+            startLine: span.startLine,
+            endLine: span.endLine,
+            changedLines
+          });
+          continue;
+        }
+        counts.blocksRetained += 1;
+        counts.changedLinesRetained += changedLines;
+        retained.push(block);
+      }
+      if (retained.length === 0) {
+        continue;
+      }
+      const hunkFirst = hunk.lines[0]?.anchor ?? 1;
+      const hunkLast = hunk.lines.at(-1)?.anchor ?? hunkFirst;
+      for (const window of windowsFor(retained, resolved.contextLines)) {
+        const lines = hunk.lines.filter((line) => line.anchor >= window.start && line.anchor <= window.end);
+        if (lines.length === 0) {
+          continue;
+        }
+        const truncated = window.start < hunkFirst && hunkFirst > 1 || window.end > hunkLast;
+        regions.push({
+          path: file.path,
+          startLine: lines[0].anchor,
+          endLine: lines.at(-1).anchor,
+          changedLines: window.blocks.reduce((total, block) => total + block.lines.length, 0),
+          contextTruncated: truncated,
+          text: lines.map((line) => line.raw).join(`
+`)
+        });
+        retainedInFile += 1;
+      }
+    }
+    if (retainedInFile > 0) {
+      counts.filesRetained += 1;
+      files.push(file.path);
+    } else {
+      counts.filesDropped += 1;
+    }
+  }
+  return {
+    schemaVersion: 1,
+    mode: "diff",
+    contextLines: resolved.contextLines,
+    files,
+    regions,
+    drops,
+    ...kept.length > 0 ? { kept } : {},
+    counts
+  };
+}
 
 // src/review/types.ts
 var FINDING_DISPOSITION_STATES = [
@@ -28072,8 +28635,11 @@ var operatorDenials = new Set;
 
 // src/review/autonomous-answers.ts
 var ENV_AUTONOMOUS_ANSWERS_FILE = "KERYX_AUTONOMOUS_ANSWERS_FILE";
-
 // src/review/coverage.ts
+var LIGHT_MAX_FILES = 5;
+var LIGHT_MAX_CHANGED_LINES = 300;
+var LIGHT_FIXED_REVIEWERS = ["review-logic", "review-testing-practices"];
+var LIGHT_CONVENTIONS_PREFERENCE = ["review-frontend-conventions", "review-backend", "review-clean-code"];
 var NOT_ROSTER = new Set([
   "review-orchestrator",
   "review-verifier",
@@ -28095,6 +28661,85 @@ var BUNDLED_PATH_GATES = {
   "review-frontend-conventions": (f) => FRONTEND_EXT.test(f) || /\.stories\.tsx$/.test(f) || CODE_FILE.test(f),
   "review-layout": (f) => /\.(tsx|jsx|css|scss)$/.test(f)
 };
+var RISK_PATH_GATES = Object.fromEntries(Object.entries(BUNDLED_PATH_GATES).filter(([name]) => name !== "review-testing-practices" && name !== "review-frontend-conventions"));
+async function decideRoundDepth(root, request, input) {
+  if (request === "full")
+    return { requested: request, depth: "full", reason: "--depth full" };
+  const checked = await autoDepth(root, input);
+  if (request === "auto")
+    return { requested: request, ...checked };
+  return checked.depth === "light" ? { requested: request, depth: "light", reason: `--depth light: ${checked.reason}` } : { requested: request, depth: "full", reason: `--depth light not honoured: ${checked.reason.replace(/^auto: /, "")}` };
+}
+async function autoDepth(root, input) {
+  const full = (reason) => ({ depth: "full", reason });
+  if (input.forceFull !== undefined)
+    return full(`auto: ${input.forceFull} forces the full set`);
+  const files = input.files;
+  if (files === undefined)
+    return full("auto: no scope file list, so the diff size and risk class are unknown");
+  if (input.changedLines === undefined)
+    return full("auto: no line count (changed-line count unknown; pass --scope <scope.json> or --diff-lines <n>)");
+  if (files.length > LIGHT_MAX_FILES)
+    return full(`auto: ${files.length} files exceeds ${LIGHT_MAX_FILES}`);
+  if (input.changedLines > LIGHT_MAX_CHANGED_LINES)
+    return full(`auto: ${input.changedLines} changed lines exceeds ${LIGHT_MAX_CHANGED_LINES}`);
+  const hit = Object.entries(RISK_PATH_GATES).find(([, gate]) => files.some(gate));
+  if (hit)
+    return full(`auto: a file hits the ${hit[0]} path gate (risk class)`);
+  if (files.some((f) => DATA_FILE.test(f)))
+    return full("auto: a data/migration file is in the diff (risk class)");
+  const inventory = await collectReviewers(root);
+  for (const reviewer of inventory.project) {
+    if (reviewer.pathsSource === "none" || !reviewer.paths.length)
+      continue;
+    const patterns = reviewer.paths.map(globToRegExp2);
+    if (files.some((f) => patterns.some((p) => p.test(f))))
+      return full(`auto: a file hits the project reviewer ${reviewer.name} path gate (risk class)`);
+  }
+  return { depth: "light", reason: `auto: ${files.length} file(s), ${input.changedLines} changed line(s), no risk-class path gate` };
+}
+var ROUND_DEPTH_FILE = "round-depth.json";
+async function packageDepthBasis(packageDir) {
+  const manifest = await readFile22(path46.join(packageDir, "manifest.json"), "utf8").then((t) => JSON.parse(t)).catch(() => {
+    return;
+  });
+  const head = manifest?.target?.head;
+  const files = await packageScopeFiles(packageDir);
+  return { head: typeof head === "string" ? head : undefined, files: files === undefined ? undefined : [...files].sort(), changedLines: await packageChangedLines(packageDir) };
+}
+async function packageChangedLines(packageDir) {
+  try {
+    const parsed = JSON.parse(await readFile22(path46.join(packageDir, "scope-files.json"), "utf8"));
+    return typeof parsed?.changedLines === "number" && Number.isFinite(parsed.changedLines) && parsed.changedLines >= 0 ? parsed.changedLines : undefined;
+  } catch {
+    return;
+  }
+}
+async function packageRoundDepth(packageDir) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile22(path46.join(packageDir, ROUND_DEPTH_FILE), "utf8"));
+  } catch {
+    return;
+  }
+  if (!((parsed?.depth === "light" || parsed?.depth === "full") && typeof parsed.reason === "string"))
+    return;
+  const decision = { requested: parsed.requested ?? "auto", depth: parsed.depth, reason: parsed.reason };
+  if (decision.depth === "full")
+    return decision;
+  const now = await packageDepthBasis(packageDir);
+  const recorded = Array.isArray(parsed.files) && parsed.files.every((f) => typeof f === "string") ? [...parsed.files].sort() : undefined;
+  const stale = (why) => ({ requested: decision.requested, depth: "full", reason: `${ROUND_DEPTH_FILE} ignored: ${why}`, stale: why });
+  if (recorded === undefined || now.files === undefined || recorded.join(`
+`) !== now.files.join(`
+`))
+    return stale("it was decided for a different scope file list");
+  if (typeof parsed.changedLines !== "number" || parsed.changedLines !== now.changedLines)
+    return stale("it was decided for a different changed-line count");
+  if (parsed.head !== undefined && now.head !== undefined && parsed.head !== now.head)
+    return stale("it was decided for a different head");
+  return decision;
+}
 function globToRegExp2(glob) {
   const body = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\/?/g, (match, offset, whole) => offset + match.length === whole.length ? "\uE001" : "\uE000").replace(/\*/g, "[^/]*").replace(/\uE001/g, ".*").replace(/\uE000/g, "(?:.*/)?");
   return new RegExp(`^${body}$`);
@@ -28159,6 +28804,18 @@ async function requiredReviewers(root, mode, files, options = {}) {
       projectGates.set(reviewer.name, reviewer.paths.map(globToRegExp2));
   }
   const filesKnown = files !== undefined;
+  if (options.depth === "light") {
+    const conventions = LIGHT_CONVENTIONS_PREFERENCE.find((name) => roster.includes(name));
+    const keep = new Set([...LIGHT_FIXED_REVIEWERS, ...conventions === undefined ? [] : [conventions]]);
+    const light = roster.filter((name) => keep.has(name));
+    for (const name of roster)
+      if (!keep.has(name))
+        excluded.push({ reviewer: name, reason: "light round: only logic, testing and the stack's conventions reviewer run" });
+    for (const name of [REGRESSION, PR_CONTRACT])
+      if (inventory.bundled.some((r) => r.name === name))
+        excluded.push({ reviewer: name, reason: "light round: not part of the light set" });
+    return { mode, depth: "light", required: light.sort(), excluded, filesKnown };
+  }
   const gated = (name) => {
     if (!filesKnown)
       return;
@@ -28197,13 +28854,58 @@ async function requiredReviewers(root, mode, files, options = {}) {
     else
       excluded.push({ reviewer: PR_CONTRACT, reason: "no pr-context.md in the package: there is no PR body checklist to compare with the diff" });
   }
-  return { mode, required: required.sort(), excluded, filesKnown };
+  return { mode, depth: "full", required: required.sort(), excluded, filesKnown };
+}
+async function gitDiffStats(root, target) {
+  try {
+    assertGitRevision(target.ref);
+    assertGitRevision(target.head);
+    const proc = Bun.spawn(["git", "diff", "--no-color", "-U20", "--end-of-options", `${target.ref}...${target.head}`], { cwd: root, stdout: "pipe", stderr: "pipe", timeout: 15000, killSignal: "SIGKILL", maxBuffer: 8 * 1024 * 1024 });
+    const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    if (exitCode !== 0 || proc.signalCode !== null)
+      return;
+    const scope = buildReviewScope(stdout);
+    return { files: scope.files, changedLines: scope.counts.changedLinesRetained };
+  } catch {
+    return;
+  }
+}
+async function packageDiffStats(options) {
+  if (options.diffStats !== undefined)
+    return options.diffStats();
+  if (options.packageDir === undefined)
+    return;
+  const manifest = await readFile22(path46.join(options.packageDir, "manifest.json"), "utf8").then((t) => JSON.parse(t)).catch(() => {
+    return;
+  });
+  const { ref, head } = manifest?.target ?? {};
+  return typeof ref === "string" && typeof head === "string" ? gitDiffStats(options.root, { ref, head }) : undefined;
 }
 function isAttendedRun(env = process.env) {
   return env[ENV_AUTONOMOUS_ANSWERS_FILE] === undefined;
 }
-function mutationErrors(record, options) {
+async function effectiveDepth(record, options) {
+  if (record.depth !== "light")
+    return { depth: "full" };
+  if (options.packageDir !== undefined) {
+    const recorded = await packageRoundDepth(options.packageDir);
+    if (recorded?.depth === "full" && recorded.stale === undefined)
+      return { depth: "full", refused: `${ROUND_DEPTH_FILE} records a full round (${recorded.reason}), which binds` };
+  }
+  let input = { files: options.files, changedLines: options.changedLines };
+  if (options.packageDir !== undefined || options.diffStats !== undefined) {
+    const stats = await packageDiffStats(options);
+    if (stats === undefined)
+      return { depth: "full", refused: "the diff could not be resolved from git to confirm the size" };
+    input = { files: stats.files, changedLines: stats.changedLines };
+  }
+  const decision = await decideRoundDepth(options.root, "auto", input);
+  return decision.depth === "light" ? { depth: "light" } : { depth: "full", refused: decision.reason.replace(/^auto: /, "") };
+}
+function mutationErrors(record, options, depth) {
   const pending = options.pendingMutants ?? 0;
+  if (depth === "light")
+    return [];
   if (pending === 0 || (options.attended ?? isAttendedRun()) === false)
     return [];
   const w = record.mutationWaiver;
@@ -28228,9 +28930,10 @@ function packageHasPrContext(packageDir, name = "pr-context.md") {
 }
 async function coverageErrors(dispatch, options) {
   const record = dispatch && typeof dispatch === "object" && !Array.isArray(dispatch) ? dispatch : undefined;
-  return [...await reviewerSetErrors(dispatch, options), ...record === undefined ? [] : mutationErrors(record, options)];
+  const effective = record === undefined ? undefined : await effectiveDepth(record, options);
+  return [...await reviewerSetErrors(dispatch, options, effective), ...record === undefined || effective === undefined ? [] : mutationErrors(record, options, effective.depth)];
 }
-async function reviewerSetErrors(dispatch, options) {
+async function reviewerSetErrors(dispatch, options, effective) {
   if (!dispatch || typeof dispatch !== "object" || Array.isArray(dispatch))
     return [];
   const record = dispatch;
@@ -28248,14 +28951,15 @@ async function reviewerSetErrors(dispatch, options) {
     return ["diff mode needs the scope-A file list: pass `--scope <scope.json>` to `keryx review start|ingest`, or run mode all"];
   const need = await requiredReviewers(options.root, record.mode, options.files, {
     blastRadius: options.blastRadius,
-    prContext: options.prContext === true && dispatchKnowsRole(record, PR_CONTRACT)
+    prContext: options.prContext === true && dispatchKnowsRole(record, PR_CONTRACT),
+    depth: effective?.depth ?? "full"
   });
   const selected = new Set(Array.isArray(record.selected) ? record.selected.filter(text) : []);
   const missing = need.required.filter((name) => !selected.has(name));
   if (!missing.length)
     return [];
   return [
-    `dispatch covers ${need.required.length - missing.length} of ${need.required.length} reviewers that mode ${record.mode} requires; missing: ${missing.join(", ")}. ` + "Dispatch them, or record an operator override {operatorQuote, reason}; `keryx review required` prints the set"
+    `dispatch covers ${need.required.length - missing.length} of ${need.required.length} reviewers that mode ${record.mode} requires; missing: ${missing.join(", ")}. ` + "Dispatch them, or record an operator override {operatorQuote, reason}; `keryx review required` prints the set" + (effective?.refused === undefined ? "" : `. The dispatch says depth light, but the full set applies: ${effective.refused}`)
   ];
 }
 async function packageScopeFiles(packageDir) {
@@ -28684,6 +29388,8 @@ var MUTANT_KINDS = ["behavior", "presentation"];
 var MUTANTS_SPEC = "mutants.json";
 var EVIDENCE_DIR = "research-evidence";
 var SKIP_COPY = new Set([".git", "node_modules"]);
+var SCRATCH_DIR = path49.join(".metaproject", "data", "review", "mutate-scratch");
+var OUTPUT_KEEP_CHARS = 256 * 1024;
 function parseMutantSpec(raw) {
   const list = Array.isArray(raw) ? raw : raw?.mutants;
   if (!Array.isArray(list) || list.length === 0)
@@ -28712,6 +29418,7 @@ function parseMutantSpec(raw) {
     };
   });
 }
+var liveGroups = new Set;
 async function doneMutantIds(packageDir) {
   const dir = path49.join(packageDir, EVIDENCE_DIR);
   const done = new Set;
@@ -28809,7 +29516,9 @@ async function packageResearchErrors(packageDir, artifacts, findings, options =
     const dispatch = a.reviewerDispatch === undefined ? [] : dispatchErrors(ledger?.dispatch);
     const coverage = a.reviewerDispatch === undefined || options.coverage === false || dispatch.length ? [] : await coverageErrors(ledger?.dispatch, {
       root: projectRootOfPackage(packageDir),
+      packageDir,
       files: await packageScopeFiles(packageDir),
+      changedLines: await packageChangedLines(packageDir),
       blastRadius: await packageHasBlastRadius(packageDir),
       prContext: packageHasPrContext(packageDir),
       pendingMutants: (await pendingMutants(packageDir)).length
@@ -31006,7 +31715,7 @@ function parseAcKinds(content) {
   }
   return { criteria, errors };
 }
-function emptyCounts() {
+function emptyCounts2() {
   return { exec: 0, invariant: 0, judged: 0, none: 0, unclassified: 0 };
 }
 function buildAcKindReport(flowId, content) {
@@ -31019,7 +31728,7 @@ function buildAcKindReport(flowId, content) {
   return { report: reportFromRecords(flowId, criteria), errors: parsed.errors };
 }
 function reportFromRecords(flowId, criteria) {
-  const counts = emptyCounts();
+  const counts = emptyCounts2();
   const byValue = { revert: 0, mutation: 0, "failure-scenario": 0 };
   let proven = 0;
   for (const record of Object.values(criteria)) {