@pablozrrrr/jevguard 0.2.2 → 0.3.0

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

@@ -3,43 +3,70 @@
 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 = {
   maxDiffLength: DEFAULT_MAX_DIFF_LENGTH,
-  allowedExtensions: [
+  codeExtensions: [
     ".ts",
     ".tsx",
     ".mts",
@@ -50,9 +77,6 @@ var DEFAULT_EVIDENCE_POLICY = {
     ".cjs",
     ".json",
     ".jsonc",
-    ".md",
-    ".mdx",
-    ".txt",
     ".yaml",
     ".yml",
     ".toml",
@@ -108,6 +132,7 @@ var DEFAULT_EVIDENCE_POLICY = {
     ".diff",
     ".patch"
   ],
+  docsExtensions: [".md", ".mdx", ".txt"],
   deniedFileNames: [
     ".env",
     ".envrc",
@@ -182,18 +207,26 @@ function checkFilePath(path, policy) {
   if (policy.deniedExtensions.includes(extension)) {
     return DENIED_SENSITIVE;
   }
-  if (!policy.allowedExtensions.includes(extension)) {
+  if (!isAllowlistedExtension(extension, policy)) {
     return DENIED_EXTENSION;
   }
   return { allowed: true };
 }
+function isAllowlistedExtension(extension, policy) {
+  return policy.codeExtensions.includes(extension) || policy.docsExtensions.includes(extension);
+}
 function matchesDeniedFileName(basename, policy) {
   return policy.deniedFileNames.some((name) => name.startsWith(".") ? basename === name || basename.startsWith(`${name}.`) : basename === name);
 }
 
 // packages/core/src/evidence/scope.ts
-function matchesScope(path, scope) {
-  return globToRegExp(scope).test(normalizePath(path));
+function matchesRuleScope(path, scope) {
+  const normalized = normalizePath(path);
+  const included = scope.include.some((pattern) => globToRegExp(pattern).test(normalized));
+  if (!included) {
+    return false;
+  }
+  return !scope.exclude.some((pattern) => globToRegExp(pattern).test(normalized));
 }
 function globToRegExp(glob) {
   const source = glob.replace(/\\/g, "/");
@@ -220,16 +253,6 @@ function globToRegExp(glob) {
 }
 
 // packages/core/src/evidence/select-evidence.ts
-function selectRuleEvidence(turn, rule, policy = DEFAULT_EVIDENCE_POLICY) {
-  if (hasNoAttributedPatch(turn)) {
-    return { status: "SKIPPED", reason: "NO_ATTRIBUTED_PATCH" };
-  }
-  const applicableFiles = selectApplicableFiles(turn.files, rule.scope);
-  if (applicableFiles.length === 0) {
-    return { status: "SKIPPED", reason: "NO_SCOPE_MATCH" };
-  }
-  return mountEvidence(applicableFiles, policy);
-}
 function selectTurnEvidence(turn, policy = DEFAULT_EVIDENCE_POLICY) {
   if (hasNoAttributedPatch(turn)) {
     return { status: "SKIPPED", reason: "NO_ATTRIBUTED_PATCH" };
@@ -256,11 +279,21 @@ function mountEvidence(files, policy) {
 function hasNoAttributedPatch(turn) {
   return turn.files.every((file) => file.patch.trim() === "");
 }
-function selectApplicableFiles(files, scope) {
-  if (scope === null) {
-    return files;
+function selectApplicableFiles(files, scope, evidenceClass, policy) {
+  const scoped = scope === null ? files : files.filter((file) => matchesRuleScope(file.path, scope));
+  return scoped.filter((file) => isInEvidenceClass(file.path, evidenceClass, policy));
+}
+function isInEvidenceClass(path, evidenceClass, policy) {
+  if (evidenceClass === "any") {
+    return true;
+  }
+  const safety = checkFilePath(path, policy);
+  if (!safety.allowed && safety.reason === "DENIED_SENSITIVE_PATH") {
+    return true;
   }
-  return files.filter((file) => matchesScope(file.path, scope));
+  const extension = fileExtension(path);
+  const otherClass = evidenceClass === "code" ? policy.docsExtensions : policy.codeExtensions;
+  return !otherClass.includes(extension);
 }
 function assembleDiff(files) {
   return files.map((file) => file.patch).join(`
@@ -300,592 +333,1034 @@ function evaluateWarningGate(probability, thresholds) {
   return { outcome: "WARN", violationProbability: probability };
 }
 
-// packages/core/src/evaluation/evaluate-with-port.ts
-async function evaluateWithPort(port, request) {
-  try {
-    const result = await port.evaluate(request);
-    return result.kind === "RULE" ? result : { kind: "RULE", status: "FAILED", reason: "INVALID_RESPONSE" };
-  } catch {
-    return { kind: "RULE", status: "FAILED", reason: "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
+    }
+  };
 }
-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" };
-  }
+function buildScopeCreepContext(turn, scopedPaths) {
+  return {
+    kind: "BUILT_IN",
+    turnId: turn.id,
+    ruleId: null,
+    checkId: SCOPE_CREEP_CHECK_ID,
+    severity: "error",
+    scopedPaths
+  };
 }
 
-// packages/core/src/evaluation/evaluate-rule.ts
-async function evaluateRule(input, dependencies) {
-  const selection = selectRuleEvidence(input.turn, input.rule, input.evidencePolicy);
+// 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") {
-    const context = buildReviewContext(input.turn, input.rule, []);
-    return { ...context, outcome: "SKIPPED", reason: selection.reason };
+    return {
+      scopeCreep: {
+        ...buildScopeCreepContext(input.turn, []),
+        outcome: "SKIPPED",
+        reason: selection.reason
+      },
+      complexity: {
+        ...buildComplexityContext(input.turn, []),
+        outcome: "SKIPPED",
+        reason: selection.reason
+      }
+    };
   }
   if (selection.status === "UNAVAILABLE") {
-    const context = buildReviewContext(input.turn, input.rule, []);
-    return { ...context, outcome: "UNAVAILABLE", reason: selection.reason };
+    return {
+      scopeCreep: {
+        ...buildScopeCreepContext(input.turn, []),
+        outcome: "UNAVAILABLE",
+        reason: selection.reason
+      },
+      complexity: {
+        ...buildComplexityContext(input.turn, []),
+        outcome: "UNAVAILABLE",
+        reason: selection.reason
+      }
+    };
   }
-  const context = buildReviewContext(input.turn, input.rule, selection.evidence.files);
-  const request = buildJevRequest(input.turn.task, input.rule, selection.evidence);
-  const evaluation = await evaluateWithPort(dependencies.jev, request);
+  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 { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
+    return {
+      scopeCreep: { ...scopeCreepContext, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" },
+      complexity: { ...complexityContext, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" }
+    };
   }
-  const gate = evaluateGate(input.rule.severity, evaluation.noul.violationProbability, input.gateConfig);
-  return { ...context, ...gate };
-}
-// packages/core/src/review/aggregate.ts
-var VERDICT_RANK = { PASS: 0, WARN: 1, FAIL: 2 };
-function aggregateReview(turnId, results) {
-  const snapshot = [...results];
-  return { turnId, results: snapshot, summary: summarize(snapshot) };
-}
-function summarize(results) {
-  const counts = countOutcomes(results);
   return {
-    verdict: highestVerdict(results),
-    hasUnavailable: counts.unavailable > 0,
-    counts
+    scopeCreep: gateScopeCreep(evaluation.answers.scopeCreep, scopeCreepContext),
+    complexity: gateComplexity(evaluation.answers.complexity, complexityContext)
   };
 }
-function countOutcomes(results) {
-  const counts = { pass: 0, warn: 0, fail: 0, skipped: 0, unavailable: 0 };
-  for (const result of results) {
-    switch (result.outcome) {
-      case "PASS":
-        counts.pass += 1;
-        break;
-      case "WARN":
-        counts.warn += 1;
-        break;
-      case "FAIL":
-        counts.fail += 1;
-        break;
-      case "SKIPPED":
-        counts.skipped += 1;
-        break;
-      case "UNAVAILABLE":
-        counts.unavailable += 1;
-        break;
-    }
-  }
-  return counts;
-}
-function highestVerdict(results) {
-  let highest = null;
-  for (const result of results) {
-    if (!isSemanticVerdict(result.outcome)) {
-      continue;
-    }
-    if (highest === null || VERDICT_RANK[result.outcome] > VERDICT_RANK[highest]) {
-      highest = result.outcome;
-    }
-  }
-  return highest;
-}
-function isSemanticVerdict(outcome) {
-  return outcome === "PASS" || outcome === "WARN" || outcome === "FAIL";
-}
-
-// packages/core/src/evaluation/evaluate-rules.ts
-async function evaluateRules(input, dependencies) {
-  const results = [];
-  for (const rule of input.rules) {
-    results.push(await evaluateRuleResult(input, rule, dependencies));
-  }
-  return aggregateReview(input.turn.id, results);
-}
-async function evaluateRuleResult(input, rule, dependencies) {
-  if (rule.status === "INVALID") {
-    return invalidRuleResult(input.turn.id, rule);
-  }
-  if (input.gateConfig.status === "INVALID") {
-    return invalidConfigResult(input.turn, rule.rule);
+function gateScopeCreep(answer, context) {
+  if (answer.status === "FAILED") {
+    return { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
   }
-  const ruleInput = {
-    turn: input.turn,
-    rule: rule.rule,
-    gateConfig: input.gateConfig.config,
-    evidencePolicy: input.evidencePolicy
+  return {
+    ...context,
+    ...evaluateGate("error", answer.noul.violationProbability, SCOPE_CREEP_GATE_CONFIG)
   };
-  return evaluateRule(ruleInput, dependencies);
 }
-function invalidRuleResult(turnId, failure) {
+function gateComplexity(answer, context) {
+  if (answer.status === "FAILED") {
+    return { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
+  }
   return {
-    kind: "RULE",
-    turnId,
-    ruleId: failure.ruleId,
-    severity: null,
-    scopedPaths: [],
-    outcome: "UNAVAILABLE",
-    reason: "INVALID_RULE"
+    ...context,
+    ...evaluateGate("warning", answer.noul.violationProbability, COMPLEXITY_GATE_CONFIG)
   };
 }
-function invalidConfigResult(turn, rule) {
-  return {
-    ...buildReviewContext(turn, rule, []),
-    outcome: "UNAVAILABLE",
-    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;
+// 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");
   }
-  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 scope = null;
-  const seenKeys = new Set;
-  for (const line of collectMetadataLines(lines)) {
-    const entry = parseMetadataEntry(line);
-    if (entry === null) {
-      return { ok: false, code: "MALFORMED_METADATA" };
+  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);
     }
-    if (seenKeys.has(entry.key)) {
-      return { ok: false, code: "DUPLICATE_METADATA" };
+  }
+  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;
     }
-    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;
+    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();
+      });
     }
-    if (entry.key === "scope") {
-      if (entry.value === "") {
-        return { ok: false, code: "MALFORMED_METADATA" };
+  };
+}
+// 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 }
       }
-      scope = entry.value;
-      continue;
-    }
-    return { ok: false, code: "MALFORMED_METADATA" };
+    },
+    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" };
   }
-  if (severity === null) {
-    return { ok: false, code: "MISSING_SEVERITY" };
+  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" };
   }
-  return { ok: true, value: { severity, scope } };
+  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 collectMetadataLines(lines) {
-  const collected = [];
-  for (const line of lines) {
-    if (matchSectionHeading(line) !== null) {
-      break;
+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;
     }
-    if (line.trim() !== "") {
-      collected.push(line);
+    const hunks = sliceHunks(slices.length, file, policy);
+    if (hunks === null) {
+      return { status: "UNAVAILABLE", reason: "OVERSIZED_DIFF" };
     }
+    slices.push(...hunks);
   }
-  return collected;
+  return { status: "PLANNED", slices };
 }
-function parseMetadataEntry(line) {
-  const match = METADATA_ENTRY.exec(line);
-  if (match === null) {
+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;
   }
-  return { key: match[1] ?? "", value: (match[2] ?? "").trim() };
-}
-function parseSeverity(value) {
-  switch (value) {
-    case "error":
-    case "warning":
-      return value;
-    default:
+  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];
+    if (start === undefined) {
+      return null;
+    }
+    const end = starts[ordinal + 1] ?? file.patch.length;
+    const rendered = preamble + file.patch.slice(start, end);
+    if (rendered.length > policy.maxDiffLength) {
       return null;
+    }
+    slices.push({
+      index: startIndex + ordinal,
+      kind: "HUNK",
+      path: file.path,
+      hunkOrdinal: ordinal,
+      files: [file.path],
+      diff: rendered
+    });
   }
+  return slices;
+}
+function hunkStarts(patch) {
+  return Array.from(patch.matchAll(HUNK_MARKER), (match) => match.index ?? 0);
 }
 
-// packages/core/src/rules/sections.ts
-var SECTION_NAMES = ["Rule", "Violation", "Allowed"];
-function parseRuleSections(lines) {
-  const collected = collectSections(lines);
-  if (!collected.ok) {
-    return collected;
+// packages/core/src/evidence/slice-budget.ts
+var MAX_SLICES_PER_RULE = 16;
+var MAX_EXTRA_RULE_CALLS_PER_TURN = 32;
+function planTurnRuleSlices(plans) {
+  let remainingExtraCalls = MAX_EXTRA_RULE_CALLS_PER_TURN;
+  return plans.map((plan) => {
+    if (plan.status !== "PLANNED") {
+      return plan;
+    }
+    const extraCalls = plan.slices.length - 1;
+    if (plan.slices.length > MAX_SLICES_PER_RULE || extraCalls > remainingExtraCalls) {
+      return { status: "SLICE_LIMIT_EXCEEDED", slices: plan.slices };
+    }
+    remainingExtraCalls -= extraCalls;
+    return plan;
+  });
+}
+
+// packages/core/src/review/aggregate.ts
+var VERDICT_RANK = { PASS: 0, WARN: 1, FAIL: 2 };
+function aggregateReview(turnId, results) {
+  const snapshot = [...results];
+  return { turnId, results: snapshot, summary: summarize(snapshot) };
+}
+function summarize(results) {
+  const counts = countOutcomes(results);
+  return {
+    verdict: highestVerdict(results),
+    hasUnavailable: counts.unavailable > 0,
+    counts
+  };
+}
+function countOutcomes(results) {
+  const counts = { pass: 0, warn: 0, fail: 0, skipped: 0, unavailable: 0 };
+  for (const result of results) {
+    switch (result.outcome) {
+      case "PASS":
+        counts.pass += 1;
+        break;
+      case "WARN":
+        counts.warn += 1;
+        break;
+      case "FAIL":
+        counts.fail += 1;
+        break;
+      case "SKIPPED":
+        counts.skipped += 1;
+        break;
+      case "UNAVAILABLE":
+        counts.unavailable += 1;
+        break;
+    }
   }
-  return validateSections(collected.value);
+  return counts;
 }
-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);
-      }
+function highestVerdict(results) {
+  let highest = null;
+  for (const result of results) {
+    if (!isSemanticVerdict(result.outcome)) {
       continue;
     }
-    if (current !== null) {
-      sections.set(current, joinContent(content));
+    if (highest === null || VERDICT_RANK[result.outcome] > VERDICT_RANK[highest]) {
+      highest = result.outcome;
     }
-    if (!SECTION_NAMES.includes(heading)) {
-      return { ok: false, code: "UNKNOWN_SECTION" };
+  }
+  return highest;
+}
+function isSemanticVerdict(outcome) {
+  return outcome === "PASS" || outcome === "WARN" || outcome === "FAIL";
+}
+
+// packages/core/src/evaluation/assemble-rule.ts
+var VERDICT_RANK2 = { PASS: 0, WARN: 1, FAIL: 2 };
+function assembleSlicedRuleResult(rule, context, slices, evaluations, gateConfig) {
+  if (slices.length === 0) {
+    return { ...context, outcome: "SKIPPED", reason: "NO_SCOPE_MATCH" };
+  }
+  const summaries = slices.map(sliceSummary);
+  const mode = evidenceMode(slices.length);
+  const gates = [];
+  const judgments = [];
+  let failureIndex = null;
+  for (let index = 0;index < slices.length; index += 1) {
+    const slice = slices[index];
+    const evaluation = evaluations[index];
+    if (slice === undefined || evaluation === undefined || evaluation.status === "FAILED") {
+      failureIndex = index;
+      break;
     }
-    if (sections.has(heading)) {
-      return { ok: false, code: "DUPLICATE_SECTION" };
+    const gate = evaluateGate(rule.severity, evaluation.noul.violationProbability, gateConfig);
+    if (gate.outcome === "UNAVAILABLE") {
+      failureIndex = index;
+      break;
     }
-    current = heading;
-    content = [];
+    gates.push(gate);
+    judgments.push({
+      index: slice.index,
+      probability: gate.violationProbability,
+      outcome: gate.outcome
+    });
   }
-  if (current !== null) {
-    sections.set(current, joinContent(content));
+  if (failureIndex !== null) {
+    return {
+      ...context,
+      outcome: "UNAVAILABLE",
+      reason: "JEV_FAILURE",
+      evidence: failedMetadata(mode, summaries, failureIndex)
+    };
   }
-  return { ok: true, value: sections };
+  return {
+    ...context,
+    outcome: mergeVerdict(gates),
+    violationProbability: maxProbability(gates),
+    evidence: completeMetadata(mode, summaries, judgments)
+  };
 }
-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 overBudgetMetadata(slices) {
+  const summaries = slices.map(sliceSummary);
+  return {
+    mode: "SLICED",
+    plannedSliceCount: summaries.length,
+    evaluatedSliceCount: 0,
+    failedSliceCount: 0,
+    notEvaluatedSliceCount: summaries.length,
+    slices: summaries,
+    sliceJudgments: [],
+    failingSliceIndex: null,
+    failureReason: "SLICE_LIMIT_EXCEEDED"
+  };
+}
+function sliceSummary(slice) {
+  return {
+    index: slice.index,
+    path: slice.path,
+    kind: slice.kind,
+    hunkOrdinal: slice.hunkOrdinal
+  };
+}
+function evidenceMode(sliceCount) {
+  return sliceCount === 1 ? "WHOLE" : "SLICED";
+}
+function mergeVerdict(gates) {
+  let verdict = "PASS";
+  for (const gate of gates) {
+    if (VERDICT_RANK2[gate.outcome] > VERDICT_RANK2[verdict]) {
+      verdict = gate.outcome;
+    }
   }
-  if (rule === "") {
-    return { ok: false, code: "EMPTY_SECTION" };
+  return verdict;
+}
+function maxProbability(gates) {
+  return gates.reduce((highest, gate) => Math.max(highest, gate.violationProbability), Number.NEGATIVE_INFINITY);
+}
+function completeMetadata(mode, summaries, judgments) {
+  return {
+    mode,
+    plannedSliceCount: summaries.length,
+    evaluatedSliceCount: summaries.length,
+    failedSliceCount: 0,
+    notEvaluatedSliceCount: 0,
+    slices: summaries,
+    sliceJudgments: judgments,
+    failingSliceIndex: null,
+    failureReason: null
+  };
+}
+function failedMetadata(mode, summaries, failingIndex) {
+  return {
+    mode,
+    plannedSliceCount: summaries.length,
+    evaluatedSliceCount: failingIndex,
+    failedSliceCount: 1,
+    notEvaluatedSliceCount: summaries.length - failingIndex - 1,
+    slices: summaries,
+    sliceJudgments: [],
+    failingSliceIndex: failingIndex,
+    failureReason: "JEV_FAILURE"
+  };
+}
+
+// packages/core/src/evaluation/evaluate-rules.ts
+async function evaluateRules(input, dependencies) {
+  if (input.gateConfig.status === "INVALID") {
+    const results = input.rules.map((candidate) => candidate.status === "INVALID" ? invalidRuleResult(input.turn.id, candidate) : invalidConfigResult(input.turn, candidate.rule));
+    return aggregateReview(input.turn.id, results);
+  }
+  const gateConfig = input.gateConfig.config;
+  const slots = resolveSlots(input);
+  const requests = collectRequests(input.turn.task, slots);
+  const evaluations = requests.length === 0 ? [] : await evaluateRuleBatchWithPort(dependencies.jev, requests);
+  return aggregateReview(input.turn.id, assembleResults(input, slots, evaluations, gateConfig));
+}
+function resolveSlots(input) {
+  const planned = input.rules.map((candidate) => candidate.status === "INVALID" ? { kind: "RESULT", result: invalidRuleResult(input.turn.id, candidate) } : {
+    kind: "PLAN",
+    rule: candidate.rule,
+    plan: planRuleEvidence(input.turn, candidate.rule, input.evidencePolicy)
+  });
+  const budgeted = planTurnRuleSlices(planned.flatMap((slot) => slot.kind === "PLAN" ? [slot.plan] : []));
+  let cursor = 0;
+  return planned.map((slot) => {
+    if (slot.kind === "RESULT") {
+      return slot;
+    }
+    const plan = budgeted[cursor];
+    cursor += 1;
+    return plan === undefined ? slot : { kind: "PLAN", rule: slot.rule, plan };
+  });
+}
+function collectRequests(task, slots) {
+  const requests = [];
+  for (const slot of slots) {
+    if (slot.kind !== "PLAN" || slot.plan.status !== "PLANNED") {
+      continue;
+    }
+    for (const slice of slot.plan.slices) {
+      requests.push(buildJevRequest(task, slot.rule, { files: slice.files, diff: slice.diff }));
+    }
   }
-  if (violation === "") {
-    return { ok: false, code: "EMPTY_SECTION" };
+  return requests;
+}
+function assembleResults(input, slots, evaluations, gateConfig) {
+  const results = [];
+  let evaluationCursor = 0;
+  for (const slot of slots) {
+    if (slot.kind === "RESULT") {
+      results.push(slot.result);
+      continue;
+    }
+    const plan = slot.plan;
+    if (plan.status === "SKIPPED") {
+      results.push(skippedResult(input.turn, slot.rule, plan.reason));
+      continue;
+    }
+    if (plan.status === "UNAVAILABLE") {
+      results.push(unavailableResult(input.turn, slot.rule, plan.reason));
+      continue;
+    }
+    if (plan.status === "SLICE_LIMIT_EXCEEDED") {
+      results.push({
+        ...buildReviewContext(input.turn, slot.rule, collectSlicePaths(plan.slices)),
+        outcome: "UNAVAILABLE",
+        reason: "SLICE_LIMIT_EXCEEDED",
+        evidence: overBudgetMetadata(plan.slices)
+      });
+      continue;
+    }
+    const sliceEvaluations = evaluations.slice(evaluationCursor, evaluationCursor + plan.slices.length);
+    evaluationCursor += plan.slices.length;
+    results.push(assembleSlicedRuleResult(slot.rule, buildReviewContext(input.turn, slot.rule, collectSlicePaths(plan.slices)), plan.slices, sliceEvaluations, gateConfig));
+  }
+  return results;
+}
+function collectSlicePaths(slices) {
+  const paths = [];
+  for (const slice of slices) {
+    for (const path of slice.files) {
+      if (!paths.includes(path)) {
+        paths.push(path);
+      }
+    }
   }
-  if (allowed === "") {
-    return { ok: false, code: "EMPTY_ALLOWED" };
+  return paths;
+}
+function skippedResult(turn, rule, reason) {
+  return { ...buildReviewContext(turn, rule, []), outcome: "SKIPPED", reason };
+}
+function unavailableResult(turn, rule, reason) {
+  return { ...buildReviewContext(turn, rule, []), outcome: "UNAVAILABLE", reason };
+}
+function invalidRuleResult(turnId, failure) {
+  return {
+    kind: "RULE",
+    turnId,
+    ruleId: failure.ruleId,
+    severity: null,
+    scopedPaths: [],
+    outcome: "UNAVAILABLE",
+    reason: "INVALID_RULE"
+  };
+}
+function invalidConfigResult(turn, rule) {
+  return {
+    ...buildReviewContext(turn, rule, []),
+    outcome: "UNAVAILABLE",
+    reason: "INVALID_CONFIG"
+  };
+}
+// 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();
   }
-  if (allowed !== null && allowed === violation) {
-    return { ok: false, code: "ALLOWED_EQUALS_VIOLATION" };
+  const stripped = raw.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  return { raw, text: stripped, endsWithNewline };
+}
+function isCombinedHeader(line) {
+  return COMBINED_HEADERS.some((header) => line.startsWith(header));
+}
+function detectFormat(text, first) {
+  if ((text[first] ?? "").startsWith(GIT_HEADER)) {
+    return "GIT";
   }
-  return { ok: true, value: { rule, violation, allowed } };
+  if (text.some((line) => line.startsWith(GIT_HEADER))) {
+    return null;
+  }
+  return isPlainSectionStart(text, first) ? "PLAIN" : null;
 }
-function joinContent(lines) {
-  return lines.join(`
-`).trim();
+function isPlainSectionStart(text, index) {
+  return (text[index] ?? "").startsWith(OLD_FILE_MARKER) && (text[index + 1] ?? "").startsWith(NEW_FILE_MARKER);
 }
-
-// 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 isSectionStart(text, index, format) {
+  return format === "GIT" ? (text[index] ?? "").startsWith(GIT_HEADER) : isPlainSectionStart(text, index);
 }
-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;
+function isBlankTail(text, from) {
+  for (let index = from;index < text.length; index += 1) {
+    if ((text[index] ?? "").trim() !== "") {
+      return false;
     }
-    if (current !== null) {
-      current.body.push(line);
+  }
+  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 (section.file !== null) {
+      files.push(section.file);
     }
+    cursor = section.next;
   }
-  return blocks;
+  return { status: "PARSED", files };
 }
-function parseRuleBlock(block, duplicate) {
-  if (!isValidRuleId(block.id)) {
-    return ruleCandidateFailure("INVALID_ID", null);
+function readGitSection(diff, start) {
+  const header = parseGitHeader(diff.text[start] ?? "");
+  if (header.status === "INVALID") {
+    return header;
   }
-  if (duplicate) {
-    return ruleCandidateFailure("DUPLICATE_ID", block.id);
+  const extended = readExtendedHeaders(diff.text, start + 1);
+  if (extended.status === "INVALID") {
+    return extended;
   }
-  const metadata = parseRuleMetadata(block.body);
-  if (!metadata.ok) {
-    return ruleCandidateFailure(metadata.code, block.id);
+  if (!(diff.text[extended.next] ?? "").startsWith(OLD_FILE_MARKER)) {
+    return readSectionWithoutContent(diff.text, extended.next);
   }
-  const sections = parseRuleSections(block.body);
-  if (!sections.ok) {
-    return ruleCandidateFailure(sections.code, block.id);
+  const paths = readFilePaths(diff.text, extended.next, "GIT");
+  if (paths.status === "INVALID") {
+    return paths;
   }
-  return {
-    status: "PARSED",
-    rule: buildParsedRule(block.id, metadata.value, sections.value)
-  };
+  const failure = checkGitPaths(header, extended, paths);
+  if (failure !== null) {
+    return failure;
+  }
+  return readContent(diff, start, extended.next + 2, paths, "GIT");
 }
-function ruleCandidateFailure(code, ruleId) {
-  return { status: "INVALID", reason: "INVALID_RULE", code, ruleId };
+function readSectionWithoutContent(text, index) {
+  if (index >= text.length || text[index]?.startsWith(GIT_HEADER)) {
+    return { status: "OK", file: null, next: index };
+  }
+  return isBlankTail(text, index) ? { status: "OK", file: null, next: text.length } : invalid("UNRECOGNIZED_DIFF");
 }
-function splitLines(text) {
-  return text.replace(/\r\n?/g, `
-`).split(`
-`);
+function parseGitHeader(line) {
+  const rest = line.slice(GIT_HEADER.length);
+  if (rest.startsWith('"') || rest.includes(' "')) {
+    return invalid("QUOTED_PATH");
+  }
+  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 buildParsedRule(id, metadata, sections) {
+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 {
-    id,
-    severity: metadata.severity,
-    scope: metadata.scope,
-    description: sections.rule,
-    violation: sections.violation,
-    allowed: sections.allowed
+    oldPath: rest.slice(OLD_PREFIX.length, index),
+    newPath: rest.slice(index + separator.length)
   };
 }
-// packages/core/src/rules/parse-rules.ts
-function parseRules(text) {
-  const blocks = collectRuleBlocks(text);
-  if (blocks.length === 0) {
-    return [ruleCandidateFailure("MISSING_ID", null)];
+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");
+    }
+    const fromValue = headerValue(line, RENAME_FROM_HEADERS);
+    const toValue = headerValue(line, RENAME_TO_HEADERS);
+    if (fromValue?.startsWith('"') || toValue?.startsWith('"')) {
+      return invalid("QUOTED_PATH");
+    }
+    movedFrom = fromValue ?? movedFrom;
+    movedTo = toValue ?? movedTo;
+    if (!KNOWN_EXTENDED_HEADERS.some((header) => line.startsWith(header))) {
+      break;
+    }
+    cursor += 1;
   }
-  const duplicates = findDuplicateIds(blocks.map((block) => block.id));
-  return blocks.map((block) => parseRuleBlock(block, duplicates.has(block.id)));
+  return { status: "OK", next: cursor, movedFrom, movedTo };
 }
-function findDuplicateIds(ids) {
-  const counts = new Map;
-  for (const id of ids) {
-    if (!isValidRuleId(id)) {
-      continue;
+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");
+  }
+  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");
+  }
+  const stripped = stripPrefixes(oldValue, newValue, format);
+  if (stripped === null) {
+    return invalid("UNSUPPORTED_PREFIX");
+  }
+  if (isMissing(stripped.oldPath) && isMissing(stripped.newPath)) {
+    return invalid("MISSING_PATH");
+  }
+  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 { status: "OK", oldPath, newPath };
+}
+function isMissing(path) {
+  return path === "" || path === DEV_NULL;
+}
+function cutAtTab(value) {
+  const tabIndex = value.indexOf("\t");
+  return tabIndex === -1 ? value : value.slice(0, tabIndex);
+}
+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
+    };
+  }
+  if (format === "PLAIN" && !hasOldPrefix && !hasNewPrefix) {
+    return { oldPath: oldValue, newPath: newValue };
+  }
+  return 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");
+  }
+  const movedByHeader = extended.movedFrom !== null && extended.movedTo !== null && extended.movedFrom !== extended.movedTo;
+  if (header.oldPath !== header.newPath || movedByHeader) {
+    return invalid("RENAMED_PATH");
+  }
+  return null;
+}
+function readPlainSection(diff, start) {
+  const paths = readFilePaths(diff.text, start, "PLAIN");
+  if (paths.status === "INVALID") {
+    return paths;
+  }
+  if (paths.oldPath !== null && paths.newPath !== null && paths.oldPath !== paths.newPath) {
+    return invalid("RENAMED_PATH");
+  }
+  return readContent(diff, start, start + 2, paths, "PLAIN");
+}
+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 renderPatch(diff, start, end) {
+  const body = diff.raw.slice(start, end).join(`
+`);
+  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;
     }
-    counts.set(id, (counts.get(id) ?? 0) + 1);
+    cursor = hunk.next;
+    hunkCount += 1;
   }
-  const duplicates = new Set;
-  for (const [id, count] of counts) {
-    if (count > 1) {
-      duplicates.add(id);
+  if (hunkCount === 0) {
+    return invalid(cursor >= text.length ? "TRUNCATED_HUNK" : "UNRECOGNIZED_DIFF");
+  }
+  return { status: "OK", end: cursor };
+}
+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;
+    }
+    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;
+  }
+  const closesWithMarker = afterBodyLine && (text[cursor] ?? "").startsWith(NO_NEWLINE_MARKER);
+  return { status: "OK", next: closesWithMarker ? cursor + 1 : cursor };
+}
+// 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) {
+    for (const result of record.results) {
+      if (result.kind !== "RULE" || result.ruleId === null || result.outcome !== "FAIL") {
+        continue;
+      }
+      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 duplicates;
+  return fails;
 }
-// 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 }
+function latestDecisions(feedback) {
+  const decisions = new Map;
+  for (const record of feedback) {
+    decisions.set(failIdentityKey(record), record.decision);
   }
-};
-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
-    }
-  };
+  return decisions;
 }
-function buildComplexityContext(turn, scopedPaths) {
-  return {
-    kind: "BUILT_IN",
-    turnId: turn.id,
-    ruleId: null,
-    checkId: COMPLEXITY_CHECK_ID,
-    severity: "warning",
-    scopedPaths
-  };
+function latestFeedbackRecords(feedback) {
+  const latest = new Map;
+  for (const record of feedback) {
+    const key = failIdentityKey(record);
+    latest.delete(key);
+    latest.set(key, record);
+  }
+  return [...latest.values()];
+}
+// packages/core/src/report/compare.ts
+function compareStrings(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  return left > right ? 1 : 0;
 }
 
-// packages/core/src/builtins/scope-creep.ts
-var SCOPE_CREEP_CHECK_ID = "SCOPE-CREEP";
-var SCOPE_CREEP_GATE_CONFIG = {
+// 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 compareNewestFirst(left, right) {
+  return compareStrings(right.timestamp, left.timestamp) || compareStrings(left.ruleId, right.ruleId) || compareStrings(left.turnId, right.turnId);
+}
+// 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 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 = {
   version: 1,
   thresholds: {
-    error: { warn: 0.65, fail: 0.9 },
+    error: { warn: 0.4, fail: 0.7 },
     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) {
-    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({ request, settle, fail });
-        drain();
-      });
-    }
-  };
-}
-// packages/core/src/gate/defaults.ts
-var DEFAULT_GATE_CONFIG = {
-  version: 1,
-  thresholds: {
-    error: { warn: 0.4, fail: 0.7 },
-    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",
@@ -901,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;
+// 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;
   }
-  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
-  };
+  return hash.toString(16).padStart(8, "0");
 }
-function collectRuleFindings(results, rulesById) {
-  const findings = [];
+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 (!isFailingRule(result)) {
+    if (result.outcome !== "FAIL")
       continue;
-    }
-    const rule = rulesById.get(result.ruleId);
-    if (rule === undefined) {
+    if (result.kind === "RULE" && result.severity !== "error")
       continue;
-    }
-    findings.push({
-      ruleId: rule.id,
-      severity: "error",
-      rule: snapshotRule(rule),
-      probability: result.violationProbability,
-      scopedPaths: [...result.scopedPaths]
-    });
+    const id = idOf(result);
+    if (id !== null)
+      failures.push({ id, scopedPaths: [...result.scopedPaths] });
   }
-  return findings;
+  return failures;
 }
-function collectBuiltInFindings(results) {
-  const findings = [];
+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) {
-    if (result.kind !== "BUILT_IN" || result.outcome !== "FAIL") {
-      continue;
-    }
-    findings.push({
-      checkId: result.checkId,
-      severity: result.severity,
-      probability: result.violationProbability,
-      scopedPaths: [...result.scopedPaths]
-    });
+    const id = idOf(result);
+    if (id !== null && ids.includes(id))
+      scopes[id] = sortedUnique(result.scopedPaths);
   }
-  return findings;
+  return scopes;
 }
-function isFailingRule(result) {
-  return result.kind === "RULE" && result.outcome === "FAIL" && result.severity === "error" && result.ruleId !== null;
+function isJudged(result) {
+  return result.outcome === "PASS" || result.outcome === "FAIL";
 }
-function indexParsedRules(rules) {
-  const byId = new Map;
-  for (const candidate of rules) {
-    if (candidate.status === "PARSED") {
-      byId.set(candidate.rule.id, candidate.rule);
+function narrowed(before, after) {
+  return before?.some((path) => !after.includes(path)) === true;
+}
+function judgedOf(id, results) {
+  return results.filter((result) => idOf(result) === id && isJudged(result));
+}
+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"]);
@@ -1006,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 });
 }
@@ -1073,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.",
@@ -1146,19 +1809,103 @@ function section(label, value) {
 ${value}
 `;
 }
-// packages/core/src/remediation/store.ts
-function createRemediationProposalStore() {
-  const claimed = new Set;
-  const childSessions = new Set;
-  return {
-    claim(evaluationId) {
-      if (evaluationId === "" || claimed.has(evaluationId)) {
-        return false;
-      }
-      claimed.add(evaluationId);
-      return true;
-    },
-    registerChildSession(sessionID) {
+// 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;
+  const childSessions = new Set;
+  return {
+    claim(evaluationId) {
+      if (evaluationId === "" || claimed.has(evaluationId)) {
+        return false;
+      }
+      claimed.add(evaluationId);
+      return true;
+    },
+    registerChildSession(sessionID) {
       if (sessionID !== "") {
         childSessions.add(sessionID);
       }
@@ -1168,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);