@pablozrrrr/jevguard 0.2.3 → 0.3.1

package/skills/jevguard-rules/validate-rules.js

@@ -3,38 +3,65 @@
 import { readFileSync, statSync } from "fs";
 import { resolve } from "path";
 
-// packages/core/src/ports/types.ts
-var SCOPE_CREEP_ANSWER = "scopeCreep";
-var COMPLEXITY_ANSWER = "complexity";
-// packages/core/src/evaluation/build-request.ts
-var NOUL_INSTRUCTIONS = "Answer true when the attributed change violates the rule's Violation, excluding behavior described by the rule's Allowed exception. Answer false when the change does not violate the rule, including allowed behavior. Return the probability from 0 to 1 that the change violates the rule.";
-function buildJevRequest(task, rule, evidence) {
+// packages/core/src/builtins/complexity.ts
+var COMPLEXITY_CHECK_ID = "COMPLEXITY";
+var COMPLEXITY_GATE_CONFIG = {
+  version: 1,
+  thresholds: {
+    error: { warn: 0.4, fail: 0.7 },
+    warning: { warn: 0.5 }
+  }
+};
+var COMPLEXITY_INSTRUCTIONS = "Does this attributed change introduce material complexity that is disproportionate to, or not reasonably necessary for, completing the user's task? Necessary supporting changes, tests, validation, error handling, and complexity explicitly required by the task should not count as unnecessary complexity. Return the probability from 0 to 1 that the change introduces disproportionate or unnecessary complexity.";
+var COMPLEXITY_DESCRIPTION = "Material complexity introduced by the attributed change that is disproportionate to the problem and not reasonably necessary for completing the task.";
+var COMPLEXITY_VIOLATION = "The change adds unnecessary abstractions, layers or indirections without proportional gain, new dependencies without clear need, excessive configuration, premature generalization, or structure materially larger than the problem requires.";
+var COMPLEXITY_ALLOWED = "Complexity explicitly required by the task, and necessary supporting changes, tests, validation, error handling, auxiliary changes, or following an existing codebase abstraction to avoid breaking its pattern.";
+function buildComplexityQuestion() {
   return {
-    kind: "RULE",
-    task,
-    question: {
-      type: "noul",
-      instructions: NOUL_INSTRUCTIONS,
-      criteria: {
-        id: rule.id,
-        description: rule.description,
-        violation: rule.violation,
-        ...rule.allowed === null ? {} : { allowed: rule.allowed }
-      }
-    },
-    change: { files: evidence.files, diff: evidence.diff }
+    type: "noul",
+    instructions: COMPLEXITY_INSTRUCTIONS,
+    criteria: {
+      id: COMPLEXITY_CHECK_ID,
+      description: COMPLEXITY_DESCRIPTION,
+      violation: COMPLEXITY_VIOLATION,
+      allowed: COMPLEXITY_ALLOWED
+    }
   };
 }
-// packages/core/src/evaluation/build-context.ts
-function buildReviewContext(turn, rule, scopedPaths) {
+function buildComplexityContext(turn, scopedPaths) {
   return {
-    kind: "RULE",
+    kind: "BUILT_IN",
     turnId: turn.id,
-    ruleId: rule.id,
-    severity: rule.severity,
+    ruleId: null,
+    checkId: COMPLEXITY_CHECK_ID,
+    severity: "warning",
     scopedPaths
   };
 }
+// packages/core/src/evaluation/evaluate-with-port.ts
+async function evaluateRuleBatchWithPort(port, requests) {
+  try {
+    const results = await port.evaluateRuleBatch(requests);
+    if (results.length !== requests.length) {
+      return requests.map(() => ruleFailure("INVALID_RESPONSE"));
+    }
+    return results.map((result) => result.kind === "RULE" ? result : ruleFailure("INVALID_RESPONSE"));
+  } catch {
+    return requests.map(() => ruleFailure("API_ERROR"));
+  }
+}
+function ruleFailure(reason) {
+  return { kind: "RULE", status: "FAILED", reason };
+}
+async function evaluateBuiltInBatchWithPort(port, request) {
+  try {
+    const result = await port.evaluate(request);
+    return result.kind === "BUILT_IN_BATCH" ? result : { kind: "BUILT_IN_BATCH", status: "FAILED", reason: "INVALID_RESPONSE" };
+  } catch {
+    return { kind: "BUILT_IN_BATCH", status: "FAILED", reason: "API_ERROR" };
+  }
+}
+
 // packages/core/src/evidence/defaults.ts
 var DEFAULT_MAX_DIFF_LENGTH = 1e5;
 var DEFAULT_EVIDENCE_POLICY = {
@@ -306,97 +333,275 @@ function evaluateWarningGate(probability, thresholds) {
   return { outcome: "WARN", violationProbability: probability };
 }
 
-// packages/core/src/evaluation/evaluate-with-port.ts
-async function evaluateRuleBatchWithPort(port, requests) {
-  try {
-    const results = await port.evaluateRuleBatch(requests);
-    if (results.length !== requests.length) {
-      return requests.map(() => ruleFailure("INVALID_RESPONSE"));
-    }
-    return results.map((result) => result.kind === "RULE" ? result : ruleFailure("INVALID_RESPONSE"));
-  } catch {
-    return requests.map(() => ruleFailure("API_ERROR"));
+// packages/core/src/ports/types.ts
+var SCOPE_CREEP_ANSWER = "scopeCreep";
+var COMPLEXITY_ANSWER = "complexity";
+
+// packages/core/src/builtins/scope-creep.ts
+var SCOPE_CREEP_CHECK_ID = "SCOPE-CREEP";
+var SCOPE_CREEP_GATE_CONFIG = {
+  version: 1,
+  thresholds: {
+    error: { warn: 0.65, fail: 0.9 },
+    warning: { warn: 0.6 }
   }
+};
+var SCOPE_CREEP_INSTRUCTIONS = "Answer true when the attributed change contains scope creep: material functional, behavioral, architectural, dependency, configuration, documentation, or refactoring work that the task did not request and that is not reasonably necessary to complete the task. Answer false when every change is requested work, or supporting, testing, or documentation work reasonably necessary to complete the requested work, including immaterial incidental edits. Return the probability from 0 to 1 that the change is scope creep.";
+var SCOPE_CREEP_DESCRIPTION = "A change is scope creep when it introduces material functional, behavioral, architectural, dependency, configuration, documentation, or refactoring work that the task did not request and that is not reasonably necessary to complete it.";
+var SCOPE_CREEP_VIOLATION = "The change adds material functional, behavioral, architectural, dependency, configuration, documentation, or refactoring work that the task did not request and that is not reasonably necessary to complete the task.";
+var SCOPE_CREEP_ALLOWED = "Changes the task requested, and supporting, testing, and documentation changes reasonably necessary to complete the requested work, including immaterial incidental edits.";
+function buildScopeCreepQuestion() {
+  return {
+    type: "noul",
+    instructions: SCOPE_CREEP_INSTRUCTIONS,
+    criteria: {
+      id: SCOPE_CREEP_CHECK_ID,
+      description: SCOPE_CREEP_DESCRIPTION,
+      violation: SCOPE_CREEP_VIOLATION,
+      allowed: SCOPE_CREEP_ALLOWED
+    }
+  };
 }
-function ruleFailure(reason) {
-  return { kind: "RULE", status: "FAILED", reason };
+function buildScopeCreepContext(turn, scopedPaths) {
+  return {
+    kind: "BUILT_IN",
+    turnId: turn.id,
+    ruleId: null,
+    checkId: SCOPE_CREEP_CHECK_ID,
+    severity: "error",
+    scopedPaths
+  };
 }
-async function evaluateBuiltInBatchWithPort(port, request) {
-  try {
-    const result = await port.evaluate(request);
-    return result.kind === "BUILT_IN_BATCH" ? result : { kind: "BUILT_IN_BATCH", status: "FAILED", reason: "INVALID_RESPONSE" };
-  } catch {
-    return { kind: "BUILT_IN_BATCH", status: "FAILED", reason: "API_ERROR" };
-  }
+
+// packages/core/src/builtins/evaluate-builtins.ts
+function buildBuiltInBatchRequest(task, evidence) {
+  return {
+    kind: "BUILT_IN_BATCH",
+    task,
+    questions: {
+      [SCOPE_CREEP_ANSWER]: buildScopeCreepQuestion(),
+      [COMPLEXITY_ANSWER]: buildComplexityQuestion()
+    },
+    change: { files: evidence.files, diff: evidence.diff }
+  };
 }
-// packages/core/src/evidence/plan-slices.ts
-var HUNK_MARKER = /^@@ [^\n]*@@/gm;
-function planRuleEvidence(turn, rule, policy = DEFAULT_EVIDENCE_POLICY) {
-  if (hasNoAttributedPatch(turn)) {
-    return { status: "SKIPPED", reason: "NO_ATTRIBUTED_PATCH" };
-  }
-  const applicableFiles = selectApplicableFiles(turn.files, rule.scope, rule.evidence, policy);
-  if (applicableFiles.length === 0) {
-    return { status: "SKIPPED", reason: "NO_SCOPE_MATCH" };
-  }
-  const diff = assembleDiff(applicableFiles);
-  if (diff.trim() === "") {
-    return { status: "SKIPPED", reason: "NO_ATTRIBUTED_PATCH" };
+async function evaluateBuiltIns(input, dependencies) {
+  const selection = selectTurnEvidence(input.turn, input.evidencePolicy);
+  if (selection.status === "SKIPPED") {
+    return {
+      scopeCreep: {
+        ...buildScopeCreepContext(input.turn, []),
+        outcome: "SKIPPED",
+        reason: selection.reason
+      },
+      complexity: {
+        ...buildComplexityContext(input.turn, []),
+        outcome: "SKIPPED",
+        reason: selection.reason
+      }
+    };
   }
-  if (applicableFiles.some((file) => !checkFilePath(file.path, policy).allowed)) {
-    return { status: "UNAVAILABLE", reason: "BLOCKED_EVIDENCE" };
+  if (selection.status === "UNAVAILABLE") {
+    return {
+      scopeCreep: {
+        ...buildScopeCreepContext(input.turn, []),
+        outcome: "UNAVAILABLE",
+        reason: selection.reason
+      },
+      complexity: {
+        ...buildComplexityContext(input.turn, []),
+        outcome: "UNAVAILABLE",
+        reason: selection.reason
+      }
+    };
   }
-  if (diff.length <= policy.maxDiffLength) {
-    return { status: "PLANNED", slices: [wholeSlice(applicableFiles, diff)] };
+  const evidence = selection.evidence;
+  const request = buildBuiltInBatchRequest(input.turn.task, evidence);
+  const evaluation = await evaluateBuiltInBatchWithPort(dependencies.jev, request);
+  const scopeCreepContext = buildScopeCreepContext(input.turn, evidence.files);
+  const complexityContext = buildComplexityContext(input.turn, evidence.files);
+  if (evaluation.status === "FAILED") {
+    return {
+      scopeCreep: { ...scopeCreepContext, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" },
+      complexity: { ...complexityContext, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" }
+    };
   }
-  return sliceByFile(applicableFiles, policy);
-}
-function wholeSlice(files, diff) {
-  const paths = files.map((file) => file.path);
   return {
-    index: 0,
-    kind: "WHOLE",
-    path: paths.length === 1 ? paths[0] ?? null : null,
-    hunkOrdinal: null,
-    files: paths,
-    diff
+    scopeCreep: gateScopeCreep(evaluation.answers.scopeCreep, scopeCreepContext),
+    complexity: gateComplexity(evaluation.answers.complexity, complexityContext)
   };
 }
-function sliceByFile(files, policy) {
-  const slices = [];
-  for (const file of files) {
-    if (file.patch.length <= policy.maxDiffLength) {
-      slices.push(fileSlice(slices.length, file));
-      continue;
-    }
-    const hunks = sliceHunks(slices.length, file, policy);
-    if (hunks === null) {
-      return { status: "UNAVAILABLE", reason: "OVERSIZED_DIFF" };
-    }
-    slices.push(...hunks);
+function gateScopeCreep(answer, context) {
+  if (answer.status === "FAILED") {
+    return { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
   }
-  return { status: "PLANNED", slices };
-}
-function fileSlice(index, file) {
   return {
-    index,
-    kind: "FILE",
-    path: file.path,
-    hunkOrdinal: null,
-    files: [file.path],
-    diff: file.patch
+    ...context,
+    ...evaluateGate("error", answer.noul.violationProbability, SCOPE_CREEP_GATE_CONFIG)
   };
 }
-function sliceHunks(startIndex, file, policy) {
-  const starts = hunkStarts(file.patch);
-  if (starts.length === 0) {
-    return null;
+function gateComplexity(answer, context) {
+  if (answer.status === "FAILED") {
+    return { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
   }
-  const firstStart = starts[0];
-  if (firstStart === undefined) {
-    return null;
+  return {
+    ...context,
+    ...evaluateGate("warning", answer.noul.violationProbability, COMPLEXITY_GATE_CONFIG)
+  };
+}
+// packages/core/src/concurrency/fifo-port.ts
+function createFifoJevPort(port, config) {
+  const maxConcurrency = config.maxConcurrency;
+  if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) {
+    throw new RangeError("maxConcurrency must be a positive integer");
   }
-  const preamble = file.patch.slice(0, firstStart);
+  const queue = [];
+  let active = 0;
+  function drain() {
+    while (active < maxConcurrency && queue.length > 0) {
+      const pending = queue.shift();
+      if (pending === undefined) {
+        return;
+      }
+      active += 1;
+      start(pending);
+    }
+  }
+  function start(pending) {
+    if (pending.kind === "BATCH") {
+      Promise.resolve().then(() => port.evaluateRuleBatch(pending.requests)).then((results) => {
+        active -= 1;
+        pending.settle(results);
+        drain();
+      }, (error) => {
+        active -= 1;
+        pending.fail(error);
+        drain();
+      });
+      return;
+    }
+    Promise.resolve().then(() => port.evaluate(pending.request)).then((result) => {
+      active -= 1;
+      pending.settle(result);
+      drain();
+    }, (error) => {
+      active -= 1;
+      pending.fail(error);
+      drain();
+    });
+  }
+  return {
+    evaluate(request) {
+      return new Promise((settle, fail) => {
+        queue.push({ kind: "SINGLE", request, settle, fail });
+        drain();
+      });
+    },
+    evaluateRuleBatch(requests) {
+      return new Promise((settle, fail) => {
+        queue.push({ kind: "BATCH", requests, settle, fail });
+        drain();
+      });
+    }
+  };
+}
+// packages/core/src/evaluation/build-context.ts
+function buildReviewContext(turn, rule, scopedPaths) {
+  return {
+    kind: "RULE",
+    turnId: turn.id,
+    ruleId: rule.id,
+    severity: rule.severity,
+    scopedPaths
+  };
+}
+// packages/core/src/evaluation/build-request.ts
+var NOUL_INSTRUCTIONS = "Answer true when the attributed change violates the rule's Violation, excluding behavior described by the rule's Allowed exception. Answer false when the change does not violate the rule, including allowed behavior. Return the probability from 0 to 1 that the change violates the rule.";
+function buildJevRequest(task, rule, evidence) {
+  return {
+    kind: "RULE",
+    task,
+    question: {
+      type: "noul",
+      instructions: NOUL_INSTRUCTIONS,
+      criteria: {
+        id: rule.id,
+        description: rule.description,
+        violation: rule.violation,
+        ...rule.allowed === null ? {} : { allowed: rule.allowed }
+      }
+    },
+    change: { files: evidence.files, diff: evidence.diff }
+  };
+}
+// packages/core/src/evidence/plan-slices.ts
+var HUNK_MARKER = /^@@ [^\n]*@@/gm;
+function planRuleEvidence(turn, rule, policy = DEFAULT_EVIDENCE_POLICY) {
+  if (hasNoAttributedPatch(turn)) {
+    return { status: "SKIPPED", reason: "NO_ATTRIBUTED_PATCH" };
+  }
+  const applicableFiles = selectApplicableFiles(turn.files, rule.scope, rule.evidence, policy);
+  if (applicableFiles.length === 0) {
+    return { status: "SKIPPED", reason: "NO_SCOPE_MATCH" };
+  }
+  const diff = assembleDiff(applicableFiles);
+  if (diff.trim() === "") {
+    return { status: "SKIPPED", reason: "NO_ATTRIBUTED_PATCH" };
+  }
+  if (applicableFiles.some((file) => !checkFilePath(file.path, policy).allowed)) {
+    return { status: "UNAVAILABLE", reason: "BLOCKED_EVIDENCE" };
+  }
+  if (diff.length <= policy.maxDiffLength) {
+    return { status: "PLANNED", slices: [wholeSlice(applicableFiles, diff)] };
+  }
+  return sliceByFile(applicableFiles, policy);
+}
+function wholeSlice(files, diff) {
+  const paths = files.map((file) => file.path);
+  return {
+    index: 0,
+    kind: "WHOLE",
+    path: paths.length === 1 ? paths[0] ?? null : null,
+    hunkOrdinal: null,
+    files: paths,
+    diff
+  };
+}
+function sliceByFile(files, policy) {
+  const slices = [];
+  for (const file of files) {
+    if (file.patch.length <= policy.maxDiffLength) {
+      slices.push(fileSlice(slices.length, file));
+      continue;
+    }
+    const hunks = sliceHunks(slices.length, file, policy);
+    if (hunks === null) {
+      return { status: "UNAVAILABLE", reason: "OVERSIZED_DIFF" };
+    }
+    slices.push(...hunks);
+  }
+  return { status: "PLANNED", slices };
+}
+function fileSlice(index, file) {
+  return {
+    index,
+    kind: "FILE",
+    path: file.path,
+    hunkOrdinal: null,
+    files: [file.path],
+    diff: file.patch
+  };
+}
+function sliceHunks(startIndex, file, policy) {
+  const starts = hunkStarts(file.patch);
+  if (starts.length === 0) {
+    return null;
+  }
+  const firstStart = starts[0];
+  if (firstStart === undefined) {
+    return null;
+  }
+  const preamble = file.patch.slice(0, firstStart);
   const slices = [];
   for (let ordinal = 0;ordinal < starts.length; ordinal += 1) {
     const start = starts[ordinal];
@@ -711,610 +916,416 @@ function invalidConfigResult(turn, rule) {
     reason: "INVALID_CONFIG"
   };
 }
-// packages/core/src/rules/headings.ts
-var RULE_HEADING = /^##\s+(.*)$/;
-var SECTION_HEADING = /^###\s+(.*)$/;
-function matchRuleHeading(line) {
-  const match = RULE_HEADING.exec(line);
-  if (match === null) {
-    return null;
+// packages/core/src/evidence/parse-unified-diff.ts
+var GIT_HEADER = "diff --git ";
+var OLD_FILE_MARKER = "--- ";
+var NEW_FILE_MARKER = "+++ ";
+var DEV_NULL = "/dev/null";
+var OLD_PREFIX = "a/";
+var NEW_PREFIX = "b/";
+var NO_NEWLINE_MARKER = "\\ ";
+var HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: .*)?$/;
+var COMBINED_HEADERS = ["diff --cc ", "diff --combined "];
+var RENAME_FROM_HEADERS = ["rename from ", "copy from "];
+var RENAME_TO_HEADERS = ["rename to ", "copy to "];
+var KNOWN_EXTENDED_HEADERS = [
+  "old mode ",
+  "new mode ",
+  "deleted file mode ",
+  "new file mode ",
+  "similarity index ",
+  "dissimilarity index ",
+  "index ",
+  ...RENAME_FROM_HEADERS,
+  ...RENAME_TO_HEADERS
+];
+function parseUnifiedDiff(text) {
+  const diff = splitLines(text);
+  const first = diff.text.findIndex((line) => line.trim() !== "");
+  if (first === -1) {
+    return { status: "PARSED", files: [] };
+  }
+  if (diff.text.some(isCombinedHeader)) {
+    return invalid("COMBINED_DIFF");
+  }
+  const format = detectFormat(diff.text, first);
+  if (format === null) {
+    return invalid("UNRECOGNIZED_DIFF");
+  }
+  return collectFiles(diff, first, format);
+}
+function invalid(reason) {
+  return { status: "INVALID", reason };
+}
+function splitLines(text) {
+  const raw = text.split(`
+`);
+  const endsWithNewline = text.endsWith(`
+`);
+  if (endsWithNewline) {
+    raw.pop();
   }
-  return (match[1] ?? "").trim();
+  const stripped = raw.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  return { raw, text: stripped, endsWithNewline };
 }
-function matchSectionHeading(line) {
-  const match = SECTION_HEADING.exec(line);
-  if (match === null) {
+function isCombinedHeader(line) {
+  return COMBINED_HEADERS.some((header) => line.startsWith(header));
+}
+function detectFormat(text, first) {
+  if ((text[first] ?? "").startsWith(GIT_HEADER)) {
+    return "GIT";
+  }
+  if (text.some((line) => line.startsWith(GIT_HEADER))) {
     return null;
   }
-  return (match[1] ?? "").trim();
+  return isPlainSectionStart(text, first) ? "PLAIN" : null;
 }
-
-// packages/core/src/rules/metadata.ts
-var METADATA_ENTRY = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/;
-function parseRuleMetadata(lines) {
-  let severity = null;
-  let evidence = null;
-  let scopeDeclared = false;
-  const includePatterns = [];
-  const excludePatterns = [];
-  const seenKeys = new Set;
-  for (const line of collectMetadataLines(lines)) {
-    const entry = parseMetadataEntry(line);
-    if (entry === null) {
-      return { ok: false, code: "MALFORMED_METADATA" };
-    }
-    if (entry.key === "scope") {
-      const pattern = parseScopePattern(entry.value);
-      if (pattern === null) {
-        return { ok: false, code: "MALFORMED_METADATA" };
-      }
-      scopeDeclared = true;
-      if (pattern.exclude) {
-        excludePatterns.push(pattern.pattern);
-      } else {
-        includePatterns.push(pattern.pattern);
-      }
-      continue;
-    }
-    if (seenKeys.has(entry.key)) {
-      return { ok: false, code: "DUPLICATE_METADATA" };
+function isPlainSectionStart(text, index) {
+  return (text[index] ?? "").startsWith(OLD_FILE_MARKER) && (text[index + 1] ?? "").startsWith(NEW_FILE_MARKER);
+}
+function isSectionStart(text, index, format) {
+  return format === "GIT" ? (text[index] ?? "").startsWith(GIT_HEADER) : isPlainSectionStart(text, index);
+}
+function isBlankTail(text, from) {
+  for (let index = from;index < text.length; index += 1) {
+    if ((text[index] ?? "").trim() !== "") {
+      return false;
     }
-    seenKeys.add(entry.key);
-    if (entry.key === "severity") {
-      const parsed = parseSeverity(entry.value);
-      if (parsed === null) {
-        return { ok: false, code: "INVALID_SEVERITY" };
-      }
-      severity = parsed;
-      continue;
+  }
+  return true;
+}
+function collectFiles(diff, first, format) {
+  const files = [];
+  let cursor = first;
+  while (cursor < diff.text.length) {
+    const section = format === "GIT" ? readGitSection(diff, cursor) : readPlainSection(diff, cursor);
+    if (section.status === "INVALID") {
+      return section;
     }
-    if (entry.key === "evidence") {
-      const parsed = parseEvidenceClass(entry.value);
-      if (parsed === null) {
-        return { ok: false, code: "MALFORMED_METADATA" };
-      }
-      evidence = parsed;
-      continue;
+    if (section.file !== null) {
+      files.push(section.file);
     }
-    return { ok: false, code: "MALFORMED_METADATA" };
+    cursor = section.next;
   }
-  if (severity === null) {
-    return { ok: false, code: "MISSING_SEVERITY" };
+  return { status: "PARSED", files };
+}
+function readGitSection(diff, start) {
+  const header = parseGitHeader(diff.text[start] ?? "");
+  if (header.status === "INVALID") {
+    return header;
   }
-  if (scopeDeclared && includePatterns.length === 0) {
-    return { ok: false, code: "MALFORMED_METADATA" };
+  const extended = readExtendedHeaders(diff.text, start + 1);
+  if (extended.status === "INVALID") {
+    return extended;
   }
-  const scope = scopeDeclared ? { include: includePatterns, exclude: excludePatterns } : null;
-  return { ok: true, value: { severity, scope, evidence: evidence ?? "code" } };
+  if (!(diff.text[extended.next] ?? "").startsWith(OLD_FILE_MARKER)) {
+    return readSectionWithoutContent(diff.text, extended.next);
+  }
+  const paths = readFilePaths(diff.text, extended.next, "GIT");
+  if (paths.status === "INVALID") {
+    return paths;
+  }
+  const failure = checkGitPaths(header, extended, paths);
+  if (failure !== null) {
+    return failure;
+  }
+  return readContent(diff, start, extended.next + 2, paths, "GIT");
 }
-function collectMetadataLines(lines) {
-  const collected = [];
-  for (const line of lines) {
-    if (matchSectionHeading(line) !== null) {
-      break;
-    }
-    if (line.trim() !== "") {
-      collected.push(line);
-    }
+function readSectionWithoutContent(text, index) {
+  if (index >= text.length || text[index]?.startsWith(GIT_HEADER)) {
+    return { status: "OK", file: null, next: index };
   }
-  return collected;
+  return isBlankTail(text, index) ? { status: "OK", file: null, next: text.length } : invalid("UNRECOGNIZED_DIFF");
 }
-function parseMetadataEntry(line) {
-  const match = METADATA_ENTRY.exec(line);
-  if (match === null) {
-    return null;
+function parseGitHeader(line) {
+  const rest = line.slice(GIT_HEADER.length);
+  if (rest.startsWith('"') || rest.includes(' "')) {
+    return invalid("QUOTED_PATH");
   }
-  return { key: match[1] ?? "", value: (match[2] ?? "").trim() };
+  if (!rest.startsWith(OLD_PREFIX)) {
+    return invalid("UNSUPPORTED_PREFIX");
+  }
+  const split = splitGitHeaderPaths(rest);
+  if (split === null) {
+    return invalid("UNRECOGNIZED_DIFF");
+  }
+  if (split.oldPath === "" || split.newPath === "") {
+    return invalid("MISSING_PATH");
+  }
+  return { status: "OK", ...split };
 }
-function parseSeverity(value) {
-  switch (value) {
-    case "error":
-    case "warning":
-      return value;
-    default:
-      return null;
+function splitGitHeaderPaths(rest) {
+  const separator = ` ${NEW_PREFIX}`;
+  const pathLength = (rest.length - OLD_PREFIX.length - separator.length) / 2;
+  if (Number.isInteger(pathLength) && pathLength > 0) {
+    const oldPath = rest.slice(OLD_PREFIX.length, OLD_PREFIX.length + pathLength);
+    const tail = rest.slice(OLD_PREFIX.length + pathLength);
+    if (tail === `${separator}${oldPath}`) {
+      return { oldPath, newPath: oldPath };
+    }
+  }
+  const index = rest.indexOf(separator, OLD_PREFIX.length);
+  if (index === -1) {
+    return null;
   }
+  return {
+    oldPath: rest.slice(OLD_PREFIX.length, index),
+    newPath: rest.slice(index + separator.length)
+  };
 }
-function parseEvidenceClass(value) {
-  switch (value) {
-    case "code":
-    case "docs":
-    case "any":
-      return value;
-    default:
-      return null;
-  }
-}
-function parseScopePattern(value) {
-  if (value === "") {
-    return null;
-  }
-  if (value.startsWith("!")) {
-    const pattern = value.slice(1).trim();
-    return pattern === "" ? null : { pattern, exclude: true };
-  }
-  return { pattern: value, exclude: false };
-}
-
-// packages/core/src/rules/sections.ts
-var SECTION_NAMES = ["Rule", "Violation", "Allowed"];
-function parseRuleSections(lines) {
-  const collected = collectSections(lines);
-  if (!collected.ok) {
-    return collected;
-  }
-  return validateSections(collected.value);
-}
-function collectSections(lines) {
-  const sections = new Map;
-  let current = null;
-  let content = [];
-  for (const line of lines) {
-    const heading = matchSectionHeading(line);
-    if (heading === null) {
-      if (current !== null) {
-        content.push(line);
-      }
-      continue;
+function readExtendedHeaders(text, start) {
+  let movedFrom = null;
+  let movedTo = null;
+  let cursor = start;
+  while (cursor < text.length) {
+    const line = text[cursor] ?? "";
+    if (line.startsWith("GIT binary patch") || line.startsWith("Binary files ")) {
+      return invalid("BINARY_PATCH");
     }
-    if (current !== null) {
-      sections.set(current, joinContent(content));
-    }
-    if (!SECTION_NAMES.includes(heading)) {
-      return { ok: false, code: "UNKNOWN_SECTION" };
+    const fromValue = headerValue(line, RENAME_FROM_HEADERS);
+    const toValue = headerValue(line, RENAME_TO_HEADERS);
+    if (fromValue?.startsWith('"') || toValue?.startsWith('"')) {
+      return invalid("QUOTED_PATH");
     }
-    if (sections.has(heading)) {
-      return { ok: false, code: "DUPLICATE_SECTION" };
+    movedFrom = fromValue ?? movedFrom;
+    movedTo = toValue ?? movedTo;
+    if (!KNOWN_EXTENDED_HEADERS.some((header) => line.startsWith(header))) {
+      break;
     }
-    current = heading;
-    content = [];
-  }
-  if (current !== null) {
-    sections.set(current, joinContent(content));
+    cursor += 1;
   }
-  return { ok: true, value: sections };
+  return { status: "OK", next: cursor, movedFrom, movedTo };
 }
-function validateSections(sections) {
-  const rule = sections.get("Rule");
-  const violation = sections.get("Violation");
-  const allowed = sections.get("Allowed") ?? null;
-  if (rule === undefined) {
-    return { ok: false, code: "MISSING_RULE" };
-  }
-  if (violation === undefined) {
-    return { ok: false, code: "MISSING_VIOLATION" };
+function headerValue(line, headers) {
+  const header = headers.find((candidate) => line.startsWith(candidate));
+  return header === undefined ? null : line.slice(header.length);
+}
+function readFilePaths(text, index, format) {
+  const oldLine = text[index] ?? "";
+  const newLine = text[index + 1] ?? "";
+  if (!oldLine.startsWith(OLD_FILE_MARKER) || !newLine.startsWith(NEW_FILE_MARKER)) {
+    return invalid("UNRECOGNIZED_DIFF");
   }
-  if (rule === "") {
-    return { ok: false, code: "EMPTY_SECTION" };
+  const oldValue = cutAtTab(oldLine.slice(OLD_FILE_MARKER.length));
+  const newValue = cutAtTab(newLine.slice(NEW_FILE_MARKER.length));
+  if (oldValue.startsWith('"') || newValue.startsWith('"')) {
+    return invalid("QUOTED_PATH");
   }
-  if (violation === "") {
-    return { ok: false, code: "EMPTY_SECTION" };
+  const stripped = stripPrefixes(oldValue, newValue, format);
+  if (stripped === null) {
+    return invalid("UNSUPPORTED_PREFIX");
   }
-  if (allowed === "") {
-    return { ok: false, code: "EMPTY_ALLOWED" };
+  if (isMissing(stripped.oldPath) && isMissing(stripped.newPath)) {
+    return invalid("MISSING_PATH");
   }
-  if (allowed !== null && allowed === violation) {
-    return { ok: false, code: "ALLOWED_EQUALS_VIOLATION" };
+  const oldPath = stripped.oldPath === DEV_NULL ? null : stripped.oldPath;
+  const newPath = stripped.newPath === DEV_NULL ? null : stripped.newPath;
+  if (oldPath === "" || newPath === "") {
+    return invalid("MISSING_PATH");
   }
-  return { ok: true, value: { rule, violation, allowed } };
+  return { status: "OK", oldPath, newPath };
 }
-function joinContent(lines) {
-  return lines.join(`
-`).trim();
+function isMissing(path) {
+  return path === "" || path === DEV_NULL;
 }
-
-// packages/core/src/rules/blocks.ts
-var RULE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-function isValidRuleId(id) {
-  return RULE_ID.test(id);
+function cutAtTab(value) {
+  const tabIndex = value.indexOf("\t");
+  return tabIndex === -1 ? value : value.slice(0, tabIndex);
 }
-function collectRuleBlocks(text) {
-  const blocks = [];
-  let current = null;
-  for (const line of splitLines(text)) {
-    const id = matchRuleHeading(line);
-    if (id !== null) {
-      current = { id, body: [] };
-      blocks.push(current);
-      continue;
-    }
-    if (current !== null) {
-      current.body.push(line);
-    }
+function stripPrefixes(oldValue, newValue, format) {
+  const hasOldPrefix = oldValue.startsWith(OLD_PREFIX);
+  const hasNewPrefix = newValue.startsWith(NEW_PREFIX);
+  const oldAllowed = hasOldPrefix || oldValue === DEV_NULL;
+  const newAllowed = hasNewPrefix || newValue === DEV_NULL;
+  if (oldAllowed && newAllowed) {
+    return {
+      oldPath: hasOldPrefix ? oldValue.slice(OLD_PREFIX.length) : oldValue,
+      newPath: hasNewPrefix ? newValue.slice(NEW_PREFIX.length) : newValue
+    };
   }
-  return blocks;
+  if (format === "PLAIN" && !hasOldPrefix && !hasNewPrefix) {
+    return { oldPath: oldValue, newPath: newValue };
+  }
+  return null;
 }
-function parseRuleBlock(block, duplicate) {
-  if (!isValidRuleId(block.id)) {
-    return ruleCandidateFailure("INVALID_ID", null);
+function checkGitPaths(header, extended, paths) {
+  const oldMatches = paths.oldPath === null || paths.oldPath === header.oldPath;
+  const newMatches = paths.newPath === null || paths.newPath === header.newPath;
+  if (!oldMatches || !newMatches) {
+    return invalid("UNRECOGNIZED_DIFF");
   }
-  if (duplicate) {
-    return ruleCandidateFailure("DUPLICATE_ID", block.id);
+  const movedByHeader = extended.movedFrom !== null && extended.movedTo !== null && extended.movedFrom !== extended.movedTo;
+  if (header.oldPath !== header.newPath || movedByHeader) {
+    return invalid("RENAMED_PATH");
   }
-  const metadata = parseRuleMetadata(block.body);
-  if (!metadata.ok) {
-    return ruleCandidateFailure(metadata.code, block.id);
+  return null;
+}
+function readPlainSection(diff, start) {
+  const paths = readFilePaths(diff.text, start, "PLAIN");
+  if (paths.status === "INVALID") {
+    return paths;
   }
-  const sections = parseRuleSections(block.body);
-  if (!sections.ok) {
-    return ruleCandidateFailure(sections.code, block.id);
+  if (paths.oldPath !== null && paths.newPath !== null && paths.oldPath !== paths.newPath) {
+    return invalid("RENAMED_PATH");
   }
-  return {
-    status: "PARSED",
-    rule: buildParsedRule(block.id, metadata.value, sections.value)
-  };
+  return readContent(diff, start, start + 2, paths, "PLAIN");
 }
-function ruleCandidateFailure(code, ruleId) {
-  return { status: "INVALID", reason: "INVALID_RULE", code, ruleId };
+function readContent(diff, start, hunksStart, paths, format) {
+  const hunks = readHunks(diff.text, hunksStart);
+  if (hunks.status === "INVALID") {
+    return hunks;
+  }
+  const next = nextSectionIndex(diff.text, hunks.end, format);
+  if (next === null) {
+    return invalid("UNRECOGNIZED_DIFF");
+  }
+  const path = paths.newPath ?? paths.oldPath ?? "";
+  const patch = renderPatch(diff, start, hunks.end);
+  return { status: "OK", file: { path, patch }, next };
 }
-function splitLines(text) {
-  return text.replace(/\r\n?/g, `
-`).split(`
+function renderPatch(diff, start, end) {
+  const body = diff.raw.slice(start, end).join(`
 `);
-}
-function buildParsedRule(id, metadata, sections) {
-  return {
-    id,
-    severity: metadata.severity,
-    scope: metadata.scope,
-    evidence: metadata.evidence,
-    description: sections.rule,
-    violation: sections.violation,
-    allowed: sections.allowed
-  };
-}
-// packages/core/src/rules/parse-rules.ts
-function parseRules(text) {
-  const blocks = collectRuleBlocks(text);
-  if (blocks.length === 0) {
-    return [ruleCandidateFailure("MISSING_ID", null)];
+  return end < diff.raw.length || diff.endsWithNewline ? `${body}
+` : body;
+}
+function nextSectionIndex(text, end, format) {
+  if (end >= text.length || isSectionStart(text, end, format)) {
+    return end;
+  }
+  return isBlankTail(text, end) ? text.length : null;
+}
+function readHunks(text, start) {
+  let cursor = start;
+  let hunkCount = 0;
+  while (cursor < text.length && (text[cursor] ?? "").startsWith("@@")) {
+    const hunk = readHunk(text, cursor);
+    if (hunk.status === "INVALID") {
+      return hunk;
+    }
+    cursor = hunk.next;
+    hunkCount += 1;
   }
-  const duplicates = findDuplicateIds(blocks.map((block) => block.id));
-  return blocks.map((block) => parseRuleBlock(block, duplicates.has(block.id)));
+  if (hunkCount === 0) {
+    return invalid(cursor >= text.length ? "TRUNCATED_HUNK" : "UNRECOGNIZED_DIFF");
+  }
+  return { status: "OK", end: cursor };
 }
-function findDuplicateIds(ids) {
-  const counts = new Map;
-  for (const id of ids) {
-    if (!isValidRuleId(id)) {
+function readHunk(text, at) {
+  const match = HUNK_HEADER.exec(text[at] ?? "");
+  if (match === null) {
+    return invalid("UNRECOGNIZED_DIFF");
+  }
+  let oldLeft = Number(match[2] ?? 1);
+  let newLeft = Number(match[4] ?? 1);
+  let cursor = at + 1;
+  let afterBodyLine = false;
+  while (oldLeft > 0 || newLeft > 0) {
+    if (cursor >= text.length) {
+      return invalid("TRUNCATED_HUNK");
+    }
+    const line = text[cursor] ?? "";
+    if (line.startsWith(NO_NEWLINE_MARKER)) {
+      if (!afterBodyLine) {
+        return invalid("UNRECOGNIZED_DIFF");
+      }
+      afterBodyLine = false;
+      cursor += 1;
       continue;
     }
-    counts.set(id, (counts.get(id) ?? 0) + 1);
-  }
-  const duplicates = new Set;
-  for (const [id, count] of counts) {
-    if (count > 1) {
-      duplicates.add(id);
+    const marker = line === "" ? " " : line.charAt(0);
+    const consumesOld = marker === " " || marker === "-";
+    const consumesNew = marker === " " || marker === "+";
+    const exceedsCount = consumesOld && oldLeft === 0 || consumesNew && newLeft === 0;
+    if (!(consumesOld || consumesNew) || exceedsCount) {
+      return invalid("UNRECOGNIZED_DIFF");
     }
+    oldLeft -= consumesOld ? 1 : 0;
+    newLeft -= consumesNew ? 1 : 0;
+    afterBodyLine = true;
+    cursor += 1;
   }
-  return duplicates;
+  const closesWithMarker = afterBodyLine && (text[cursor] ?? "").startsWith(NO_NEWLINE_MARKER);
+  return { status: "OK", next: closesWithMarker ? cursor + 1 : cursor };
 }
-// packages/core/src/report/aggregate.ts
-function aggregateReviewHistory(records, skippedLineCount) {
-  const outcomes = emptyAccumulator();
-  const unavailableReasons = new Map;
-  const skippedReasons = new Map;
-  const builtIns = new Map;
-  const rules = new Map;
-  const evaluation = { wholeEvaluations: 0, slicedEvaluations: 0, totalSliceJudgments: 0 };
-  let firstTimestamp = null;
-  let lastTimestamp = null;
+// packages/core/src/feedback/identity.ts
+function failIdentityKey(identity) {
+  return JSON.stringify([identity.turnId, identity.ruleId]);
+}
+function collectRuleFails(records) {
+  const fails = new Map;
   for (const record of records) {
-    firstTimestamp = earlier(firstTimestamp, record.timestamp);
-    lastTimestamp = later(lastTimestamp, record.timestamp);
     for (const result of record.results) {
-      countOutcome(outcomes, result.outcome);
-      if (result.outcome === "UNAVAILABLE") {
-        bump(unavailableReasons, result.reason);
-      }
-      if (result.outcome === "SKIPPED") {
-        bump(skippedReasons, result.reason);
-      }
-      if (result.kind === "BUILT_IN") {
-        bump(builtIns, result.checkId);
-      }
-      if (result.kind === "RULE" && result.ruleId !== null) {
-        countRule(rules, result.ruleId, result.outcome, result.evidence);
+      if (result.kind !== "RULE" || result.ruleId === null || result.outcome !== "FAIL") {
+        continue;
       }
-      if (result.kind === "RULE" && result.evidence !== undefined) {
-        countEvidence(evaluation, result.evidence.mode, result.evidence.sliceJudgments.length);
+      const fail = {
+        turnId: record.turnId,
+        ruleId: result.ruleId,
+        timestamp: record.timestamp,
+        violationProbability: result.violationProbability
+      };
+      const key = failIdentityKey(fail);
+      const existing = fails.get(key);
+      if (existing === undefined || fail.timestamp >= existing.timestamp) {
+        fails.set(key, fail);
       }
     }
   }
-  return {
-    entryCount: records.length,
-    skippedLineCount,
-    firstTimestamp,
-    lastTimestamp,
-    outcomes: finalizeAccumulator(outcomes),
-    unavailableReasons: sortedReasons(unavailableReasons),
-    skippedReasons: sortedReasons(skippedReasons),
-    builtIns: sortedBuiltIns(builtIns),
-    rules: sortedRules(rules),
-    evaluation: finalizeEvaluation(evaluation)
-  };
-}
-function emptyAccumulator() {
-  return { pass: 0, warn: 0, fail: 0, unavailable: 0, skipped: 0 };
+  return fails;
 }
-function countOutcome(counts, outcome) {
-  switch (outcome) {
-    case "PASS":
-      counts.pass += 1;
-      return;
-    case "WARN":
-      counts.warn += 1;
-      return;
-    case "FAIL":
-      counts.fail += 1;
-      return;
-    case "UNAVAILABLE":
-      counts.unavailable += 1;
-      return;
-    case "SKIPPED":
-      counts.skipped += 1;
-      return;
+function latestDecisions(feedback) {
+  const decisions = new Map;
+  for (const record of feedback) {
+    decisions.set(failIdentityKey(record), record.decision);
   }
+  return decisions;
 }
-function countRule(rules, ruleId, outcome, evidence) {
-  const accumulator = rules.get(ruleId) ?? { counts: emptyAccumulator(), sliced: 0 };
-  countOutcome(accumulator.counts, outcome);
-  if (evidence?.mode === "SLICED") {
-    accumulator.sliced += 1;
+function latestFeedbackRecords(feedback) {
+  const latest = new Map;
+  for (const record of feedback) {
+    const key = failIdentityKey(record);
+    latest.delete(key);
+    latest.set(key, record);
   }
-  rules.set(ruleId, accumulator);
+  return [...latest.values()];
 }
-function countEvidence(coverage, mode, sliceJudgmentCount) {
-  if (mode === "WHOLE") {
-    coverage.wholeEvaluations += 1;
-    return;
+// packages/core/src/report/compare.ts
+function compareStrings(left, right) {
+  if (left < right) {
+    return -1;
   }
-  coverage.slicedEvaluations += 1;
-  coverage.totalSliceJudgments += sliceJudgmentCount;
-}
-function finalizeAccumulator(counts) {
-  return {
-    pass: counts.pass,
-    warn: counts.warn,
-    fail: counts.fail,
-    unavailable: counts.unavailable,
-    skipped: counts.skipped,
-    total: counts.pass + counts.warn + counts.fail + counts.unavailable + counts.skipped
-  };
+  return left > right ? 1 : 0;
 }
-function finalizeEvaluation(coverage) {
-  return { ...coverage };
+
+// packages/core/src/feedback/pending.ts
+var FEEDBACK_LIST_LIMIT = 20;
+function listPendingFails(records, feedback, limit) {
+  const answered = latestDecisions(feedback);
+  const pending = [...collectRuleFails(records)].filter(([key]) => !answered.has(key)).map(([, fail]) => fail).sort(compareNewestFirst);
+  return { items: pending.slice(0, limit), total: pending.length };
 }
-function bump(map, key) {
-  map.set(key, (map.get(key) ?? 0) + 1);
+function compareNewestFirst(left, right) {
+  return compareStrings(right.timestamp, left.timestamp) || compareStrings(left.ruleId, right.ruleId) || compareStrings(left.turnId, right.turnId);
 }
-function sortedReasons(map) {
-  return [...map.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareStrings(left.reason, right.reason));
+// packages/core/src/feedback/resolve.ts
+function resolveFeedbackTarget(selection, number, records) {
+  if (selection === null) {
+    return { status: "NO_SELECTION" };
+  }
+  if (!Number.isInteger(number) || number < 1) {
+    return { status: "NUMBER_OUT_OF_RANGE" };
+  }
+  const identity = selection.items[number - 1];
+  if (identity === undefined) {
+    return { status: "NUMBER_OUT_OF_RANGE" };
+  }
+  const fail = collectRuleFails(records).get(failIdentityKey(identity));
+  return fail === undefined ? { status: "NO_LONGER_IN_HISTORY" } : { status: "FOUND", fail };
 }
-function sortedBuiltIns(map) {
-  return [...map.entries()].map(([checkId, count]) => ({ checkId, count })).sort((left, right) => compareStrings(left.checkId, right.checkId));
-}
-function sortedRules(map) {
-  return [...map.entries()].map(([ruleId, accumulator]) => ({
-    ruleId,
-    counts: finalizeAccumulator(accumulator.counts),
-    slicedRuleCount: accumulator.sliced
-  })).sort((left, right) => compareStrings(left.ruleId, right.ruleId));
-}
-function earlier(current, candidate) {
-  return current === null || candidate < current ? candidate : current;
-}
-function later(current, candidate) {
-  return current === null || candidate > current ? candidate : current;
-}
-function compareStrings(left, right) {
-  if (left < right) {
-    return -1;
-  }
-  return left > right ? 1 : 0;
-}
-// packages/core/src/builtins/complexity.ts
-var COMPLEXITY_CHECK_ID = "COMPLEXITY";
-var COMPLEXITY_GATE_CONFIG = {
-  version: 1,
-  thresholds: {
-    error: { warn: 0.4, fail: 0.7 },
-    warning: { warn: 0.5 }
-  }
-};
-var COMPLEXITY_INSTRUCTIONS = "Does this attributed change introduce material complexity that is disproportionate to, or not reasonably necessary for, completing the user's task? Necessary supporting changes, tests, validation, error handling, and complexity explicitly required by the task should not count as unnecessary complexity. Return the probability from 0 to 1 that the change introduces disproportionate or unnecessary complexity.";
-var COMPLEXITY_DESCRIPTION = "Material complexity introduced by the attributed change that is disproportionate to the problem and not reasonably necessary for completing the task.";
-var COMPLEXITY_VIOLATION = "The change adds unnecessary abstractions, layers or indirections without proportional gain, new dependencies without clear need, excessive configuration, premature generalization, or structure materially larger than the problem requires.";
-var COMPLEXITY_ALLOWED = "Complexity explicitly required by the task, and necessary supporting changes, tests, validation, error handling, auxiliary changes, or following an existing codebase abstraction to avoid breaking its pattern.";
-function buildComplexityQuestion() {
-  return {
-    type: "noul",
-    instructions: COMPLEXITY_INSTRUCTIONS,
-    criteria: {
-      id: COMPLEXITY_CHECK_ID,
-      description: COMPLEXITY_DESCRIPTION,
-      violation: COMPLEXITY_VIOLATION,
-      allowed: COMPLEXITY_ALLOWED
-    }
-  };
-}
-function buildComplexityContext(turn, scopedPaths) {
-  return {
-    kind: "BUILT_IN",
-    turnId: turn.id,
-    ruleId: null,
-    checkId: COMPLEXITY_CHECK_ID,
-    severity: "warning",
-    scopedPaths
-  };
-}
-
-// packages/core/src/builtins/scope-creep.ts
-var SCOPE_CREEP_CHECK_ID = "SCOPE-CREEP";
-var SCOPE_CREEP_GATE_CONFIG = {
-  version: 1,
-  thresholds: {
-    error: { warn: 0.65, fail: 0.9 },
-    warning: { warn: 0.6 }
-  }
-};
-var SCOPE_CREEP_INSTRUCTIONS = "Answer true when the attributed change contains scope creep: material functional, behavioral, architectural, dependency, configuration, documentation, or refactoring work that the task did not request and that is not reasonably necessary to complete the task. Answer false when every change is requested work, or supporting, testing, or documentation work reasonably necessary to complete the requested work, including immaterial incidental edits. Return the probability from 0 to 1 that the change is scope creep.";
-var SCOPE_CREEP_DESCRIPTION = "A change is scope creep when it introduces material functional, behavioral, architectural, dependency, configuration, documentation, or refactoring work that the task did not request and that is not reasonably necessary to complete it.";
-var SCOPE_CREEP_VIOLATION = "The change adds material functional, behavioral, architectural, dependency, configuration, documentation, or refactoring work that the task did not request and that is not reasonably necessary to complete the task.";
-var SCOPE_CREEP_ALLOWED = "Changes the task requested, and supporting, testing, and documentation changes reasonably necessary to complete the requested work, including immaterial incidental edits.";
-function buildScopeCreepQuestion() {
-  return {
-    type: "noul",
-    instructions: SCOPE_CREEP_INSTRUCTIONS,
-    criteria: {
-      id: SCOPE_CREEP_CHECK_ID,
-      description: SCOPE_CREEP_DESCRIPTION,
-      violation: SCOPE_CREEP_VIOLATION,
-      allowed: SCOPE_CREEP_ALLOWED
-    }
-  };
-}
-function buildScopeCreepContext(turn, scopedPaths) {
-  return {
-    kind: "BUILT_IN",
-    turnId: turn.id,
-    ruleId: null,
-    checkId: SCOPE_CREEP_CHECK_ID,
-    severity: "error",
-    scopedPaths
-  };
-}
-
-// packages/core/src/builtins/evaluate-builtins.ts
-function buildBuiltInBatchRequest(task, evidence) {
-  return {
-    kind: "BUILT_IN_BATCH",
-    task,
-    questions: {
-      [SCOPE_CREEP_ANSWER]: buildScopeCreepQuestion(),
-      [COMPLEXITY_ANSWER]: buildComplexityQuestion()
-    },
-    change: { files: evidence.files, diff: evidence.diff }
-  };
-}
-async function evaluateBuiltIns(input, dependencies) {
-  const selection = selectTurnEvidence(input.turn, input.evidencePolicy);
-  if (selection.status === "SKIPPED") {
-    return {
-      scopeCreep: {
-        ...buildScopeCreepContext(input.turn, []),
-        outcome: "SKIPPED",
-        reason: selection.reason
-      },
-      complexity: {
-        ...buildComplexityContext(input.turn, []),
-        outcome: "SKIPPED",
-        reason: selection.reason
-      }
-    };
-  }
-  if (selection.status === "UNAVAILABLE") {
-    return {
-      scopeCreep: {
-        ...buildScopeCreepContext(input.turn, []),
-        outcome: "UNAVAILABLE",
-        reason: selection.reason
-      },
-      complexity: {
-        ...buildComplexityContext(input.turn, []),
-        outcome: "UNAVAILABLE",
-        reason: selection.reason
-      }
-    };
-  }
-  const evidence = selection.evidence;
-  const request = buildBuiltInBatchRequest(input.turn.task, evidence);
-  const evaluation = await evaluateBuiltInBatchWithPort(dependencies.jev, request);
-  const scopeCreepContext = buildScopeCreepContext(input.turn, evidence.files);
-  const complexityContext = buildComplexityContext(input.turn, evidence.files);
-  if (evaluation.status === "FAILED") {
-    return {
-      scopeCreep: { ...scopeCreepContext, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" },
-      complexity: { ...complexityContext, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" }
-    };
-  }
-  return {
-    scopeCreep: gateScopeCreep(evaluation.answers.scopeCreep, scopeCreepContext),
-    complexity: gateComplexity(evaluation.answers.complexity, complexityContext)
-  };
-}
-function gateScopeCreep(answer, context) {
-  if (answer.status === "FAILED") {
-    return { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
-  }
-  return {
-    ...context,
-    ...evaluateGate("error", answer.noul.violationProbability, SCOPE_CREEP_GATE_CONFIG)
-  };
-}
-function gateComplexity(answer, context) {
-  if (answer.status === "FAILED") {
-    return { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
-  }
-  return {
-    ...context,
-    ...evaluateGate("warning", answer.noul.violationProbability, COMPLEXITY_GATE_CONFIG)
-  };
-}
-// packages/core/src/concurrency/fifo-port.ts
-function createFifoJevPort(port, config) {
-  const maxConcurrency = config.maxConcurrency;
-  if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) {
-    throw new RangeError("maxConcurrency must be a positive integer");
-  }
-  const queue = [];
-  let active = 0;
-  function drain() {
-    while (active < maxConcurrency && queue.length > 0) {
-      const pending = queue.shift();
-      if (pending === undefined) {
-        return;
-      }
-      active += 1;
-      start(pending);
-    }
-  }
-  function start(pending) {
-    if (pending.kind === "BATCH") {
-      Promise.resolve().then(() => port.evaluateRuleBatch(pending.requests)).then((results) => {
-        active -= 1;
-        pending.settle(results);
-        drain();
-      }, (error) => {
-        active -= 1;
-        pending.fail(error);
-        drain();
-      });
-      return;
-    }
-    Promise.resolve().then(() => port.evaluate(pending.request)).then((result) => {
-      active -= 1;
-      pending.settle(result);
-      drain();
-    }, (error) => {
-      active -= 1;
-      pending.fail(error);
-      drain();
-    });
-  }
-  return {
-    evaluate(request) {
-      return new Promise((settle, fail) => {
-        queue.push({ kind: "SINGLE", request, settle, fail });
-        drain();
-      });
-    },
-    evaluateRuleBatch(requests) {
-      return new Promise((settle, fail) => {
-        queue.push({ kind: "BATCH", requests, settle, fail });
-        drain();
-      });
-    }
-  };
+function planFeedbackDecision(target, decision, feedback) {
+  const previous = latestDecisions(feedback).get(failIdentityKey(target)) ?? null;
+  return previous === decision ? { status: "UNCHANGED" } : { status: "RECORD", previous };
 }
 // packages/core/src/gate/defaults.ts
 var DEFAULT_GATE_CONFIG = {
@@ -1324,31 +1335,32 @@ var DEFAULT_GATE_CONFIG = {
     warning: { warn: 0.6 }
   }
 };
+
 // packages/core/src/gate/config.ts
 function resolveGateConfig(value) {
   if (value === null || value === undefined) {
     return { status: "VALID", config: DEFAULT_GATE_CONFIG };
   }
   if (!isRecord(value) || value.version !== 1) {
-    return invalid();
+    return invalid2();
   }
   const thresholds = value.thresholds;
   if (!isRecord(thresholds)) {
-    return invalid();
+    return invalid2();
   }
   const error = thresholds.error;
   const warning = thresholds.warning;
   if (!isRecord(error) || !isRecord(warning)) {
-    return invalid();
+    return invalid2();
   }
   const errorWarn = error.warn;
   const errorFail = error.fail;
   const warningWarn = warning.warn;
   if (!isProbability(errorWarn) || !isProbability(errorFail) || !isProbability(warningWarn)) {
-    return invalid();
+    return invalid2();
   }
   if (errorWarn >= errorFail) {
-    return invalid();
+    return invalid2();
   }
   return {
     status: "VALID",
@@ -1364,102 +1376,223 @@ function resolveGateConfig(value) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function invalid() {
+function invalid2() {
   return { status: "INVALID", reason: "INVALID_CONFIG" };
 }
 // packages/core/src/remediation/types.ts
-var PROPOSER_AGENT_NAME = "jevguard-proposer";
 var REMEDIATION_MAX_TASK_LENGTH = 16384;
+var MAX_ATTEMPTS_DEFAULT = 2;
+var MAX_ATTEMPTS_CEILING = 3;
+var CHAIN_ID_SOURCE = "[A-Za-z0-9._:-]{1,512}";
+var CHAIN_ID_PATTERN = new RegExp(`^${CHAIN_ID_SOURCE}$`);
+function isAttemptCount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_ATTEMPTS_CEILING;
+}
+var MAX_AGENT_DELIVERIES_PER_SESSION = 3;
+var PROPOSAL_MAX_TEXT_LENGTH = 32768;
+function withinSessionLimit(deliveredInSession) {
+  return deliveredInSession < MAX_AGENT_DELIVERIES_PER_SESSION;
+}
 var DEFAULT_REMEDIATION_CONFIG = {
   autoPropose: true,
   proposeOn: ["FAIL"],
   model: null
 };
 
-// packages/core/src/remediation/request.ts
-function buildProposalRequest(input) {
-  if (!input.config.autoPropose || !input.config.proposeOn.includes("FAIL")) {
-    return null;
-  }
-  if (input.turn.task.length > REMEDIATION_MAX_TASK_LENGTH) {
-    return null;
+// packages/core/src/remediation/chain.ts
+var FNV_PRIME = 16777619;
+var FNV_OFFSETS = [2166136261, 84696351];
+function fnv1a(text, offset) {
+  let hash = offset;
+  for (let index = 0;index < text.length; index += 1) {
+    hash = Math.imul(hash ^ text.charCodeAt(index), FNV_PRIME) >>> 0;
   }
-  const selection = selectTurnEvidence(input.turn, input.evidencePolicy ?? DEFAULT_EVIDENCE_POLICY);
-  if (selection.status !== "SELECTED") {
-    return null;
+  return hash.toString(16).padStart(8, "0");
+}
+function hashOf(text) {
+  return FNV_OFFSETS.map((offset) => fnv1a(text, offset)).join("");
+}
+function idOf(result) {
+  if (result.kind === "RULE")
+    return result.ruleId;
+  return result.kind === "BUILT_IN" ? result.checkId : null;
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort();
+}
+function chainFailuresOf(results) {
+  const failures = [];
+  for (const result of results) {
+    if (result.outcome !== "FAIL")
+      continue;
+    if (result.kind === "RULE" && result.severity !== "error")
+      continue;
+    const id = idOf(result);
+    if (id !== null)
+      failures.push({ id, scopedPaths: [...result.scopedPaths] });
   }
-  const ruleFindings = collectRuleFindings(input.results, indexParsedRules(input.rules));
-  const builtInFindings = collectBuiltInFindings(input.results);
-  if (ruleFindings.length === 0 && builtInFindings.length === 0) {
-    return null;
+  return failures;
+}
+function failureSignature(failures) {
+  const parts = failures.map((failure) => `${failure.id}:${sortedUnique(failure.scopedPaths).join(",")}`);
+  return hashOf(sortedUnique(parts).join("|"));
+}
+function scopesOf(results, ids) {
+  const scopes = {};
+  for (const result of results) {
+    const id = idOf(result);
+    if (id !== null && ids.includes(id))
+      scopes[id] = sortedUnique(result.scopedPaths);
   }
-  return {
-    evaluationId: input.turn.id,
-    sessionID: input.sessionID,
-    messageID: input.turn.id,
-    model: input.config.model,
-    task: input.turn.task,
-    paths: [...selection.evidence.files],
-    diff: selection.evidence.diff,
-    ruleFindings,
-    builtInFindings
-  };
+  return scopes;
 }
-function collectRuleFindings(results, rulesById) {
-  const findings = [];
-  for (const result of results) {
-    if (!isFailingRule(result)) {
-      continue;
-    }
-    const rule = rulesById.get(result.ruleId);
-    if (rule === undefined) {
-      continue;
-    }
-    findings.push({
-      ruleId: rule.id,
-      severity: "error",
-      rule: snapshotRule(rule),
-      probability: result.violationProbability,
-      scopedPaths: [...result.scopedPaths]
-    });
-  }
-  return findings;
+function isJudged(result) {
+  return result.outcome === "PASS" || result.outcome === "FAIL";
 }
-function collectBuiltInFindings(results) {
-  const findings = [];
-  for (const result of results) {
-    if (result.kind !== "BUILT_IN" || result.outcome !== "FAIL") {
-      continue;
-    }
-    findings.push({
-      checkId: result.checkId,
-      severity: result.severity,
-      probability: result.violationProbability,
-      scopedPaths: [...result.scopedPaths]
-    });
-  }
-  return findings;
+function narrowed(before, after) {
+  return before?.some((path) => !after.includes(path)) === true;
 }
-function isFailingRule(result) {
-  return result.kind === "RULE" && result.outcome === "FAIL" && result.severity === "error" && result.ruleId !== null;
+function judgedOf(id, results) {
+  return results.filter((result) => idOf(result) === id && isJudged(result));
 }
-function indexParsedRules(rules) {
-  const byId = new Map;
-  for (const candidate of rules) {
-    if (candidate.status === "PARSED") {
-      byId.set(candidate.rule.id, candidate.rule);
+function hasUnverifiedOrigin(state, results) {
+  return state.originIds.some((id) => {
+    const judged = judgedOf(id, results);
+    return judged.length === 0 || judged.some((result) => narrowed(state.scopes[id], sortedUnique(result.scopedPaths)));
+  });
+}
+function chainIdsOf(state, results) {
+  const resolvedIds = state.originIds.filter((id) => {
+    const judged = judgedOf(id, results);
+    return judged.length > 0 && judged.every((result) => result.outcome === "PASS" && !narrowed(state.scopes[id], sortedUnique(result.scopedPaths)));
+  });
+  return { resolvedIds, remainingIds: state.originIds.filter((id) => !resolvedIds.includes(id)) };
+}
+function unresolvedIds(state) {
+  return { resolvedIds: [], remainingIds: [...state.originIds] };
+}
+function stop(code, input, state, ids = chainIdsOf(state, input.results)) {
+  return { kind: "STOP", code, maxAttempts: input.maxAttempts, state, ids };
+}
+function startOf(input, failures) {
+  if (input.request === null || failures.length === 0)
+    return { kind: "NONE" };
+  const signature = failureSignature(failures);
+  const originIds = sortedUnique(failures.map((failure) => failure.id));
+  return {
+    kind: "DELIVER",
+    chainId: input.turnId,
+    attempt: 1,
+    maxAttempts: input.maxAttempts,
+    signature,
+    state: {
+      chainId: input.turnId,
+      originIds,
+      signatures: [signature],
+      turnIds: [input.turnId],
+      attempts: 1,
+      scopes: scopesOf(input.results, originIds)
     }
+  };
+}
+function continuation(input, state, failures) {
+  if (hasUnverifiedOrigin(state, input.results))
+    return stop("UNVERIFIED", input, state);
+  if (failures.length === 0) {
+    return {
+      kind: "RESOLVED",
+      maxAttempts: input.maxAttempts,
+      state,
+      ids: chainIdsOf(state, input.results)
+    };
   }
-  return byId;
+  if (input.request === null)
+    return stop("UNVERIFIED", input, state);
+  if (failures.some((failure) => !state.originIds.includes(failure.id))) {
+    return stop("REGRESSION_INTRODUCED", input, state);
+  }
+  const signature = failureSignature(failures);
+  if (state.signatures.includes(signature))
+    return stop("REPEATED_FAILURE", input, state);
+  if (state.attempts >= input.maxAttempts)
+    return stop("LIMIT", input, state);
+  const attempt = state.attempts + 1;
+  return {
+    kind: "DELIVER",
+    chainId: state.chainId,
+    attempt,
+    maxAttempts: input.maxAttempts,
+    signature,
+    state: {
+      ...state,
+      signatures: [...state.signatures, signature],
+      turnIds: [...state.turnIds, input.turnId],
+      attempts: attempt,
+      scopes: { ...state.scopes, ...scopesOf(input.results, state.originIds) }
+    }
+  };
 }
-function snapshotRule(rule) {
+function unverifiedWithoutState(input, delivery, known) {
+  const state = known ?? {
+    chainId: delivery.chainId,
+    originIds: [],
+    signatures: [],
+    turnIds: [],
+    attempts: Math.min(Math.max(delivery.attempt, 1), MAX_ATTEMPTS_CEILING),
+    scopes: {}
+  };
+  return stop("UNVERIFIED", input, state, unresolvedIds(state));
+}
+function decideChainStep(input) {
+  if (input.mode === "observe" || input.delivery === "LEGACY")
+    return { kind: "NONE" };
+  const failures = chainFailuresOf(input.results);
+  const { delivery, chain } = input;
+  if (delivery === null)
+    return startOf(input, failures);
+  if (chain === null || chain.chainId !== delivery.chainId || chain.attempts !== delivery.attempt) {
+    return unverifiedWithoutState(input, delivery, chain);
+  }
+  return continuation(input, chain, failures);
+}
+function decideRemediateStep(input) {
+  const { mixed = false, request, ...rest } = input;
+  if (mixed && rest.chain !== null)
+    return decideOrphanStep(rest.chain, rest.maxAttempts);
+  return decideChainStep({ ...rest, mode: "remediate", request: mixed ? null : request });
+}
+function decideOrphanStep(state, maxAttempts) {
+  return { kind: "STOP", code: "UNVERIFIED", maxAttempts, state, ids: unresolvedIds(state) };
+}
+// packages/core/src/remediation/closures.ts
+function expiredClosure(state) {
+  return { state, code: "EXPIRED" };
+}
+function endRecord(state, maxAttempts, result, ids, turnIds) {
   return {
-    id: rule.id,
-    description: rule.description,
-    violation: rule.violation,
-    allowed: rule.allowed ?? ""
+    chainId: state.chainId,
+    turnIds,
+    attempts: state.attempts,
+    maxAttempts,
+    signatures: state.signatures,
+    originIds: state.originIds,
+    resolvedIds: ids.resolvedIds,
+    remainingIds: ids.remainingIds,
+    result
   };
 }
+function chainEndOf(step, turnId) {
+  const { state } = step;
+  const turnIds = state.turnIds.includes(turnId) ? state.turnIds : [...state.turnIds, turnId];
+  return endRecord(state, step.maxAttempts, step.kind === "STOP" ? step.code : "RESOLVED", step.ids, turnIds);
+}
+async function recordClosures(closures, maxAttempts, sink) {
+  for (const { state, code } of closures) {
+    const entry = endRecord(state, Math.max(maxAttempts, state.attempts), code, unresolvedIds(state), state.turnIds);
+    await sink.stopped(code, entry);
+    await sink.record(entry);
+  }
+}
 // packages/core/src/remediation/config.ts
 var MODEL_PATTERN = /^[^\s/]+\/[^\s/]+$/;
 var KNOWN_KEYS = new Set(["auto_propose", "propose_on", "model"]);
@@ -1469,26 +1602,26 @@ function resolveRemediationConfig(value) {
     return valid(DEFAULT_REMEDIATION_CONFIG);
   }
   if (!isRecord2(value)) {
-    return invalid2();
+    return invalid3();
   }
   const remediation = value.remediation;
   if (remediation === undefined) {
     return valid(DEFAULT_REMEDIATION_CONFIG);
   }
   if (!isRecord2(remediation) || hasUnknownKey(remediation)) {
-    return invalid2();
+    return invalid3();
   }
   const autoPropose = remediation.auto_propose ?? DEFAULT_REMEDIATION_CONFIG.autoPropose;
   if (typeof autoPropose !== "boolean") {
-    return invalid2();
+    return invalid3();
   }
   const proposeOn = readProposeOn(remediation.propose_on);
   if (proposeOn === null) {
-    return invalid2();
+    return invalid3();
   }
   const model = resolveModel(remediation.model);
   if (model === INVALID_MODEL) {
-    return invalid2();
+    return invalid3();
   }
   return valid({ autoPropose, proposeOn, model });
 }
@@ -1536,9 +1669,76 @@ function isRecord2(value) {
 function valid(config) {
   return { status: "VALID", config };
 }
-function invalid2() {
+function invalid3() {
   return { status: "INVALID", reason: "INVALID_CONFIG" };
 }
+// packages/core/src/remediation/delivery-findings.ts
+function deliveryFindingsOf(request) {
+  return [
+    ...request.ruleFindings.map((finding) => ({
+      id: finding.ruleId,
+      severity: finding.severity,
+      probability: finding.probability,
+      paths: finding.scopedPaths,
+      violation: finding.rule.violation,
+      allowed: finding.rule.allowed
+    })),
+    ...request.builtInFindings.map((finding) => ({
+      id: finding.checkId,
+      severity: finding.severity,
+      probability: finding.probability,
+      paths: finding.scopedPaths,
+      violation: null,
+      allowed: null
+    }))
+  ];
+}
+// packages/core/src/remediation/delivery-frame.ts
+var AUTO_DELIVERY_MARKER = "[JevGuard remediation proposal \xB7 automatic delivery";
+var AGENT_NOTICE = "Sent by the JevGuard plugin, not typed by the user. Strategy-only proposal generated without tools for the FAIL findings of the previous work unit. Apply it only if it is consistent with the user's instructions; do not change tests, configuration or dependencies without explicit user confirmation.";
+var PROPOSAL_START = "--- proposal start ---";
+var PROPOSAL_END = "--- proposal end ---";
+var CONSTRAINTS = "Constraints: touch only the listed paths; do not change tests, configuration, dependencies or .jev/; do not commit.";
+var STOP_CLAUSE = "If you believe a finding is wrong, say so and stop instead of forcing a change.";
+var CONTROL_CHARACTERS = /(?![\n\t])\p{Cc}/gu;
+var FINDING_TEXT_MAX = 1000;
+var MARK = new RegExp(`\\[JevGuard remediation proposal \xB7 automatic delivery(?: \xB7 [^\\n\\]\xB7]*? \xB7 attempt ([1-9][0-9]*)/([1-9][0-9]*) \xB7 chain (${CHAIN_ID_SOURCE}))?\\]`);
+function clean(text) {
+  return text.replace(CONTROL_CHARACTERS, "");
+}
+function oneLine(text) {
+  return clean(text).replace(/\s+/g, " ").trim().slice(0, FINDING_TEXT_MAX);
+}
+function findingLines(finding) {
+  const head = `- ${oneLine(finding.id)} (${oneLine(finding.severity)}, p=${finding.probability.toFixed(2)}) in ${finding.paths.map(oneLine).join(", ")}`;
+  const lines = [head];
+  if (finding.violation !== null && finding.violation !== "") {
+    lines.push(`  Violation: ${oneLine(finding.violation)}`);
+  }
+  if (finding.allowed !== null && finding.allowed !== "") {
+    lines.push(`  Allowed: ${oneLine(finding.allowed)}`);
+  }
+  return lines;
+}
+function formatAgentDelivery(input) {
+  const strategy = clean(input.strategyText).split(`
+`).filter((line) => line.trim() !== PROPOSAL_START && line.trim() !== PROPOSAL_END);
+  return [
+    `${AUTO_DELIVERY_MARKER} \xB7 ${oneLine(input.unit)} \xB7 attempt ${input.attempt}/${input.maxAttempts} \xB7 chain ${input.chainId}]`,
+    AGENT_NOTICE,
+    "",
+    "Findings:",
+    ...input.findings.flatMap(findingLines),
+    "",
+    PROPOSAL_START,
+    ...strategy,
+    PROPOSAL_END,
+    "",
+    CONSTRAINTS,
+    STOP_CLAUSE
+  ].join(`
+`);
+}
 // packages/core/src/remediation/prompt.ts
 var PROPOSER_AGENT_PROMPT = [
   "JevGuard remediation proposer.",
@@ -1609,6 +1809,90 @@ function section(label, value) {
 ${value}
 `;
 }
+// packages/core/src/remediation/request.ts
+function buildProposalRequest(input) {
+  if (!input.config.autoPropose || !input.config.proposeOn.includes("FAIL")) {
+    return null;
+  }
+  if (input.turn.task.length > REMEDIATION_MAX_TASK_LENGTH) {
+    return null;
+  }
+  const selection = selectTurnEvidence(input.turn, input.evidencePolicy ?? DEFAULT_EVIDENCE_POLICY);
+  if (selection.status !== "SELECTED") {
+    return null;
+  }
+  const ruleFindings = collectRuleFindings(input.results, indexParsedRules(input.rules));
+  const builtInFindings = collectBuiltInFindings(input.results);
+  if (ruleFindings.length === 0 && builtInFindings.length === 0) {
+    return null;
+  }
+  return {
+    evaluationId: input.turn.id,
+    sessionID: input.sessionID,
+    messageID: input.turn.id,
+    model: input.config.model,
+    task: input.turn.task,
+    paths: [...selection.evidence.files],
+    diff: selection.evidence.diff,
+    ruleFindings,
+    builtInFindings
+  };
+}
+function collectRuleFindings(results, rulesById) {
+  const findings = [];
+  for (const result of results) {
+    if (!isFailingRule(result)) {
+      continue;
+    }
+    const rule = rulesById.get(result.ruleId);
+    if (rule === undefined) {
+      continue;
+    }
+    findings.push({
+      ruleId: rule.id,
+      severity: "error",
+      rule: snapshotRule(rule),
+      probability: result.violationProbability,
+      scopedPaths: [...result.scopedPaths]
+    });
+  }
+  return findings;
+}
+function collectBuiltInFindings(results) {
+  const findings = [];
+  for (const result of results) {
+    if (result.kind !== "BUILT_IN" || result.outcome !== "FAIL") {
+      continue;
+    }
+    findings.push({
+      checkId: result.checkId,
+      severity: result.severity,
+      probability: result.violationProbability,
+      scopedPaths: [...result.scopedPaths]
+    });
+  }
+  return findings;
+}
+function isFailingRule(result) {
+  return result.kind === "RULE" && result.outcome === "FAIL" && result.severity === "error" && result.ruleId !== null;
+}
+function indexParsedRules(rules) {
+  const byId = new Map;
+  for (const candidate of rules) {
+    if (candidate.status === "PARSED") {
+      byId.set(candidate.rule.id, candidate.rule);
+    }
+  }
+  return byId;
+}
+function snapshotRule(rule) {
+  return {
+    id: rule.id,
+    description: rule.description,
+    violation: rule.violation,
+    allowed: rule.allowed ?? ""
+  };
+}
 // packages/core/src/remediation/store.ts
 function createRemediationProposalStore() {
   const claimed = new Set;
@@ -1631,6 +1915,561 @@ function createRemediationProposalStore() {
     }
   };
 }
+// packages/core/src/report/aggregate.ts
+function aggregateReviewHistory(records, skippedLineCount, feedback) {
+  const outcomes = emptyAccumulator();
+  const unavailableReasons = new Map;
+  const skippedReasons = new Map;
+  const builtIns = new Map;
+  const rules = new Map;
+  const evaluation = { wholeEvaluations: 0, slicedEvaluations: 0, totalSliceJudgments: 0 };
+  let firstTimestamp = null;
+  let lastTimestamp = null;
+  for (const record of records) {
+    firstTimestamp = earlier(firstTimestamp, record.timestamp);
+    lastTimestamp = later(lastTimestamp, record.timestamp);
+    for (const result of record.results) {
+      countOutcome(outcomes, result.outcome);
+      if (result.outcome === "UNAVAILABLE") {
+        bump(unavailableReasons, result.reason);
+      }
+      if (result.outcome === "SKIPPED") {
+        bump(skippedReasons, result.reason);
+      }
+      if (result.kind === "BUILT_IN") {
+        bump(builtIns, result.checkId);
+      }
+      if (result.kind === "RULE" && result.ruleId !== null) {
+        countRule(rules, result.ruleId, result.outcome, result.evidence);
+      }
+      if (result.kind === "RULE" && result.evidence !== undefined) {
+        countEvidence(evaluation, result.evidence.mode, result.evidence.sliceJudgments.length);
+      }
+    }
+  }
+  return {
+    entryCount: records.length,
+    skippedLineCount,
+    firstTimestamp,
+    lastTimestamp,
+    outcomes: finalizeAccumulator(outcomes),
+    unavailableReasons: sortedReasons(unavailableReasons),
+    skippedReasons: sortedReasons(skippedReasons),
+    builtIns: sortedBuiltIns(builtIns),
+    rules: sortedRules(rules, calibrateRules(records, feedback)),
+    evaluation: finalizeEvaluation(evaluation)
+  };
+}
+function emptyAccumulator() {
+  return { pass: 0, warn: 0, fail: 0, unavailable: 0, skipped: 0 };
+}
+function emptyCalibration() {
+  return { right: 0, wrong: 0, unanswered: 0 };
+}
+function countOutcome(counts, outcome) {
+  switch (outcome) {
+    case "PASS":
+      counts.pass += 1;
+      return;
+    case "WARN":
+      counts.warn += 1;
+      return;
+    case "FAIL":
+      counts.fail += 1;
+      return;
+    case "UNAVAILABLE":
+      counts.unavailable += 1;
+      return;
+    case "SKIPPED":
+      counts.skipped += 1;
+      return;
+  }
+}
+function countRule(rules, ruleId, outcome, evidence) {
+  const accumulator = rules.get(ruleId) ?? { counts: emptyAccumulator(), sliced: 0 };
+  countOutcome(accumulator.counts, outcome);
+  if (evidence?.mode === "SLICED") {
+    accumulator.sliced += 1;
+  }
+  rules.set(ruleId, accumulator);
+}
+function countEvidence(coverage, mode, sliceJudgmentCount) {
+  if (mode === "WHOLE") {
+    coverage.wholeEvaluations += 1;
+    return;
+  }
+  coverage.slicedEvaluations += 1;
+  coverage.totalSliceJudgments += sliceJudgmentCount;
+}
+function finalizeAccumulator(counts) {
+  return {
+    pass: counts.pass,
+    warn: counts.warn,
+    fail: counts.fail,
+    unavailable: counts.unavailable,
+    skipped: counts.skipped,
+    total: counts.pass + counts.warn + counts.fail + counts.unavailable + counts.skipped
+  };
+}
+function finalizeEvaluation(coverage) {
+  return { ...coverage };
+}
+function bump(map, key) {
+  map.set(key, (map.get(key) ?? 0) + 1);
+}
+function sortedReasons(map) {
+  return [...map.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareStrings(left.reason, right.reason));
+}
+function sortedBuiltIns(map) {
+  return [...map.entries()].map(([checkId, count]) => ({ checkId, count })).sort((left, right) => compareStrings(left.checkId, right.checkId));
+}
+function calibrateRules(records, feedback) {
+  const decisions = latestDecisions(feedback);
+  const calibrations = new Map;
+  for (const [key, fail] of collectRuleFails(records)) {
+    const accumulator = calibrations.get(fail.ruleId) ?? emptyCalibration();
+    const decision = decisions.get(key);
+    if (decision === "RIGHT") {
+      accumulator.right += 1;
+    } else if (decision === "WRONG") {
+      accumulator.wrong += 1;
+    } else {
+      accumulator.unanswered += 1;
+    }
+    calibrations.set(fail.ruleId, accumulator);
+  }
+  return calibrations;
+}
+function finalizeCalibration(accumulator) {
+  const { right, wrong, unanswered } = accumulator ?? emptyCalibration();
+  const answered = right + wrong;
+  return { right, wrong, unanswered, precision: answered === 0 ? null : right / answered };
+}
+function sortedRules(map, calibrations) {
+  return [...map.entries()].map(([ruleId, accumulator]) => ({
+    ruleId,
+    counts: finalizeAccumulator(accumulator.counts),
+    slicedRuleCount: accumulator.sliced,
+    calibration: finalizeCalibration(calibrations.get(ruleId))
+  })).sort((left, right) => compareStrings(left.ruleId, right.ruleId));
+}
+function earlier(current, candidate) {
+  return current === null || candidate < current ? candidate : current;
+}
+function later(current, candidate) {
+  return current === null || candidate > current ? candidate : current;
+}
+// packages/core/src/review/policy.ts
+async function loadPolicy(policy) {
+  try {
+    return await policy.load();
+  } catch {
+    return null;
+  }
+}
+function readPolicyConfig(loaded, parseConfig) {
+  if (loaded === null || loaded.status === "FAILED") {
+    return invalidPolicyConfig();
+  }
+  return diagnosePolicyConfig(loaded.source.config, parseConfig).config;
+}
+function diagnosePolicyConfig(config, parseConfig) {
+  const parsed = config === null ? null : parseConfig(config);
+  if (parsed !== null && parsed.status !== "PARSED") {
+    return { code: "PARSE_INVALID", config: invalidPolicyConfig() };
+  }
+  const value = parsed === null ? null : parsed.value;
+  const gate = resolveGateConfig(value);
+  const remediation = resolveRemediationConfig(value);
+  if (gate.status === "INVALID") {
+    return { code: "GATE_INVALID", config: invalidPolicyConfig() };
+  }
+  if (remediation.status === "INVALID") {
+    return { code: "REMEDIATION_INVALID", config: invalidPolicyConfig() };
+  }
+  return { code: config === null ? "DEFAULTS" : "VALID", config: { gate, remediation } };
+}
+function invalidPolicyConfig() {
+  return {
+    gate: { status: "INVALID", reason: "INVALID_CONFIG" },
+    remediation: { status: "INVALID", reason: "INVALID_CONFIG" }
+  };
+}
+
+// packages/core/src/rules/headings.ts
+var RULE_HEADING = /^##\s+(.*)$/;
+var SECTION_HEADING = /^###\s+(.*)$/;
+function matchRuleHeading(line) {
+  const match = RULE_HEADING.exec(line);
+  if (match === null) {
+    return null;
+  }
+  return (match[1] ?? "").trim();
+}
+function matchSectionHeading(line) {
+  const match = SECTION_HEADING.exec(line);
+  if (match === null) {
+    return null;
+  }
+  return (match[1] ?? "").trim();
+}
+
+// packages/core/src/rules/metadata.ts
+var METADATA_ENTRY = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/;
+function parseRuleMetadata(lines) {
+  let severity = null;
+  let evidence = null;
+  let scopeDeclared = false;
+  const includePatterns = [];
+  const excludePatterns = [];
+  const seenKeys = new Set;
+  for (const line of collectMetadataLines(lines)) {
+    const entry = parseMetadataEntry(line);
+    if (entry === null) {
+      return { ok: false, code: "MALFORMED_METADATA" };
+    }
+    if (entry.key === "scope") {
+      const pattern = parseScopePattern(entry.value);
+      if (pattern === null) {
+        return { ok: false, code: "MALFORMED_METADATA" };
+      }
+      scopeDeclared = true;
+      if (pattern.exclude) {
+        excludePatterns.push(pattern.pattern);
+      } else {
+        includePatterns.push(pattern.pattern);
+      }
+      continue;
+    }
+    if (seenKeys.has(entry.key)) {
+      return { ok: false, code: "DUPLICATE_METADATA" };
+    }
+    seenKeys.add(entry.key);
+    if (entry.key === "severity") {
+      const parsed = parseSeverity(entry.value);
+      if (parsed === null) {
+        return { ok: false, code: "INVALID_SEVERITY" };
+      }
+      severity = parsed;
+      continue;
+    }
+    if (entry.key === "evidence") {
+      const parsed = parseEvidenceClass(entry.value);
+      if (parsed === null) {
+        return { ok: false, code: "MALFORMED_METADATA" };
+      }
+      evidence = parsed;
+      continue;
+    }
+    return { ok: false, code: "MALFORMED_METADATA" };
+  }
+  if (severity === null) {
+    return { ok: false, code: "MISSING_SEVERITY" };
+  }
+  if (scopeDeclared && includePatterns.length === 0) {
+    return { ok: false, code: "MALFORMED_METADATA" };
+  }
+  const scope = scopeDeclared ? { include: includePatterns, exclude: excludePatterns } : null;
+  return { ok: true, value: { severity, scope, evidence: evidence ?? "code" } };
+}
+function collectMetadataLines(lines) {
+  const collected = [];
+  for (const line of lines) {
+    if (matchSectionHeading(line) !== null) {
+      break;
+    }
+    if (line.trim() !== "") {
+      collected.push(line);
+    }
+  }
+  return collected;
+}
+function parseMetadataEntry(line) {
+  const match = METADATA_ENTRY.exec(line);
+  if (match === null) {
+    return null;
+  }
+  return { key: match[1] ?? "", value: (match[2] ?? "").trim() };
+}
+function parseSeverity(value) {
+  switch (value) {
+    case "error":
+    case "warning":
+      return value;
+    default:
+      return null;
+  }
+}
+function parseEvidenceClass(value) {
+  switch (value) {
+    case "code":
+    case "docs":
+    case "any":
+      return value;
+    default:
+      return null;
+  }
+}
+function parseScopePattern(value) {
+  if (value === "") {
+    return null;
+  }
+  if (value.startsWith("!")) {
+    const pattern = value.slice(1).trim();
+    return pattern === "" ? null : { pattern, exclude: true };
+  }
+  return { pattern: value, exclude: false };
+}
+
+// packages/core/src/rules/sections.ts
+var SECTION_NAMES = ["Rule", "Violation", "Allowed"];
+function parseRuleSections(lines) {
+  const collected = collectSections(lines);
+  if (!collected.ok) {
+    return collected;
+  }
+  return validateSections(collected.value);
+}
+function collectSections(lines) {
+  const sections = new Map;
+  let current = null;
+  let content = [];
+  for (const line of lines) {
+    const heading = matchSectionHeading(line);
+    if (heading === null) {
+      if (current !== null) {
+        content.push(line);
+      }
+      continue;
+    }
+    if (current !== null) {
+      sections.set(current, joinContent(content));
+    }
+    if (!SECTION_NAMES.includes(heading)) {
+      return { ok: false, code: "UNKNOWN_SECTION" };
+    }
+    if (sections.has(heading)) {
+      return { ok: false, code: "DUPLICATE_SECTION" };
+    }
+    current = heading;
+    content = [];
+  }
+  if (current !== null) {
+    sections.set(current, joinContent(content));
+  }
+  return { ok: true, value: sections };
+}
+function validateSections(sections) {
+  const rule = sections.get("Rule");
+  const violation = sections.get("Violation");
+  const allowed = sections.get("Allowed") ?? null;
+  if (rule === undefined) {
+    return { ok: false, code: "MISSING_RULE" };
+  }
+  if (violation === undefined) {
+    return { ok: false, code: "MISSING_VIOLATION" };
+  }
+  if (rule === "") {
+    return { ok: false, code: "EMPTY_SECTION" };
+  }
+  if (violation === "") {
+    return { ok: false, code: "EMPTY_SECTION" };
+  }
+  if (allowed === "") {
+    return { ok: false, code: "EMPTY_ALLOWED" };
+  }
+  if (allowed !== null && allowed === violation) {
+    return { ok: false, code: "ALLOWED_EQUALS_VIOLATION" };
+  }
+  return { ok: true, value: { rule, violation, allowed } };
+}
+function joinContent(lines) {
+  return lines.join(`
+`).trim();
+}
+
+// packages/core/src/rules/blocks.ts
+var RULE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function isValidRuleId(id) {
+  return RULE_ID.test(id);
+}
+function collectRuleBlocks(text) {
+  const blocks = [];
+  let current = null;
+  for (const line of splitLines2(text)) {
+    const id = matchRuleHeading(line);
+    if (id !== null) {
+      current = { id, body: [] };
+      blocks.push(current);
+      continue;
+    }
+    if (current !== null) {
+      current.body.push(line);
+    }
+  }
+  return blocks;
+}
+function parseRuleBlock(block, duplicate) {
+  if (!isValidRuleId(block.id)) {
+    return ruleCandidateFailure("INVALID_ID", null);
+  }
+  if (duplicate) {
+    return ruleCandidateFailure("DUPLICATE_ID", block.id);
+  }
+  const metadata = parseRuleMetadata(block.body);
+  if (!metadata.ok) {
+    return ruleCandidateFailure(metadata.code, block.id);
+  }
+  const sections = parseRuleSections(block.body);
+  if (!sections.ok) {
+    return ruleCandidateFailure(sections.code, block.id);
+  }
+  return {
+    status: "PARSED",
+    rule: buildParsedRule(block.id, metadata.value, sections.value)
+  };
+}
+function ruleCandidateFailure(code, ruleId) {
+  return { status: "INVALID", reason: "INVALID_RULE", code, ruleId };
+}
+function splitLines2(text) {
+  return text.replace(/\r\n?/g, `
+`).split(`
+`);
+}
+function buildParsedRule(id, metadata, sections) {
+  return {
+    id,
+    severity: metadata.severity,
+    scope: metadata.scope,
+    evidence: metadata.evidence,
+    description: sections.rule,
+    violation: sections.violation,
+    allowed: sections.allowed
+  };
+}
+
+// packages/core/src/rules/parse-rules.ts
+function parseRules(text) {
+  const blocks = collectRuleBlocks(text);
+  if (blocks.length === 0) {
+    return [ruleCandidateFailure("MISSING_ID", null)];
+  }
+  const duplicates = findDuplicateIds(blocks.map((block) => block.id));
+  return blocks.map((block) => parseRuleBlock(block, duplicates.has(block.id)));
+}
+function findDuplicateIds(ids) {
+  const counts = new Map;
+  for (const id of ids) {
+    if (!isValidRuleId(id)) {
+      continue;
+    }
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  const duplicates = new Set;
+  for (const [id, count] of counts) {
+    if (count > 1) {
+      duplicates.add(id);
+    }
+  }
+  return duplicates;
+}
+
+// packages/core/src/review/unavailable.ts
+function reviewLevelUnavailable(turnId, reason) {
+  return {
+    kind: "REVIEW",
+    turnId,
+    ruleId: null,
+    severity: null,
+    scopedPaths: [],
+    outcome: "UNAVAILABLE",
+    reason
+  };
+}
+function unavailableReview(turnId, reason) {
+  return aggregateReview(turnId, [reviewLevelUnavailable(turnId, reason)]);
+}
+
+// packages/core/src/review/rule-lane.ts
+function resolveRuleCandidates(turnId, loaded) {
+  if (loaded === null) {
+    return unavailableResolution(turnId, "INVALID_RULE");
+  }
+  if (loaded.status === "FAILED") {
+    const reason = loaded.reason === "CONFIG_READ_FAILURE" ? "INVALID_CONFIG" : "INVALID_RULE";
+    return unavailableResolution(turnId, reason);
+  }
+  const rules = loaded.source.rules;
+  if (rules === null) {
+    return unavailableResolution(turnId, "INVALID_RULE");
+  }
+  return { status: "RULES", rules: parseRules(rules) };
+}
+async function evaluateRuleCandidates(turn, rules, gate, dependencies) {
+  const review = await evaluateRules({
+    turn,
+    rules,
+    gateConfig: gate,
+    evidencePolicy: DEFAULT_EVIDENCE_POLICY
+  }, { jev: dependencies.jev });
+  return { results: review.results, rules };
+}
+function ruleLaneUnavailable(turnId, reason) {
+  return { results: [reviewLevelUnavailable(turnId, reason)], rules: [] };
+}
+function unavailableResolution(turnId, reason) {
+  return { status: "UNAVAILABLE", lane: ruleLaneUnavailable(turnId, reason) };
+}
+
+// packages/core/src/review/check-rules.ts
+async function checkRules(input, dependencies) {
+  const { turn, ruleId } = input;
+  const loaded = await loadPolicy(dependencies.policy);
+  const resolution = resolveRuleCandidates(turn.id, loaded);
+  if (resolution.status === "UNAVAILABLE") {
+    return { status: "REVIEWED", review: aggregateReview(turn.id, resolution.lane.results) };
+  }
+  const candidates = selectCandidates(resolution.rules, ruleId);
+  if (candidates.length === 0) {
+    return { status: "RULE_NOT_FOUND" };
+  }
+  const config = readPolicyConfig(loaded, dependencies.parseConfig);
+  const lane = await evaluateRuleCandidates(turn, candidates, config.gate, dependencies);
+  return { status: "REVIEWED", review: aggregateReview(turn.id, lane.results) };
+}
+function selectCandidates(rules, ruleId) {
+  if (ruleId === null) {
+    return rules;
+  }
+  return rules.filter((candidate) => candidateId(candidate) === ruleId);
+}
+function candidateId(candidate) {
+  return candidate.status === "PARSED" ? candidate.rule.id : candidate.ruleId;
+}
+// packages/core/src/review/review-turn.ts
+async function reviewTurn(turn, dependencies) {
+  const loaded = await loadPolicy(dependencies.policy);
+  const config = readPolicyConfig(loaded, dependencies.parseConfig);
+  const builtInInput = { turn, evidencePolicy: DEFAULT_EVIDENCE_POLICY };
+  const [ruleLane, builtIns] = await Promise.all([
+    evaluateRuleLane(turn, loaded, config.gate, dependencies),
+    evaluateBuiltIns(builtInInput, { jev: dependencies.jev })
+  ]);
+  const review = aggregateReview(turn.id, [
+    ...ruleLane.results,
+    builtIns.scopeCreep,
+    builtIns.complexity
+  ]);
+  return { review, rules: ruleLane.rules, remediation: config.remediation };
+}
+async function evaluateRuleLane(turn, loaded, gate, dependencies) {
+  const resolution = resolveRuleCandidates(turn.id, loaded);
+  if (resolution.status === "UNAVAILABLE") {
+    return resolution.lane;
+  }
+  return evaluateRuleCandidates(turn, resolution.rules, gate, dependencies);
+}
 // packages/plugin/src/skills/jevguard-rules/rules-summary.ts
 function summarizeRules(text) {
   const results = parseRules(text);