pi-smart-compact 9.6.0 → 9.6.2

package/dist/provider-scenario-eval.js

@@ -5,7 +5,7 @@ var __require = import.meta.require;
 import { ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
 
 // src/constants.ts
-var VERSION = "9.6.0";
+var VERSION = "9.6.2";
 var SETTLED_TRIGGER_COOLDOWN_MS = 10 * 60000;
 var COMPACT_SYSTEM_PREFIX = "You are an expert conversation summarizer for a coding agent. " + "Produce structured markdown summaries. " + "Follow output format exactly. " + "Use EXACT names \u2014 never paraphrase code identifiers. " + "Trust deterministic extraction data over intuition.";
 var PROFILES = {
@@ -690,38 +690,117 @@ function buildPathNeedles(filePath) {
   }
   return needles;
 }
-function buildUniquePathNeedles(filePath, allPaths) {
-  const normalized = allPaths.map(normalizePath);
+var MAX_INDEXED_SUFFIX_CHARS = 1024;
+function buildPathNeedleOwnershipIndex(allPaths) {
+  const owners = new Map;
+  const normalizedPaths = allPaths.map(normalizePath);
+  let hasUnindexedSuffixes = false;
+  for (const normalized of normalizedPaths) {
+    const suffixes = new Set([normalized]);
+    for (let index = 0;index < normalized.length; index++) {
+      if (normalized[index] !== "/")
+        continue;
+      if (normalized.length - index - 1 <= MAX_INDEXED_SUFFIX_CHARS) {
+        suffixes.add(normalized.slice(index + 1));
+      } else {
+        hasUnindexedSuffixes = true;
+      }
+    }
+    for (const suffix of suffixes) {
+      owners.set(suffix, (owners.get(suffix) ?? 0) + 1);
+    }
+  }
+  return { counts: owners, normalizedPaths, hasUnindexedSuffixes };
+}
+function buildUniquePathNeedlesFromIndex(filePath, owners) {
   return buildPathNeedles(filePath).filter((needle) => {
-    let owners = 0;
-    for (const candidate of normalized) {
+    if (!owners.hasUnindexedSuffixes)
+      return owners.counts.get(needle) === 1;
+    let count = 0;
+    for (const candidate of owners.normalizedPaths) {
       if (candidate === needle || candidate.endsWith("/" + needle))
-        owners++;
-      if (owners > 1)
+        count++;
+      if (count > 1)
         return false;
     }
-    return owners === 1;
+    return count === 1;
   });
 }
-function isKnownPathReference(ref, knownPaths) {
-  const normalizedRef = normalizePath(ref).replace(/^\/+/, "");
-  if (!normalizedRef)
-    return false;
-  const pathShaped = normalizedRef.includes("/");
-  return knownPaths.some((path) => {
+var PATH_CANDIDATE_CHAR_RE = /[\w./-]/;
+function buildKnownPathReferenceIndex(knownPaths) {
+  const segmentSuffixes = new Set;
+  const boundarySuffixes = new Set;
+  const normalizedPaths = [];
+  let hasUnindexedSuffixes = false;
+  for (const path of knownPaths) {
     const normalizedPath = normalizePath(path).replace(/^\/+/, "");
+    if (!normalizedPath)
+      continue;
+    normalizedPaths.push(normalizedPath);
+    segmentSuffixes.add(normalizedPath);
+    for (let index = 0;index < normalizedPath.length; index++) {
+      if (normalizedPath[index] === "/") {
+        if (normalizedPath.length - index - 1 <= MAX_INDEXED_SUFFIX_CHARS) {
+          segmentSuffixes.add(normalizedPath.slice(index + 1));
+        } else {
+          hasUnindexedSuffixes = true;
+        }
+      }
+      if (index > 0 && !PATH_CANDIDATE_CHAR_RE.test(normalizedPath[index - 1])) {
+        if (normalizedPath.length - index <= MAX_INDEXED_SUFFIX_CHARS) {
+          boundarySuffixes.add(normalizedPath.slice(index));
+        } else {
+          hasUnindexedSuffixes = true;
+        }
+      }
+    }
+  }
+  return {
+    segmentSuffixes,
+    sortedSegmentSuffixes: [...segmentSuffixes].sort(),
+    boundarySuffixes,
+    normalizedPaths,
+    hasUnindexedSuffixes
+  };
+}
+function matchesKnownPathReference(normalizedRef, normalizedPaths) {
+  const pathShaped = normalizedRef.includes("/");
+  return normalizedPaths.some((normalizedPath) => {
     if (normalizedPath === normalizedRef || normalizedPath.endsWith("/" + normalizedRef))
       return true;
     if (normalizedPath.endsWith(normalizedRef)) {
       const boundary = normalizedPath[normalizedPath.length - normalizedRef.length - 1];
-      if (boundary && !/[\w./-]/.test(boundary))
+      if (boundary && !PATH_CANDIDATE_CHAR_RE.test(boundary))
         return true;
     }
     if (!pathShaped)
       return false;
-    return normalizedPath.split("/").some((_, index, parts) => parts.slice(index).join("/").startsWith(normalizedRef + "/"));
+    return normalizedPath.startsWith(normalizedRef + "/") || normalizedPath.includes("/" + normalizedRef + "/");
   });
 }
+function sortedHasPrefix(values, prefix) {
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (values[middle] < prefix)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return values[low]?.startsWith(prefix) ?? false;
+}
+function isKnownPathReferenceInIndex(ref, index) {
+  const normalizedRef = normalizePath(ref).replace(/^\/+/, "");
+  if (!normalizedRef)
+    return false;
+  if (index.segmentSuffixes.has(normalizedRef) || index.boundarySuffixes.has(normalizedRef)) {
+    return true;
+  }
+  if (normalizedRef.includes("/") && sortedHasPrefix(index.sortedSegmentSuffixes, normalizedRef + "/"))
+    return true;
+  return index.hasUnindexedSuffixes ? matchesKnownPathReference(normalizedRef, index.normalizedPaths) : false;
+}
 
 // src/domain/tool-semantics.ts
 var PATH_KEYS = [
@@ -855,7 +934,12 @@ function damageReportsFile() {
 // src/utils/file-ref-detect.ts
 var CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs|rs|py|go|java|rb|cs|cpp|c|h|hpp|swift|kt|scala|php|css|scss|html|json|yaml|yml|toml|md|mdx|sh|sql|tf|ini|env|lock|gradle|xml)$/i;
 var VERSION_RE = /^v?\d+(?:\.\d+)+(?:[-+][\w.-]+)?$/i;
-var FILE_REF_CANDIDATE_RE = /[\w.\/-]+\.[\w]+/g;
+function isAsciiWordCode(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code === 95 || code >= 97 && code <= 122;
+}
+function isCandidateCode(code) {
+  return isAsciiWordCode(code) || code === 45 || code === 46 || code === 47;
+}
 function isLikelyFileRef(candidate) {
   if (candidate.startsWith("//") || VERSION_RE.test(candidate))
     return false;
@@ -866,13 +950,32 @@ function isLikelyFileRef(candidate) {
   return CODE_EXT_RE.test(candidate);
 }
 function extractFileRefs(summary) {
-  const matcher = new RegExp(FILE_REF_CANDIDATE_RE.source, FILE_REF_CANDIDATE_RE.flags);
   const refs = [];
-  for (const match of summary.matchAll(matcher)) {
-    if (/[\\/]/.test(summary[(match.index ?? 0) + match[0].length] ?? ""))
+  let cursor = 0;
+  while (cursor < summary.length) {
+    while (cursor < summary.length && !isCandidateCode(summary.charCodeAt(cursor)))
+      cursor++;
+    const runStart = cursor;
+    while (cursor < summary.length && isCandidateCode(summary.charCodeAt(cursor)))
+      cursor++;
+    const runEnd = cursor;
+    let extensionDot = -1;
+    for (let index = runStart + 1;index + 1 < runEnd; index++) {
+      if (summary.charCodeAt(index) === 46 && isAsciiWordCode(summary.charCodeAt(index + 1))) {
+        extensionDot = index;
+      }
+    }
+    if (extensionDot < 0)
       continue;
-    if (isLikelyFileRef(match[0]))
-      refs.push(match[0]);
+    let matchEnd = extensionDot + 2;
+    while (matchEnd < runEnd && isAsciiWordCode(summary.charCodeAt(matchEnd))) {
+      matchEnd++;
+    }
+    const candidate = summary.slice(runStart, matchEnd);
+    if (/[\\/]/.test(summary[matchEnd] ?? ""))
+      continue;
+    if (isLikelyFileRef(candidate))
+      refs.push(candidate);
   }
   return refs;
 }
@@ -1564,6 +1667,229 @@ var processToolSupport = new ToolSupportCache;
 var processTokenCalibration = new TokenCalibrationStore;
 var _default = createServices();
 
+// src/domain/telemetry.ts
+function p95(values) {
+  if (!values.length)
+    return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.max(0, Math.ceil(sorted.length * 0.95) - 1)] ?? 0;
+}
+function stats(entries, damage) {
+  const evidence = entries.filter((entry) => entry.status !== "dry-run");
+  const successfulRuns = evidence.filter((entry) => entry.status === "success");
+  const quality = successfulRuns.filter((entry) => typeof entry.verificationScore === "number");
+  const appliedRunIds = new Set(successfulRuns.filter((entry) => typeof entry.runId === "string" && entry.runId.length >= 8).map((entry) => entry.runId));
+  const observedScores = new Map;
+  for (const observation of damage) {
+    if (!observation.runId || !appliedRunIds.has(observation.runId) || typeof observation.damageScore !== "number" || !Number.isFinite(observation.damageScore))
+      continue;
+    observedScores.set(observation.runId, Math.max(observedScores.get(observation.runId) ?? 0, Math.max(0, Math.min(100, observation.damageScore))));
+  }
+  const damaging = [...observedScores.values()].filter((score) => score > 0).length;
+  return {
+    runs: entries.length,
+    appliedRuns: evidence.length,
+    successRate: evidence.length ? successfulRuns.length / evidence.length : 1,
+    avgQuality: quality.length ? quality.reduce((sum, entry) => sum + (entry.verificationScore ?? 0), 0) / quality.length : null,
+    qualityCoverage: evidence.length ? quality.length / evidence.length : 0,
+    p95LatencyMs: p95(evidence.map((entry) => entry.durationMs ?? entry.avgLatency).filter(Number.isFinite)),
+    avgTokens: evidence.length ? evidence.reduce((sum, entry) => sum + entry.totalInput + entry.totalCacheHit + (entry.totalCacheWrite ?? 0) + entry.totalOutput, 0) / evidence.length : 0,
+    fallbackRate: evidence.length ? evidence.filter((entry) => entry.method === "heuristic" || Array.isArray(entry.providerRoutes) && entry.providerRoutes.some((route) => route.successes < route.calls)).length / evidence.length : 0,
+    damageRate: observedScores.size ? damaging / observedScores.size : 0,
+    damageCoverage: successfulRuns.length ? observedScores.size / successfulRuns.length : 0
+  };
+}
+function roundStats(value) {
+  return {
+    ...value,
+    successRate: Math.round(value.successRate * 1000) / 1000,
+    avgQuality: value.avgQuality == null ? null : Math.round(value.avgQuality * 10) / 10,
+    qualityCoverage: Math.round(value.qualityCoverage * 1000) / 1000,
+    p95LatencyMs: Math.round(value.p95LatencyMs),
+    avgTokens: Math.round(value.avgTokens),
+    fallbackRate: Math.round(value.fallbackRate * 1000) / 1000,
+    damageRate: Math.round(value.damageRate * 1000) / 1000,
+    damageCoverage: Math.round(value.damageCoverage * 1000) / 1000
+  };
+}
+function assessCanary(entries, damageEntries, options) {
+  const minCanaryRuns = Math.max(5, options.minCanaryRuns ?? 20);
+  const canaryEntries = entries.filter((entry) => entry.metricsSchemaVersion === 2 && entry.version === options.version && entry.releaseChannel === "canary").slice(-Math.max(100, minCanaryRuns));
+  const baselineEntries = entries.filter((entry) => entry.metricsSchemaVersion === 2 && (entry.releaseChannel ?? "stable") === "stable").slice(-(options.baselineRuns ?? Math.max(50, minCanaryRuns * 2)));
+  const baseline = stats(baselineEntries, damageEntries);
+  const canary = stats(canaryEntries, damageEntries);
+  const triggers = [];
+  const failureBaseline = 1 - baseline.successRate;
+  const failureCanary = 1 - canary.successRate;
+  if (canary.appliedRuns >= 3 && (failureCanary > 0.050001 || failureCanary - failureBaseline >= 0.050001)) {
+    triggers.push({
+      metric: "failure-rate",
+      baseline: failureBaseline,
+      canary: failureCanary,
+      threshold: failureCanary > 0.050001 ? ">5% absolute" : "+5pp regression"
+    });
+  }
+  if (canary.avgQuality != null && (canary.avgQuality < 85 || baseline.avgQuality != null && baseline.avgQuality - canary.avgQuality >= 5)) {
+    triggers.push({
+      metric: "quality",
+      baseline: baseline.avgQuality ?? 0,
+      canary: canary.avgQuality,
+      threshold: canary.avgQuality < 85 ? "<85 absolute" : "-5 points"
+    });
+  }
+  if (baseline.p95LatencyMs >= 1000 && canary.p95LatencyMs >= baseline.p95LatencyMs * 1.5) {
+    triggers.push({ metric: "latency", baseline: baseline.p95LatencyMs, canary: canary.p95LatencyMs, threshold: "+50% p95" });
+  }
+  if (baseline.avgTokens >= 1000 && canary.avgTokens >= baseline.avgTokens * 1.5) {
+    triggers.push({ metric: "tokens", baseline: baseline.avgTokens, canary: canary.avgTokens, threshold: "+50%" });
+  }
+  if (canary.fallbackRate - baseline.fallbackRate >= 0.1) {
+    triggers.push({ metric: "fallback", baseline: baseline.fallbackRate, canary: canary.fallbackRate, threshold: "+10pp" });
+  }
+  if (canary.damageRate - baseline.damageRate >= 0.1) {
+    triggers.push({ metric: "damage", baseline: baseline.damageRate, canary: canary.damageRate, threshold: "+10pp" });
+  }
+  const canarySampleAdequacy = Math.min(1, canary.appliedRuns / minCanaryRuns);
+  const baselineSampleAdequacy = Math.min(1, baseline.appliedRuns / Math.max(20, minCanaryRuns));
+  const dataConfidence = Math.round(100 * (canarySampleAdequacy * 0.25 + baselineSampleAdequacy * 0.15 + canary.qualityCoverage * canarySampleAdequacy * 0.2 + canary.damageCoverage * canarySampleAdequacy * 0.2 + baseline.damageCoverage * baselineSampleAdequacy * 0.2));
+  const reasons = [];
+  let decision = "hold";
+  if (triggers.length && canary.appliedRuns >= 3) {
+    decision = "rollback";
+    reasons.push(...triggers.map((trigger) => trigger.metric + " crossed " + trigger.threshold));
+  } else if (canary.appliedRuns < minCanaryRuns) {
+    reasons.push("need " + (minCanaryRuns - canary.appliedRuns) + " more canary runs with applied outcomes");
+  } else if (baseline.appliedRuns < Math.max(20, minCanaryRuns)) {
+    reasons.push("stable baseline is too small");
+  } else if (canary.qualityCoverage < 0.7) {
+    reasons.push("schema-v2 quality coverage is below 70%");
+  } else if (canary.damageCoverage < 0.7) {
+    reasons.push("correlated canary damage-observation coverage is below 70%");
+  } else if (baseline.damageCoverage < 0.7) {
+    reasons.push("correlated stable damage-observation coverage is below 70%");
+  } else if ((canary.avgQuality ?? 0) < 85) {
+    reasons.push("absolute verifier quality is below 85");
+  } else if (canary.successRate < 0.949999) {
+    reasons.push("absolute success rate is below 95%");
+  } else {
+    decision = "promote";
+    reasons.push("sample, absolute quality, reliability, latency, token, fallback, and damage gates passed");
+  }
+  return {
+    version: options.version,
+    decision,
+    dataConfidence,
+    baseline: roundStats(baseline),
+    canary: roundStats(canary),
+    triggers,
+    reasons
+  };
+}
+function safeMetricLabel(value, fallback) {
+  if (typeof value !== "string" || !/^[\w./:@+-]{1,160}$/.test(value))
+    return fallback;
+  return value;
+}
+var TELEMETRY_FAILURE_KINDS = new Set([
+  "cancelled",
+  "timeout",
+  "rate-limit",
+  "authentication",
+  "budget",
+  "output-limit",
+  "provider",
+  "persistence",
+  "validation",
+  "verification",
+  "yield",
+  "internal"
+]);
+function isTelemetryFailureKind(value) {
+  return typeof value === "string" && TELEMETRY_FAILURE_KINDS.has(value);
+}
+function buildPrivacySafeTelemetry(entries, damageEntries, options) {
+  const groups = new Map;
+  const failures = {};
+  for (const entry of entries) {
+    const version = safeMetricLabel(entry.version, "legacy");
+    const channel = entry.releaseChannel === "canary" ? "canary" : "stable";
+    const provider = safeMetricLabel(entry.provider, "unknown");
+    const rawModel = safeMetricLabel(entry.model, "unknown");
+    const model = rawModel.startsWith(provider + "/") ? rawModel.slice(provider.length + 1) : rawModel;
+    const key = [version, channel, provider, model].join("\x00");
+    const group = groups.get(key) ?? {
+      version,
+      channel,
+      provider,
+      model,
+      runs: 0,
+      successes: 0,
+      quality: 0,
+      qualityRuns: 0,
+      latency: 0,
+      input: 0,
+      output: 0
+    };
+    group.runs++;
+    if (entry.status === "success" || entry.status === "dry-run")
+      group.successes++;
+    if (entry.metricsSchemaVersion === 2 && typeof entry.verificationScore === "number") {
+      group.quality += entry.verificationScore;
+      group.qualityRuns++;
+    }
+    group.latency += entry.avgLatency;
+    group.input += entry.totalInput + entry.totalCacheHit + (entry.totalCacheWrite ?? 0);
+    group.output += entry.totalOutput;
+    groups.set(key, group);
+    if (isTelemetryFailureKind(entry.failureKind)) {
+      failures[entry.failureKind] = (failures[entry.failureKind] ?? 0) + 1;
+    }
+  }
+  const aggregates = [...groups.values()].map((group) => ({
+    version: group.version,
+    channel: group.channel,
+    provider: group.provider,
+    model: group.model,
+    runs: group.runs,
+    successes: group.successes,
+    avgQuality: group.qualityRuns ? Math.round(group.quality / group.qualityRuns * 10) / 10 : null,
+    avgLatencyMs: group.runs ? Math.round(group.latency / group.runs) : 0,
+    inputTokens: group.input,
+    outputTokens: group.output
+  })).sort((a, b) => b.runs - a.runs || a.version.localeCompare(b.version));
+  return {
+    generatedAt: new Date().toISOString(),
+    totalRuns: entries.length,
+    aggregates,
+    failures,
+    canary: assessCanary(entries, damageEntries, options),
+    privacy: "aggregate-only; no session ids, project ids, prompts, summaries, paths, or error text"
+  };
+}
+function formatPrivacySafeTelemetry(report) {
+  const lines = [
+    "# Smart Compact Telemetry",
+    "",
+    "Privacy: " + report.privacy + ".",
+    "",
+    "| Version | Channel | Provider/model | Runs | Success | Quality | Latency | Input | Output |",
+    "|---|---|---|---:|---:|---:|---:|---:|---:|"
+  ];
+  for (const item of report.aggregates) {
+    lines.push("| " + item.version + " | " + item.channel + " | " + item.provider + "/" + item.model + " | " + item.runs + " | " + item.successes + "/" + item.runs + " | " + (item.avgQuality == null ? "n/a" : item.avgQuality.toFixed(1)) + " | " + item.avgLatencyMs + "ms | " + item.inputTokens + " | " + item.outputTokens + " |");
+  }
+  lines.push("", "## Canary: " + report.canary.decision.toUpperCase() + " (data confidence " + report.canary.dataConfidence + "%)", "");
+  const baseline = report.canary.baseline;
+  const canary = report.canary.canary;
+  lines.push("| Gate | Stable baseline | Canary |", "|---|---:|---:|", "| Runs (total/applied) | " + baseline.runs + "/" + baseline.appliedRuns + " | " + canary.runs + "/" + canary.appliedRuns + " |", "| Success | " + Math.round(baseline.successRate * 100) + "% | " + Math.round(canary.successRate * 100) + "% |", "| Verify quality | " + (baseline.avgQuality ?? "n/a") + " | " + (canary.avgQuality ?? "n/a") + " |", "| p95 duration | " + baseline.p95LatencyMs + "ms | " + canary.p95LatencyMs + "ms |", "| Avg tokens | " + baseline.avgTokens + " | " + canary.avgTokens + " |", "| Fallback | " + Math.round(baseline.fallbackRate * 100) + "% | " + Math.round(canary.fallbackRate * 100) + "% |", "| Damage | " + Math.round(baseline.damageRate * 100) + "% | " + Math.round(canary.damageRate * 100) + "% |", "| Damage observed | " + Math.round(baseline.damageCoverage * 100) + "% | " + Math.round(canary.damageCoverage * 100) + "% |", "");
+  for (const reason of report.canary.reasons)
+    lines.push("- " + reason);
+  const failureText = Object.entries(report.failures).map(([kind, count]) => kind + "=" + count).join(", ");
+  lines.push("", "Failures: " + (failureText || "none classified"));
+  return lines.join(`
+`);
+}
+
 // src/utils/cache.ts
 var INTERNAL_PHASES = new Set([
   "explore-retry",
@@ -1693,8 +2019,9 @@ function hasListedPath(listed, file, display, normalizedOwners) {
   }
   return false;
 }
-function outcomeClaims(summary) {
-  return Array.from(new Set(summary.split(/\r?\n/).map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").trim()).filter((line) => line.length > 0 && !line.startsWith("#")).filter((line) => HIGH_RISK_OUTCOME_RE.test(line)).filter((line) => /\bno\s+(?:errors?|failures?)\b/i.test(line) || !NEGATED_OUTCOME_RE.test(line)))).slice(0, 12);
+function outcomeClaims(summary, pathEvidence) {
+  const pathLines = new Set(Array.from(pathEvidence, ([path2, display]) => [path2, display, "`" + path2 + "`"]).flat());
+  return Array.from(new Set(summary.split(/\r?\n/).map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").trim()).filter((line) => line.length > 0 && !line.startsWith("#") && !pathLines.has(line)).filter((line) => HIGH_RISK_OUTCOME_RE.test(line)).filter((line) => /\bno\s+(?:errors?|failures?)\b/i.test(line) || !NEGATED_OUTCOME_RE.test(line)))).slice(0, 12);
 }
 function classifyOutcomeClaim(claim) {
   const lower = claim.toLowerCase();
@@ -1928,7 +2255,7 @@ function stemToken(token) {
   return lower;
 }
 function semanticTokens(text) {
-  return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2);
+  return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2 || NEGATION_MARKERS.has(token));
 }
 var semanticShapeCache = new Map;
 var semanticFragmentCache = new Map;
@@ -1948,7 +2275,7 @@ function hasEffectiveTargetNegation(tokens, anchor) {
     if (token !== anchor)
       return false;
     const nearbyStart = Math.max(0, anchorIndex - 2);
-    const nearbyNegations = tokens.slice(nearbyStart, anchorIndex + 3).map((near, offset) => NEGATION_MARKERS.has(near) ? nearbyStart + offset : -1).filter((index) => index >= 0);
+    const nearbyNegations = tokens.slice(nearbyStart, anchorIndex + 3).map((near, offset) => NEGATION_MARKERS.has(near) && !(near === "without" && nearbyStart + offset > anchorIndex) ? nearbyStart + offset : -1).filter((index) => index >= 0);
     const governingStart = Math.max(0, anchorIndex - 3);
     const preceding = tokens.slice(governingStart, anchorIndex);
     const nearbyGuards = preceding.map((near, offset) => POLARITY_INVERTING_GUARDS.has(near) ? governingStart + offset : -1).filter((index) => index >= 0);
@@ -1997,12 +2324,13 @@ function hasSemanticEvidence(source, target) {
   });
 }
 function hasSemanticContradiction(source, target) {
+  const sourceFragments = new Set(semanticFragments(source).map((tokens) => tokens.join(" ")));
   const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
   if (!anchor)
     return false;
   const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
   return semanticFragments(target).some((tokens) => {
-    if (!tokens.includes(anchor))
+    if (!tokens.includes(anchor) || sourceFragments.has(tokens.join(" ")))
       return false;
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
     if (overlap < required)
@@ -2220,8 +2548,9 @@ function verifyFileReferences(summary, extraction, continuity, evidence, collect
     ...(continuity?.unresolvedErrors ?? []).flatMap((error) => error.files),
     ...(continuity?.openLoops ?? []).flatMap((loop) => loop.files)
   ]));
+  const knownFileIndex = buildKnownPathReferenceIndex(knownFiles);
   for (const ref of new Set(extractFileRefs(summary))) {
-    const grounded = isKnownPathReference(ref, knownFiles) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
+    const grounded = isKnownPathReferenceInIndex(ref, knownFileIndex) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
     if (!grounded)
       addGap(accumulator, { kind: "fabricated-file", ref }, 4);
   }
@@ -2239,9 +2568,10 @@ function verifyProgressConsistency(parsed, extraction, collected, paths, accumul
     }, 12);
   }
   const doneRefs = new Set(extractFileRefs(done).map(normalizePath));
+  const modifiedPathOwners = buildPathNeedleOwnershipIndex(paths.modified);
   for (const file of extraction.modifiedFiles) {
-    const needles = buildUniquePathNeedles(file.path, paths.modified);
-    if (!needles.some((needle) => doneRefs.has(normalizePath(needle))))
+    const needles = buildUniquePathNeedlesFromIndex(file.path, modifiedPathOwners);
+    if (!needles.some((needle) => doneRefs.has(needle)))
       continue;
     const unresolved = collected.unresolved.find((error) => {
       const firstLine = error.message.split(/\r?\n/, 1)[0] ?? "";
@@ -2256,7 +2586,7 @@ function verifyProgressConsistency(parsed, extraction, collected, paths, accumul
     }
   }
 }
-function verifyOpenLoopsAndClaims(summary, parsed, extraction, continuity, evidence, collected, accumulator) {
+function verifyOpenLoopsAndClaims(summary, parsed, paths, extraction, continuity, evidence, collected, accumulator) {
   const unresolvedCount = collected.unresolved.length + (continuity?.openLoops.filter((loop) => loop.status !== "resolved").length ?? 0);
   if (unresolvedCount >= 1 && !findSection(parsed, "open-loops") && !summary.toLowerCase().replace(/\\/g, "/").includes("unresolved")) {
     addGap(accumulator, { kind: "missing-open-loops", unresolvedCount }, 5);
@@ -2264,7 +2594,7 @@ function verifyOpenLoopsAndClaims(summary, parsed, extraction, continuity, evide
   if (!evidence.sourceMessages)
     return;
   const tools = successfulToolEvidence(evidence.sourceMessages);
-  for (const claim of outcomeClaims(summary)) {
+  for (const claim of outcomeClaims(summary, paths.rendered)) {
     if (!successfulToolSupportsClaim(claim, tools, extraction)) {
       addGap(accumulator, { kind: "unsupported-claim", claim }, 20);
     }
@@ -2280,7 +2610,7 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
   verifySemanticCoverage(parsed, collected, accumulator);
   verifyFileReferences(summary, extraction, continuity, evidence, collected, paths, accumulator);
   verifyProgressConsistency(parsed, extraction, collected, paths, accumulator);
-  verifyOpenLoopsAndClaims(summary, parsed, extraction, continuity, evidence, collected, accumulator);
+  verifyOpenLoopsAndClaims(summary, parsed, paths, extraction, continuity, evidence, collected, accumulator);
   const score = Math.max(0, accumulator.score);
   return {
     ok: accumulator.gaps.length === 0 && score >= 85,