@pablozrrrr/jevguard 0.2.2 → 0.2.3

package/index.js

@@ -35,7 +35,7 @@ function buildReviewContext(turn, rule, scopedPaths) {
 var DEFAULT_MAX_DIFF_LENGTH = 1e5;
 var DEFAULT_EVIDENCE_POLICY = {
   maxDiffLength: DEFAULT_MAX_DIFF_LENGTH,
-  allowedExtensions: [
+  codeExtensions: [
     ".ts",
     ".tsx",
     ".mts",
@@ -46,9 +46,6 @@ var DEFAULT_EVIDENCE_POLICY = {
     ".cjs",
     ".json",
     ".jsonc",
-    ".md",
-    ".mdx",
-    ".txt",
     ".yaml",
     ".yml",
     ".toml",
@@ -104,6 +101,7 @@ var DEFAULT_EVIDENCE_POLICY = {
     ".diff",
     ".patch"
   ],
+  docsExtensions: [".md", ".mdx", ".txt"],
   deniedFileNames: [
     ".env",
     ".envrc",
@@ -178,18 +176,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, "/");
@@ -216,16 +222,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" };
@@ -252,11 +248,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(`
@@ -297,14 +303,20 @@ function evaluateWarningGate(probability, thresholds) {
 }
 
 // packages/core/src/evaluation/evaluate-with-port.ts
-async function evaluateWithPort(port, request) {
+async function evaluateRuleBatchWithPort(port, requests) {
   try {
-    const result = await port.evaluate(request);
-    return result.kind === "RULE" ? result : { kind: "RULE", status: "FAILED", reason: "INVALID_RESPONSE" };
+    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 { kind: "RULE", status: "FAILED", reason: "API_ERROR" };
+    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);
@@ -313,27 +325,118 @@ async function evaluateBuiltInBatchWithPort(port, request) {
     return { kind: "BUILT_IN_BATCH", status: "FAILED", reason: "API_ERROR" };
   }
 }
-
-// packages/core/src/evaluation/evaluate-rule.ts
-async function evaluateRule(input, dependencies) {
-  const selection = selectRuleEvidence(input.turn, input.rule, input.evidencePolicy);
-  if (selection.status === "SKIPPED") {
-    const context = buildReviewContext(input.turn, input.rule, []);
-    return { ...context, outcome: "SKIPPED", reason: selection.reason };
+// 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 (selection.status === "UNAVAILABLE") {
-    const context = buildReviewContext(input.turn, input.rule, []);
-    return { ...context, outcome: "UNAVAILABLE", reason: selection.reason };
+  const applicableFiles = selectApplicableFiles(turn.files, rule.scope, rule.evidence, policy);
+  if (applicableFiles.length === 0) {
+    return { status: "SKIPPED", reason: "NO_SCOPE_MATCH" };
   }
-  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);
-  if (evaluation.status === "FAILED") {
-    return { ...context, outcome: "UNAVAILABLE", reason: "JEV_FAILURE" };
+  const diff = assembleDiff(applicableFiles);
+  if (diff.trim() === "") {
+    return { status: "SKIPPED", reason: "NO_ATTRIBUTED_PATCH" };
+  }
+  if (applicableFiles.some((file) => !checkFilePath(file.path, policy).allowed)) {
+    return { status: "UNAVAILABLE", reason: "BLOCKED_EVIDENCE" };
+  }
+  if (diff.length <= policy.maxDiffLength) {
+    return { status: "PLANNED", slices: [wholeSlice(applicableFiles, diff)] };
   }
-  const gate = evaluateGate(input.rule.severity, evaluation.noul.violationProbability, input.gateConfig);
-  return { ...context, ...gate };
+  return sliceByFile(applicableFiles, policy);
+}
+function wholeSlice(files, diff) {
+  const paths = files.map((file) => file.path);
+  return {
+    index: 0,
+    kind: "WHOLE",
+    path: paths.length === 1 ? paths[0] ?? null : null,
+    hunkOrdinal: null,
+    files: paths,
+    diff
+  };
+}
+function sliceByFile(files, policy) {
+  const slices = [];
+  for (const file of files) {
+    if (file.patch.length <= policy.maxDiffLength) {
+      slices.push(fileSlice(slices.length, file));
+      continue;
+    }
+    const hunks = sliceHunks(slices.length, file, policy);
+    if (hunks === null) {
+      return { status: "UNAVAILABLE", reason: "OVERSIZED_DIFF" };
+    }
+    slices.push(...hunks);
+  }
+  return { status: "PLANNED", slices };
+}
+function fileSlice(index, file) {
+  return {
+    index,
+    kind: "FILE",
+    path: file.path,
+    hunkOrdinal: null,
+    files: [file.path],
+    diff: file.patch
+  };
 }
+function sliceHunks(startIndex, file, policy) {
+  const starts = hunkStarts(file.patch);
+  if (starts.length === 0) {
+    return null;
+  }
+  const firstStart = starts[0];
+  if (firstStart === undefined) {
+    return null;
+  }
+  const preamble = file.patch.slice(0, firstStart);
+  const slices = [];
+  for (let ordinal = 0;ordinal < starts.length; ordinal += 1) {
+    const start = starts[ordinal];
+    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/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) {
@@ -387,28 +490,204 @@ 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));
+// 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;
+    }
+    const gate = evaluateGate(rule.severity, evaluation.noul.violationProbability, gateConfig);
+    if (gate.outcome === "UNAVAILABLE") {
+      failureIndex = index;
+      break;
+    }
+    gates.push(gate);
+    judgments.push({
+      index: slice.index,
+      probability: gate.violationProbability,
+      outcome: gate.outcome
+    });
   }
-  return aggregateReview(input.turn.id, results);
+  if (failureIndex !== null) {
+    return {
+      ...context,
+      outcome: "UNAVAILABLE",
+      reason: "JEV_FAILURE",
+      evidence: failedMetadata(mode, summaries, failureIndex)
+    };
+  }
+  return {
+    ...context,
+    outcome: mergeVerdict(gates),
+    violationProbability: maxProbability(gates),
+    evidence: completeMetadata(mode, summaries, judgments)
+  };
 }
-async function evaluateRuleResult(input, rule, dependencies) {
-  if (rule.status === "INVALID") {
-    return invalidRuleResult(input.turn.id, rule);
+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;
+    }
   }
+  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") {
-    return invalidConfigResult(input.turn, rule.rule);
+    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 }));
+    }
   }
-  const ruleInput = {
-    turn: input.turn,
-    rule: rule.rule,
-    gateConfig: input.gateConfig.config,
-    evidencePolicy: input.evidencePolicy
-  };
-  return evaluateRule(ruleInput, dependencies);
+  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);
+      }
+    }
+  }
+  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 {
@@ -450,13 +729,29 @@ function matchSectionHeading(line) {
 var METADATA_ENTRY = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/;
 function parseRuleMetadata(lines) {
   let severity = null;
-  let scope = 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" };
     }
@@ -469,11 +764,12 @@ function parseRuleMetadata(lines) {
       severity = parsed;
       continue;
     }
-    if (entry.key === "scope") {
-      if (entry.value === "") {
+    if (entry.key === "evidence") {
+      const parsed = parseEvidenceClass(entry.value);
+      if (parsed === null) {
         return { ok: false, code: "MALFORMED_METADATA" };
       }
-      scope = entry.value;
+      evidence = parsed;
       continue;
     }
     return { ok: false, code: "MALFORMED_METADATA" };
@@ -481,7 +777,11 @@ function parseRuleMetadata(lines) {
   if (severity === null) {
     return { ok: false, code: "MISSING_SEVERITY" };
   }
-  return { ok: true, value: { severity, scope } };
+  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 = [];
@@ -511,6 +811,26 @@ function parseSeverity(value) {
       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"];
@@ -633,6 +953,7 @@ function buildParsedRule(id, metadata, sections) {
     id,
     severity: metadata.severity,
     scope: metadata.scope,
+    evidence: metadata.evidence,
     description: sections.rule,
     violation: sections.violation,
     allowed: sections.allowed
@@ -663,6 +984,130 @@ function findDuplicateIds(ids) {
   }
   return duplicates;
 }
+// packages/core/src/report/aggregate.ts
+function aggregateReviewHistory(records, skippedLineCount) {
+  const outcomes = emptyAccumulator();
+  const unavailableReasons = new Map;
+  const skippedReasons = new Map;
+  const builtIns = new Map;
+  const rules = new Map;
+  const evaluation = { wholeEvaluations: 0, slicedEvaluations: 0, totalSliceJudgments: 0 };
+  let firstTimestamp = null;
+  let lastTimestamp = null;
+  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),
+    evaluation: finalizeEvaluation(evaluation)
+  };
+}
+function emptyAccumulator() {
+  return { pass: 0, warn: 0, fail: 0, unavailable: 0, skipped: 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 sortedRules(map) {
+  return [...map.entries()].map(([ruleId, accumulator]) => ({
+    ruleId,
+    counts: finalizeAccumulator(accumulator.counts),
+    slicedRuleCount: accumulator.sliced
+  })).sort((left, right) => compareStrings(left.ruleId, right.ruleId));
+}
+function earlier(current, candidate) {
+  return current === null || candidate < current ? candidate : current;
+}
+function later(current, candidate) {
+  return current === null || candidate > current ? candidate : current;
+}
+function compareStrings(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  return left > right ? 1 : 0;
+}
 // packages/core/src/builtins/complexity.ts
 var COMPLEXITY_CHECK_ID = "COMPLEXITY";
 var COMPLEXITY_GATE_CONFIG = {
@@ -830,6 +1275,18 @@ function createFifoJevPort(port, config) {
     }
   }
   function start(pending) {
+    if (pending.kind === "BATCH") {
+      Promise.resolve().then(() => port.evaluateRuleBatch(pending.requests)).then((results) => {
+        active -= 1;
+        pending.settle(results);
+        drain();
+      }, (error) => {
+        active -= 1;
+        pending.fail(error);
+        drain();
+      });
+      return;
+    }
     Promise.resolve().then(() => port.evaluate(pending.request)).then((result) => {
       active -= 1;
       pending.settle(result);
@@ -843,7 +1300,13 @@ function createFifoJevPort(port, config) {
   return {
     evaluate(request) {
       return new Promise((settle, fail) => {
-        queue.push({ request, 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();
       });
     }
@@ -1520,6 +1983,7 @@ var JEV_MODEL = "jev-latest";
 
 // packages/opencode-adapter/src/jev/transport.ts
 var DEFAULT_ALLOWED_CRITERION = "The change does not violate the rule's Violation.";
+var RULE_BATCH_CONCURRENCY = 4;
 function buildTypeSafeClientConfig(apiKey) {
   return { apiKey, defaultModel: JEV_MODEL, logLevel: "off" };
 }
@@ -1537,9 +2001,48 @@ function createJevTransport(dependencies) {
         return failedFor(request, "API_ERROR");
       }
       return evaluateWithClient(client, request);
+    },
+    async evaluateRuleBatch(requests) {
+      if (requests.length === 0) {
+        return [];
+      }
+      const credential = await resolveCredential(dependencies.credentials);
+      if (credential.status === "UNAVAILABLE") {
+        const reason = toFailureReason(credential.reason);
+        return requests.map(() => ruleFailed(reason));
+      }
+      let client;
+      try {
+        client = dependencies.createClient(credential.apiKey);
+      } catch {
+        return requests.map(() => ruleFailed("API_ERROR"));
+      }
+      return runWithConcurrency(requests, RULE_BATCH_CONCURRENCY, (request) => evaluateRuleWithClient(client, request));
     }
   };
 }
+async function runWithConcurrency(items, cap, worker) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  async function run() {
+    while (true) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= items.length) {
+        return;
+      }
+      const item = items[index];
+      if (item === undefined) {
+        continue;
+      }
+      results[index] = await worker(item);
+    }
+  }
+  const workerCount = Math.min(cap, items.length);
+  const workers = Array.from({ length: workerCount }, () => run());
+  await Promise.all(workers);
+  return results;
+}
 function createTypeSafeJevTransport(credentials) {
   return createJevTransport({ credentials, createClient: createTypeSafeSystemOneClient });
 }
@@ -1988,6 +2491,261 @@ async function readOptionalFile2(fileSystem, path) {
 function isMissingFileError2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+// packages/opencode-adapter/src/history/local.ts
+import { isAbsolute as isAbsolute2, join as join5 } from "path";
+var DATA_DIRECTORY = "jevguard";
+var HISTORY_FILENAME = "reviews.jsonl";
+var DEFAULT_HISTORY_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_HISTORY_MAX_RECORDS = 2000;
+function createLocalReviewHistory(dependencies) {
+  const filePath = resolveHistoryFilePath(dependencies.context);
+  const maxBytes = dependencies.maxBytes ?? DEFAULT_HISTORY_MAX_BYTES;
+  const maxRecords = dependencies.maxRecords ?? DEFAULT_HISTORY_MAX_RECORDS;
+  let tail = Promise.resolve();
+  async function append(entry) {
+    try {
+      const record = {
+        ...entry,
+        timestamp: dependencies.now().toISOString()
+      };
+      await dependencies.fileSystem.ensureParentDirectory(filePath);
+      await dependencies.fileSystem.appendFile(filePath, `${JSON.stringify(record)}
+`);
+      await boundGrowth();
+    } catch {
+      return;
+    }
+  }
+  async function boundGrowth() {
+    try {
+      const size = await dependencies.fileSystem.sizeOf(filePath);
+      if (size === null || size <= maxBytes) {
+        return;
+      }
+      const contents = await dependencies.fileSystem.readFile(filePath);
+      if (contents === null) {
+        return;
+      }
+      const lines = contents.split(`
+`).filter((line) => line.trim() !== "");
+      const kept = lines.slice(Math.max(0, lines.length - maxRecords));
+      const rewritten = kept.length === 0 ? "" : `${kept.join(`
+`)}
+`;
+      await dependencies.fileSystem.writeFileAtomic(filePath, rewritten);
+    } catch {
+      return;
+    }
+  }
+  async function read() {
+    try {
+      const contents = await dependencies.fileSystem.readFile(filePath);
+      if (contents === null) {
+        return { records: [], skippedLineCount: 0 };
+      }
+      return parseRecords(contents);
+    } catch {
+      return { records: [], skippedLineCount: 0 };
+    }
+  }
+  return {
+    append: (entry) => {
+      const run = tail.then(() => append(entry));
+      tail = run.then(ignore, ignore);
+      return run;
+    },
+    read
+  };
+}
+function resolveHistoryFilePath(context) {
+  return join5(resolveDataHome(context), DATA_DIRECTORY, HISTORY_FILENAME);
+}
+function resolveDataHome(context) {
+  const configured = context.environment.get("XDG_DATA_HOME");
+  if (configured !== undefined && configured !== "" && isAbsolute2(configured)) {
+    return configured;
+  }
+  return join5(context.homedir, ".local", "share");
+}
+function parseRecords(contents) {
+  const records = [];
+  let skippedLineCount = 0;
+  for (const line of contents.split(`
+`)) {
+    if (line.trim() === "") {
+      continue;
+    }
+    const parsed = parseRecord(line);
+    if (parsed === null) {
+      skippedLineCount += 1;
+      continue;
+    }
+    records.push(parsed);
+  }
+  return { records, skippedLineCount };
+}
+function parseRecord(line) {
+  try {
+    const value = JSON.parse(line);
+    return isReviewHistoryRecord(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function isReviewHistoryRecord(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  if (typeof value.timestamp !== "string" || typeof value.turnId !== "string") {
+    return false;
+  }
+  if (!isObject(value.summary) || !Array.isArray(value.results)) {
+    return false;
+  }
+  return value.results.every(isHistoryResult);
+}
+function isHistoryResult(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  if (value.kind !== "RULE" && value.kind !== "BUILT_IN" && value.kind !== "REVIEW") {
+    return false;
+  }
+  if (!isReviewOutcome(value.outcome)) {
+    return false;
+  }
+  if (value.outcome === "UNAVAILABLE" || value.outcome === "SKIPPED") {
+    return typeof value.reason === "string" && hasValidEvidence(value);
+  }
+  if (typeof value.violationProbability !== "number") {
+    return false;
+  }
+  if (value.kind === "BUILT_IN") {
+    return typeof value.checkId === "string" && hasValidEvidence(value);
+  }
+  if (value.kind === "RULE") {
+    return (value.ruleId === null || typeof value.ruleId === "string") && hasValidEvidence(value);
+  }
+  return true;
+}
+function hasValidEvidence(value) {
+  const evidence = value.evidence;
+  if (evidence === undefined) {
+    return true;
+  }
+  if (!isObject(evidence)) {
+    return false;
+  }
+  if (evidence.mode !== "WHOLE" && evidence.mode !== "SLICED") {
+    return false;
+  }
+  return Array.isArray(evidence.sliceJudgments);
+}
+function isReviewOutcome(value) {
+  return value === "PASS" || value === "WARN" || value === "FAIL" || value === "UNAVAILABLE" || value === "SKIPPED";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function ignore() {
+  return;
+}
+// packages/opencode-adapter/src/history/mirrored-sink.ts
+function createMirroredReviewLogSink(hostSink, history) {
+  return {
+    async write(entry) {
+      const [hostStatus] = await Promise.all([
+        writeHost(hostSink, entry),
+        appendHistory(history, entry)
+      ]);
+      return hostStatus;
+    }
+  };
+}
+async function writeHost(sink, entry) {
+  try {
+    return await sink.write(entry);
+  } catch {
+    return "FAILED";
+  }
+}
+async function appendHistory(history, entry) {
+  try {
+    await history.append(entry);
+  } catch {
+    return;
+  }
+}
+// packages/opencode-adapter/src/history/node-file-system.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { appendFile, mkdir as mkdir2, readFile as readFile3, rename as rename2, rm as rm2, stat, writeFile as writeFile2 } from "fs/promises";
+import { basename, dirname as dirname3, join as join6 } from "path";
+function createNodeReviewHistoryFileSystem() {
+  return {
+    readFile: readOptionalFile3,
+    appendFile: appendHistoryFile,
+    sizeOf: sizeOfOptionalFile,
+    writeFileAtomic,
+    ensureParentDirectory: async (path) => {
+      await mkdir2(dirname3(path), { recursive: true });
+    }
+  };
+}
+async function readOptionalFile3(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch (error) {
+    if (isMissingFileError3(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function appendHistoryFile(path, data) {
+  await appendFile(path, data, "utf8");
+}
+async function sizeOfOptionalFile(path) {
+  try {
+    const info = await stat(path);
+    return info.size;
+  } catch (error) {
+    if (isMissingFileError3(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeFileAtomic(path, data) {
+  const temporaryPath = join6(dirname3(path), `.${basename(path)}.jevguard-tmp-${randomUUID2()}`);
+  try {
+    await writeFile2(temporaryPath, data, "utf8");
+    await rename2(temporaryPath, path);
+  } catch (error) {
+    await rm2(temporaryPath, { force: true }).catch(() => {
+      return;
+    });
+    throw error;
+  }
+}
+function isMissingFileError3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+// packages/opencode-adapter/src/history/process-context.ts
+import { homedir } from "os";
+function createProcessReviewHistoryContext() {
+  return {
+    cwd: process.cwd(),
+    environment: processEnvironment(),
+    homedir: homedir()
+  };
+}
+function processEnvironment() {
+  return {
+    get(name) {
+      return process.env[name];
+    }
+  };
+}
 // packages/opencode-adapter/src/presentation/display.ts
 function displayOutcome(counts) {
   if (counts.fail > 0) {
@@ -2042,12 +2800,35 @@ function logLevelFor(outcome) {
 function reviewLogMessage(entry) {
   return `JevGuard ${displayOutcome(entry.summary.counts)} for turn ${entry.turnId}`;
 }
+function projectEvidence(evidence) {
+  return {
+    mode: evidence.mode,
+    plannedSliceCount: evidence.plannedSliceCount,
+    evaluatedSliceCount: evidence.evaluatedSliceCount,
+    failedSliceCount: evidence.failedSliceCount,
+    notEvaluatedSliceCount: evidence.notEvaluatedSliceCount,
+    slices: evidence.slices.map((slice) => ({
+      index: slice.index,
+      path: slice.path,
+      kind: slice.kind,
+      hunkOrdinal: slice.hunkOrdinal
+    })),
+    sliceJudgments: evidence.sliceJudgments.map((judgment) => ({
+      index: judgment.index,
+      probability: judgment.probability,
+      outcome: judgment.outcome
+    })),
+    failingSliceIndex: evidence.failingSliceIndex,
+    failureReason: evidence.failureReason
+  };
+}
 function ruleLogResult(result) {
   const identity = {
     kind: "RULE",
     ruleId: result.ruleId,
     severity: result.severity,
-    scopedPaths: [...result.scopedPaths]
+    scopedPaths: [...result.scopedPaths],
+    ...result.evidence === undefined ? {} : { evidence: projectEvidence(result.evidence) }
   };
   switch (result.outcome) {
     case "PASS":
@@ -2093,10 +2874,28 @@ function toReviewToast(review) {
   const outcome = displayOutcome(review.summary.counts);
   return {
     title: `JevGuard ${outcome}`,
-    message: countSummary(review.summary.counts),
+    message: `${countSummary(review.summary.counts)}${slicedSummary(review.results)}`,
     variant: toastVariantFor(outcome)
   };
 }
+function slicedSummary(results) {
+  let slicedRules = 0;
+  let sliceJudgments = 0;
+  for (const result of results) {
+    if (result.kind !== "RULE" || result.evidence === undefined) {
+      continue;
+    }
+    if (result.evidence.mode !== "SLICED") {
+      continue;
+    }
+    slicedRules += 1;
+    sliceJudgments += result.evidence.evaluatedSliceCount;
+  }
+  if (slicedRules === 0 && sliceJudgments === 0) {
+    return "";
+  }
+  return ` \xB7 sliced ${slicedRules} rules \xB7 slices ${sliceJudgments}`;
+}
 function toastVariantFor(outcome) {
   switch (outcome) {
     case "PASS":
@@ -2580,7 +3379,7 @@ function createPluginRuntime(dependencies) {
   let attributionTail = Promise.resolve();
   const backgroundJobs = new Set;
   function track(work) {
-    const contained = work.then(ignore, ignore);
+    const contained = work.then(ignore2, ignore2);
     backgroundJobs.add(contained);
     contained.then(() => {
       backgroundJobs.delete(contained);
@@ -2588,7 +3387,7 @@ function createPluginRuntime(dependencies) {
   }
   function enqueueAttribution(sessionID) {
     const run = attributionTail.then(() => processIdle(sessionID));
-    attributionTail = run.then(ignore, ignore);
+    attributionTail = run.then(ignore2, ignore2);
   }
   async function processIdle(sessionID) {
     try {
@@ -2637,7 +3436,7 @@ function createPluginRuntime(dependencies) {
     drain
   };
 }
-function ignore() {
+function ignore2() {
   return;
 }
 
@@ -2689,7 +3488,7 @@ function createConfigHook(options) {
 
 // packages/plugin/src/skills/skill-directory.ts
 import { existsSync } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import { fileURLToPath } from "url";
 var BUNDLED_SKILL_NAMES = ["jevguard-rules", "jev-init"];
 var SKILL_ENTRY_FILE = "SKILL.md";
@@ -2697,7 +3496,7 @@ var SKILL_DIRECTORY_PREFIXES = ["./skills/", "../skills/"];
 function resolveSkillDirectory(moduleUrl, skillName, exists) {
   for (const prefix of SKILL_DIRECTORY_PREFIXES) {
     const directory = fileURLToPath(new URL(`${prefix}${skillName}`, moduleUrl));
-    if (exists(join5(directory, SKILL_ENTRY_FILE))) {
+    if (exists(join7(directory, SKILL_ENTRY_FILE))) {
       return directory;
     }
   }
@@ -2719,6 +3518,11 @@ var DEFAULT_JEV_MAX_CONCURRENCY = 2;
 var JevGuardPlugin = async (input) => {
   const presentationClient = createOpenCodePresentationClient(input.client);
   const toast = createOpenCodeToastSink(presentationClient);
+  const history = createLocalReviewHistory({
+    context: createProcessReviewHistoryContext(),
+    fileSystem: createNodeReviewHistoryFileSystem(),
+    now: () => new Date
+  });
   const dependencies = {
     facade: createOpenCodeSessionFacade(input.client),
     deduplicator: new InMemoryTurnDeduplicator,
@@ -2727,7 +3531,7 @@ var JevGuardPlugin = async (input) => {
       fileSystem: createNodePolicyFileSystem()
     }),
     presenter: createReviewPresenter({
-      log: createOpenCodeLogSink(presentationClient),
+      log: createMirroredReviewLogSink(createOpenCodeLogSink(presentationClient), history),
       toast
     }),
     proposals: createRemediationProposalStore(),