pi-smart-compact 9.3.1 → 9.4.0

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.3.1";
+var VERSION = "9.4.0";
 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 = {
@@ -43,6 +43,7 @@ var DEFAULT_CONFIG = {
   verificationModel: null,
   summaryThinkingLevel: "minimal",
   segmentationThinkingLevel: "minimal",
+  agentToolAccess: "inherit",
   autoTrigger: true,
   autoTriggerStrategy: "native-hook",
   autoTriggerTimeoutMs: 120000,
@@ -548,12 +549,15 @@ function assertSuccessful(message) {
   }
   return message;
 }
-async function withProviderDeadline(opts, invoke, modelId) {
+function resolveProviderWatchdogMs(provider, maxTokens, configuredMs = 0) {
+  const multiplier = provider && configuredMs <= 0 ? getProviderCaps(provider).timeoutMultiplier : 1;
+  return Math.round(resolveCodexWatchdogMs(maxTokens, configuredMs) * multiplier);
+}
+async function withProviderDeadline(opts, invoke, provider) {
   if (opts.signal?.aborted)
     throw new Error("LLM request aborted before dispatch");
   const controller = new AbortController;
-  const multiplier = modelId && !((opts.codexWatchdogMs ?? 0) > 0) ? getProviderCaps(modelId).timeoutMultiplier : 1;
-  const watchdogMs = Math.round(resolveCodexWatchdogMs(opts.maxTokens, opts.codexWatchdogMs) * multiplier);
+  const watchdogMs = resolveProviderWatchdogMs(provider, opts.maxTokens, opts.codexWatchdogMs);
   const abort = Promise.withResolvers();
   const abortFromCaller = () => {
     controller.abort(opts.signal?.reason);
@@ -626,7 +630,7 @@ var rawLlmClient = {
         return completeChatGptCodex(model, body, bounded);
       const response = bounded.reasoning === undefined ? await (await resolveComplete())(model, body, bounded) : await (await resolveCompleteSimple())(model, body, bounded);
       return assertSuccessful(response);
-    }, model.id);
+    }, model.provider);
   }
 };
 var defaultLlmClient = rawLlmClient;
@@ -718,35 +722,6 @@ function isKnownPathReference(ref, knownPaths) {
   });
 }
 
-// src/utils/logger.ts
-var DEBUG = process.env.DEBUG?.includes("smart-compact") ?? false;
-function warn(msg, err) {
-  const detail = err instanceof Error ? err.message : err ?? "";
-  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
-}
-
-// src/infra/paths.ts
-import path from "path";
-import os from "os";
-function home() {
-  return process.env.HOME ?? os.homedir();
-}
-function piAgentDir() {
-  return path.join(home(), ".pi", "agent");
-}
-function cacheDir() {
-  return path.join(piAgentDir(), ".cache");
-}
-function smartCompactCacheDir() {
-  return path.join(cacheDir(), "smart-compact");
-}
-function metricsLogFile() {
-  return path.join(cacheDir(), "compact-metrics.jsonl");
-}
-function damageReportsFile() {
-  return path.join(smartCompactCacheDir(), "damage-reports.jsonl");
-}
-
 // src/domain/tool-semantics.ts
 var PATH_KEYS = [
   "path",
@@ -815,6 +790,35 @@ function classifyToolOperation(args, toolName) {
   return "unknown";
 }
 
+// src/utils/logger.ts
+var DEBUG = process.env.DEBUG?.includes("smart-compact") ?? false;
+function warn(msg, err) {
+  const detail = err instanceof Error ? err.message : err ?? "";
+  console.error(LOG_PREFIX + " " + msg + (detail ? ": " + detail : ""));
+}
+
+// src/infra/paths.ts
+import path from "path";
+import os from "os";
+function home() {
+  const configured = process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
+  return configured || os.homedir();
+}
+function piAgentDir() {
+  return path.join(home(), ".pi", "agent");
+}
+function cacheDir() {
+  return path.join(piAgentDir(), ".cache");
+}
+function smartCompactCacheDir() {
+  return path.join(cacheDir(), "smart-compact");
+}
+function metricsLogFile() {
+  return path.join(cacheDir(), "compact-metrics.jsonl");
+}
+function damageReportsFile() {
+  return path.join(smartCompactCacheDir(), "damage-reports.jsonl");
+}
 // 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;
@@ -2012,256 +2016,276 @@ function hasSemanticContradiction(source, target) {
     return conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token));
   });
 }
-function verifySummary(summary, extraction, continuity = null, evidence = {}) {
-  const parsed = parseSummary(summary);
-  const gaps = [];
-  const lower = summary.toLowerCase().replace(/\\/g, "/");
-  const normalizedSummary = lower.replace(/\s+/g, " ");
-  let score = 100;
-  const uniqueByText = (items, text) => {
-    const seen = new Set;
-    return items.filter((item) => {
-      const key = text(item).toLowerCase().replace(/\s+/g, " ").trim();
-      if (!key || seen.has(key))
-        return false;
-      seen.add(key);
-      return true;
-    });
-  };
-  const unresolvedEvidence = uniqueByText([
-    ...extraction.errors.filter((error) => !error.resolved).map((error) => ({ message: error.message })),
+function addGap(accumulator, gap, penalty) {
+  accumulator.gaps.push(gap);
+  accumulator.score -= penalty;
+}
+function uniqueByText(items, text) {
+  const seen = new Set;
+  return items.filter((item) => {
+    const key = text(item).toLowerCase().replace(/\s+/g, " ").trim();
+    if (!key || seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function collectVerificationEvidence(extraction, continuity, evidence) {
+  const unresolved = uniqueByText([
+    ...extraction.errors.flatMap((error) => !error.resolved ? [{ message: error.message }] : []),
     ...(continuity?.unresolvedErrors ?? []).map((error) => ({
       message: error.message
     }))
   ], (item) => item.message);
-  const resolvedEvidence = uniqueByText([
-    ...extraction.errors.filter((error) => error.resolved).map((error) => ({ message: error.message })),
+  const resolved = uniqueByText([
+    ...extraction.errors.flatMap((error) => error.resolved ? [{ message: error.message }] : []),
     ...(continuity?.resolvedErrors ?? []).map((error) => ({
       message: error.message
     }))
   ], (item) => item.message).slice(-5);
-  const steeringConstraints = [
-    evidence.steering?.focus ? { text: "Preserve detail about: " + evidence.steering.focus } : null,
-    evidence.steering?.note ? { text: evidence.steering.note } : null
-  ].filter((item) => Boolean(item?.text.trim()));
-  const constraintEvidence = uniqueByText([
-    ...extraction.constraints.filter((item) => item.confidence >= 0.8).map((item) => ({ text: item.text })),
-    ...(continuity?.constraints ?? []).filter((item) => item.confidence >= 0.8).map((item) => ({ text: item.text })),
+  const steeringConstraints = [];
+  if (evidence.steering?.focus?.trim()) {
+    steeringConstraints.push({
+      text: "Preserve detail about: " + evidence.steering.focus
+    });
+  }
+  if (evidence.steering?.note?.trim()) {
+    steeringConstraints.push({ text: evidence.steering.note });
+  }
+  const constraints = uniqueByText([
+    ...extraction.constraints.flatMap((item) => item.confidence >= 0.8 ? [{ text: item.text }] : []),
+    ...(continuity?.constraints ?? []).flatMap((item) => item.confidence >= 0.8 ? [{ text: item.text }] : []),
     ...steeringConstraints
   ], (item) => item.text).filter((item) => !isDiagnosticConstraintText(item.text));
-  const decisionEvidence = uniqueByText([
-    ...extraction.decisions.filter((item) => item.type === "explicit").map((item) => ({ summary: item.summary })),
-    ...(continuity?.decisions ?? []).filter((item) => item.type === "explicit").map((item) => ({ summary: item.summary }))
+  const decisions = uniqueByText([
+    ...extraction.decisions.flatMap((item) => item.type === "explicit" ? [{ summary: item.summary }] : []),
+    ...(continuity?.decisions ?? []).flatMap((item) => item.type === "explicit" ? [{ summary: item.summary }] : [])
   ], (item) => item.summary);
-  const goalEvidence = extraction.mainGoal ?? continuity?.goal ?? null;
-  const requiredSections = [
+  return {
+    unresolved,
+    resolved,
+    constraints,
+    decisions,
+    goal: extraction.mainGoal ?? continuity?.goal ?? null
+  };
+}
+function verifyRequiredSections(parsed, accumulator) {
+  const required = [
     { kind: "goal", penalty: 5 },
     { kind: "progress", penalty: 5 },
     { kind: "critical-context", penalty: 3 }
   ];
-  for (const req of requiredSections) {
-    if (!findSection(parsed, req.kind)) {
-      gaps.push({ kind: "missing-section", section: req.kind });
-      score -= req.penalty;
+  for (const item of required) {
+    if (!findSection(parsed, item.kind)) {
+      addGap(accumulator, { kind: "missing-section", section: item.kind }, item.penalty);
     }
   }
-  const modifiedPaths = extraction.modifiedFiles.map((file) => file.path);
-  const readPaths = extraction.readFiles;
-  const deletedEvidence = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
-  const requiredPaths = [...modifiedPaths, ...readPaths, ...deletedEvidence];
-  const expectedPathSet = new Set(requiredPaths);
-  const pathEvidence = buildSummaryPathEvidence(requiredPaths, evidence.summaryBudgetTokens);
-  const normalizedOwnerSets = new Map;
-  for (const file of requiredPaths) {
-    const display = pathEvidence.get(file);
+}
+function verifyPathCoverage(parsed, extraction, continuity, evidence, accumulator) {
+  const modified = extraction.modifiedFiles.map((file) => file.path);
+  const read = extraction.readFiles;
+  const deleted = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
+  const required = [...modified, ...read, ...deleted];
+  const expected = new Set(required);
+  const rendered = buildSummaryPathEvidence(required, evidence.summaryBudgetTokens);
+  const ownerSets = new Map;
+  for (const file of required) {
+    const display = rendered.get(file);
     for (const candidate of [
       file,
       ...display ? [decodePathDisplay(display)] : []
     ]) {
       const normalized = normalizePath(candidate);
-      const owners = normalizedOwnerSets.get(normalized) ?? new Set;
+      const owners = ownerSets.get(normalized) ?? new Set;
       owners.add(file);
-      normalizedOwnerSets.set(normalized, owners);
+      ownerSets.set(normalized, owners);
     }
   }
-  const normalizedOwners = new Map(Array.from(normalizedOwnerSets, ([path2, owners]) => [path2, owners.size]));
-  const listedPaths = (kind) => collectListedPaths(findSection(parsed, kind)?.body ?? "", expectedPathSet);
-  const modifiedListed = listedPaths("files-modified");
-  const readListed = listedPaths("files-read");
-  const deletedListed = listedPaths("files-deleted");
-  for (const file of modifiedPaths) {
-    const display = pathEvidence.get(file);
-    if (display && !hasListedPath(modifiedListed, file, display, normalizedOwners)) {
-      gaps.push({ kind: "missing-file", path: file });
+  const ownerCounts = new Map(Array.from(ownerSets, ([file, owners]) => [file, owners.size]));
+  const listed = (kind) => collectListedPaths(findSection(parsed, kind)?.body ?? "", expected);
+  const modifiedListed = listed("files-modified");
+  const readListed = listed("files-read");
+  const deletedListed = listed("files-deleted");
+  for (const file of modified) {
+    const display = rendered.get(file);
+    if (display && !hasListedPath(modifiedListed, file, display, ownerCounts)) {
+      addGap(accumulator, { kind: "missing-file", path: file }, 5);
     }
   }
-  for (const file of readPaths) {
-    const display = pathEvidence.get(file);
-    if (display && !hasListedPath(readListed, file, display, normalizedOwners)) {
-      gaps.push({ kind: "missing-read-file", path: file });
+  for (const file of read) {
+    const display = rendered.get(file);
+    if (display && !hasListedPath(readListed, file, display, ownerCounts)) {
+      addGap(accumulator, { kind: "missing-read-file", path: file }, 5);
     }
   }
-  for (const file of deletedEvidence) {
-    const display = pathEvidence.get(file);
-    if (display && !hasListedPath(deletedListed, file, display, normalizedOwners)) {
-      gaps.push({ kind: "missing-deleted-file", path: file });
+  for (const file of deleted) {
+    const display = rendered.get(file);
+    if (display && !hasListedPath(deletedListed, file, display, ownerCounts)) {
+      addGap(accumulator, { kind: "missing-deleted-file", path: file }, 5);
     }
   }
-  score -= gaps.filter((gap) => gap.kind === "missing-file" || gap.kind === "missing-read-file" || gap.kind === "missing-deleted-file").length * 5;
-  for (const error of unresolvedEvidence) {
+  return { modified, read, deleted, rendered };
+}
+function verifyErrorEvidence(normalizedSummary, collected, accumulator) {
+  for (const error of collected.unresolved) {
     const snippet = summaryEvidenceLine(error.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
-      gaps.push({ kind: "missing-error", message: error.message });
-      score -= 5;
+      addGap(accumulator, { kind: "missing-error", message: error.message }, 5);
     }
   }
-  for (const error of resolvedEvidence) {
+  for (const error of collected.resolved) {
     const snippet = summaryEvidenceLine(error.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
-      gaps.push({
-        kind: "missing-error",
-        message: error.message,
-        resolved: true
-      });
-      score -= 2;
+      addGap(accumulator, { kind: "missing-error", message: error.message, resolved: true }, 2);
     }
   }
+}
+function verifySemanticCoverage(parsed, collected, accumulator) {
   const constraintTarget = [
     findSection(parsed, "constraints")?.body ?? "",
     findSection(parsed, "critical-context")?.body ?? ""
   ].join(`
 `);
-  for (const constraint of constraintEvidence) {
+  for (const constraint of collected.constraints) {
     if (!hasSemanticEvidence(constraint.text, constraintTarget)) {
-      gaps.push({ kind: "missing-constraint", text: constraint.text });
-      score -= 8;
+      addGap(accumulator, { kind: "missing-constraint", text: constraint.text }, 8);
     }
     if (hasSemanticContradiction(constraint.text, constraintTarget)) {
-      gaps.push({
+      addGap(accumulator, {
         kind: "inconsistency",
         detail: "semantic-contradiction: constraint contradicts " + constraint.text.slice(0, TRUNC.SNIPPET)
-      });
-      score -= 20;
+      }, 20);
     }
   }
-  if (goalEvidence) {
+  if (collected.goal) {
     const goalTarget = findSection(parsed, "goal")?.body ?? "";
-    if (!hasSemanticEvidence(goalEvidence, goalTarget)) {
-      gaps.push({ kind: "missing-goal", goal: goalEvidence });
-      score -= 12;
+    if (!hasSemanticEvidence(collected.goal, goalTarget)) {
+      addGap(accumulator, { kind: "missing-goal", goal: collected.goal }, 12);
     }
-    if (hasSemanticContradiction(goalEvidence, goalTarget)) {
-      gaps.push({
+    if (hasSemanticContradiction(collected.goal, goalTarget)) {
+      addGap(accumulator, {
         kind: "inconsistency",
         detail: "semantic-contradiction: goal polarity or condition changed"
-      });
-      score -= 20;
+      }, 20);
     }
   }
+  const decisionBody = findSection(parsed, "decisions")?.body ?? "";
+  for (const decision of collected.decisions) {
+    if (!hasSemanticEvidence(decision.summary, decisionBody)) {
+      addGap(accumulator, { kind: "missing-decision", summary: decision.summary }, 8);
+    }
+    if (hasSemanticContradiction(decision.summary, decisionBody)) {
+      addGap(accumulator, {
+        kind: "inconsistency",
+        detail: "semantic-contradiction: decision contradicts " + decision.summary.slice(0, TRUNC.SNIPPET)
+      }, 20);
+    }
+  }
+}
+function verifyFileReferences(summary, extraction, continuity, evidence, collected, paths, accumulator) {
   const groundedEvidence = [
-    ...unresolvedEvidence.map((item) => item.message),
-    ...resolvedEvidence.map((item) => item.message),
-    ...constraintEvidence.map((item) => item.text),
-    ...decisionEvidence.map((item) => item.summary),
-    ...goalEvidence ? [goalEvidence] : [],
+    ...collected.unresolved.map((item) => item.message),
+    ...collected.resolved.map((item) => item.message),
+    ...collected.constraints.map((item) => item.text),
+    ...collected.decisions.map((item) => item.summary),
+    ...collected.goal ? [collected.goal] : [],
     ...extraction.lastUserMessages,
     ...extraction.timeline.map((item) => item.summary),
     ...extraction.topics.map((item) => item.primaryFile ?? ""),
     ...continuity?.openLoops.map((item) => item.summary) ?? [],
     ...continuity?.criticalContext ?? []
   ];
-  const groundedEvidenceFiles = groundedEvidence.flatMap((value) => [
+  const groundedFiles = groundedEvidence.flatMap((value) => [
     value,
     summaryEvidenceLine(value, TRUNC.ERROR_SNIPPET),
     summaryEvidenceLine(value, TRUNC.TOPIC_LABEL),
     summaryEvidenceLine(value, TRUNC.PREVIEW),
     summaryEvidenceLine(value, TRUNC.MESSAGE)
   ]).flatMap(extractFileRefs);
-  const renderedPathEvidence = Array.from(pathEvidence.values()).flatMap((line) => [
+  const renderedPaths = Array.from(paths.rendered.values()).flatMap((line) => [
     decodePathDisplay(line),
     line.startsWith('"') && line.endsWith('"') ? line.slice(1, -1) : line
   ]);
-  const rawKnownFiles = Array.from(new Set([
-    ...modifiedPaths,
-    ...readPaths,
-    ...deletedEvidence,
+  const knownFiles = Array.from(new Set([
+    ...paths.modified,
+    ...paths.read,
+    ...paths.deleted,
     ...extraction.referencedFiles ?? [],
-    ...groundedEvidenceFiles,
-    ...renderedPathEvidence,
-    ...renderedPathEvidence.flatMap(extractFileRefs),
+    ...groundedFiles,
+    ...renderedPaths,
+    ...renderedPaths.flatMap(extractFileRefs),
     ...continuity?.modifiedFiles ?? [],
     ...continuity?.readFiles ?? [],
     ...(continuity?.unresolvedErrors ?? []).flatMap((error) => error.files),
     ...(continuity?.openLoops ?? []).flatMap((loop) => loop.files)
   ]));
   for (const ref of new Set(extractFileRefs(summary))) {
-    const grounded = isKnownPathReference(ref, rawKnownFiles) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
-    if (!grounded) {
-      gaps.push({ kind: "fabricated-file", ref });
-      score -= 4;
-    }
+    const grounded = isKnownPathReference(ref, knownFiles) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
+    if (!grounded)
+      addGap(accumulator, { kind: "fabricated-file", ref }, 4);
   }
-  const progressSection = findSection(parsed, "progress");
-  if (progressSection) {
-    const doneSection = progressSection.body.match(/###\s*Done[\s\S]*?(?=###|$)/i)?.[0] ?? "";
-    const blockedSection = progressSection.body.match(/###\s*Blocked[\s\S]*?(?=###|$)/i)?.[0] ?? "";
-    const blockedLines = blockedSection.split(/\r?\n/).slice(1);
-    if (unresolvedEvidence.length > 0 && noneBlockerLineIndexes(blockedLines).size > 0) {
-      gaps.push({
+}
+function verifyProgressConsistency(parsed, extraction, collected, paths, accumulator) {
+  const progress = findSection(parsed, "progress");
+  if (!progress)
+    return;
+  const done = progress.body.match(/###\s*Done[\s\S]*?(?=###|$)/i)?.[0] ?? "";
+  const blocked = progress.body.match(/###\s*Blocked[\s\S]*?(?=###|$)/i)?.[0] ?? "";
+  if (collected.unresolved.length > 0 && noneBlockerLineIndexes(blocked.split(/\r?\n/).slice(1)).size > 0) {
+    addGap(accumulator, {
+      kind: "inconsistency",
+      detail: "blocked-none: Blocked says none despite unresolved errors"
+    }, 12);
+  }
+  const doneRefs = new Set(extractFileRefs(done).map(normalizePath));
+  for (const file of extraction.modifiedFiles) {
+    const needles = buildUniquePathNeedles(file.path, paths.modified);
+    if (!needles.some((needle) => doneRefs.has(normalizePath(needle))))
+      continue;
+    const unresolved = collected.unresolved.find((error) => {
+      const firstLine = error.message.split(/\r?\n/, 1)[0] ?? "";
+      const refs = extractFileRefs(firstLine).map(normalizePath);
+      return needles.some((needle) => refs.includes(normalizePath(needle)));
+    });
+    if (unresolved) {
+      addGap(accumulator, {
         kind: "inconsistency",
-        detail: "blocked-none: Blocked says none despite unresolved errors"
-      });
-      score -= 12;
-    }
-    const doneRefs = new Set(extractFileRefs(doneSection).map(normalizePath));
-    for (const file of extraction.modifiedFiles) {
-      const uniqueNeedles = buildUniquePathNeedles(file.path, modifiedPaths);
-      if (!uniqueNeedles.some((needle) => doneRefs.has(normalizePath(needle))))
-        continue;
-      const unresolved = unresolvedEvidence.find((error) => {
-        const firstLine = error.message.split(/\r?\n/, 1)[0] ?? "";
-        const errorRefs = extractFileRefs(firstLine).map(normalizePath);
-        return uniqueNeedles.some((needle) => errorRefs.includes(normalizePath(needle)));
-      });
-      if (unresolved) {
-        gaps.push({
-          kind: "inconsistency",
-          detail: file.path + " marked Done but has unresolved error"
-        });
-        score -= 5;
-      }
+        detail: file.path + " marked Done but has unresolved error"
+      }, 5);
     }
   }
-  const decisionBody = findSection(parsed, "decisions")?.body ?? "";
-  for (const decision of decisionEvidence) {
-    if (!hasSemanticEvidence(decision.summary, decisionBody)) {
-      gaps.push({ kind: "missing-decision", summary: decision.summary });
-      score -= 8;
-    }
-    if (hasSemanticContradiction(decision.summary, decisionBody)) {
-      gaps.push({
-        kind: "inconsistency",
-        detail: "semantic-contradiction: decision contradicts " + decision.summary.slice(0, TRUNC.SNIPPET)
-      });
-      score -= 20;
-    }
+}
+function verifyOpenLoopsAndClaims(summary, parsed, 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);
   }
-  const unresolvedCount = unresolvedEvidence.length + (continuity?.openLoops.filter((loop) => loop.status !== "resolved").length ?? 0);
-  if (unresolvedCount >= 1 && !findSection(parsed, "open-loops") && !lower.includes("unresolved")) {
-    gaps.push({ kind: "missing-open-loops", unresolvedCount });
-    score -= 5;
-  }
-  if (evidence.sourceMessages) {
-    const tools = successfulToolEvidence(evidence.sourceMessages);
-    for (const claim of outcomeClaims(summary)) {
-      if (!successfulToolSupportsClaim(claim, tools, extraction)) {
-        gaps.push({ kind: "unsupported-claim", claim });
-        score -= 20;
-      }
+  if (!evidence.sourceMessages)
+    return;
+  const tools = successfulToolEvidence(evidence.sourceMessages);
+  for (const claim of outcomeClaims(summary)) {
+    if (!successfulToolSupportsClaim(claim, tools, extraction)) {
+      addGap(accumulator, { kind: "unsupported-claim", claim }, 20);
     }
   }
-  const finalScore = Math.max(0, score);
-  return { ok: gaps.length === 0 && finalScore >= 85, gaps, score: finalScore };
+}
+function verifySummary(summary, extraction, continuity = null, evidence = {}) {
+  const parsed = parseSummary(summary);
+  const accumulator = { gaps: [], score: 100 };
+  const collected = collectVerificationEvidence(extraction, continuity, evidence);
+  verifyRequiredSections(parsed, accumulator);
+  const paths = verifyPathCoverage(parsed, extraction, continuity, evidence, accumulator);
+  verifyErrorEvidence(summary.toLowerCase().replace(/\\/g, "/").replace(/\s+/g, " "), collected, accumulator);
+  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);
+  const score = Math.max(0, accumulator.score);
+  return {
+    ok: accumulator.gaps.length === 0 && score >= 85,
+    gaps: accumulator.gaps,
+    score
+  };
 }
 
 // scripts/provider-scenario-eval.ts
@@ -2282,12 +2306,35 @@ Latest request: fix the test, run the release gate, and do not publish.`,
       ],
       readFiles: ["package.json"],
       deletedFiles: [],
-      errors: [{ index: 10, tool: "test", message: "expiry boundary test still fails by one second", retryAttempted: true, resolved: false }],
-      decisions: [{ index: 4, type: "explicit", summary: "Reuse node:crypto and preserve the AuthService API" }],
-      constraints: [{ index: 1, text: "Do not add dependencies", category: "prohibition", confidence: 1 }],
+      errors: [
+        {
+          index: 10,
+          tool: "test",
+          message: "expiry boundary test still fails by one second",
+          retryAttempted: true,
+          resolved: false
+        }
+      ],
+      decisions: [
+        {
+          index: 4,
+          type: "explicit",
+          summary: "Reuse node:crypto and preserve the AuthService API"
+        }
+      ],
+      constraints: [
+        {
+          index: 1,
+          text: "Do not add dependencies",
+          category: "prohibition",
+          confidence: 1
+        }
+      ],
       topics: [],
       timeline: [],
-      lastUserMessages: ["Fix the test, run the release gate, and do not publish"],
+      lastUserMessages: [
+        "Fix the test, run the release gate, and do not publish"
+      ],
       lastErrors: []
     }
   },
@@ -2301,14 +2348,35 @@ The network timeout was resolved. Open loop: add a regression check for two simu
     extraction: {
       mainGoal: "Stop duplicate background jobs",
       messageCount: 18,
-      modifiedFiles: [{ path: "src/queue.ts", toolCalls: 2, lastModifiedIndex: 13 }],
+      modifiedFiles: [
+        { path: "src/queue.ts", toolCalls: 2, lastModifiedIndex: 13 }
+      ],
       readFiles: ["src/queue.ts", "src/worker.ts"],
       deletedFiles: [],
       errors: [],
-      decisions: [{ index: 9, type: "explicit", summary: "Commit the idempotency key before retry scheduling" }],
-      constraints: [{ index: 10, text: "Keep concurrency at two", category: "requirement", confidence: 1 }],
+      decisions: [
+        {
+          index: 9,
+          type: "explicit",
+          summary: "Commit the idempotency key before retry scheduling"
+        }
+      ],
+      constraints: [
+        {
+          index: 10,
+          text: "Keep concurrency at two",
+          category: "requirement",
+          confidence: 1
+        }
+      ],
       topics: [],
-      timeline: [{ index: 16, event: "open-loop", summary: "Add a simultaneous-session regression check" }],
+      timeline: [
+        {
+          index: 16,
+          event: "open-loop",
+          summary: "Add a simultaneous-session regression check"
+        }
+      ],
       lastUserMessages: ["Add the regression check next"],
       lastErrors: []
     }
@@ -2323,18 +2391,48 @@ Critical paths: src/app/run-smart-compact.ts, src/infra/llm-client.ts, scripts/e
     extraction: {
       mainGoal: "Prepare v8 without publishing",
       messageCount: 30,
-      modifiedFiles: [{ path: "src/app/run-smart-compact.ts", toolCalls: 2, lastModifiedIndex: 20 }],
+      modifiedFiles: [
+        {
+          path: "src/app/run-smart-compact.ts",
+          toolCalls: 2,
+          lastModifiedIndex: 20
+        }
+      ],
       readFiles: ["src/infra/llm-client.ts", "scripts/eval-gate.ts"],
       deletedFiles: [],
       errors: [],
-      decisions: [{ index: 5, type: "explicit", summary: "Do not change the selected model automatically" }],
+      decisions: [
+        {
+          index: 5,
+          type: "explicit",
+          summary: "Do not change the selected model automatically"
+        }
+      ],
       constraints: [
-        { index: 2, text: "Do not publish", category: "prohibition", confidence: 1 },
-        { index: 6, text: "Keep Pi peer dependencies as wildcards", category: "requirement", confidence: 1 }
+        {
+          index: 2,
+          text: "Do not publish",
+          category: "prohibition",
+          confidence: 1
+        },
+        {
+          index: 6,
+          text: "Keep Pi peer dependencies as wildcards",
+          category: "requirement",
+          confidence: 1
+        }
       ],
       topics: [],
-      timeline: [{ index: 28, event: "open-loop", summary: "Implement telemetry canary and dashboard confidence" }],
-      lastUserMessages: ["Continue provider evaluation, then telemetry and dashboard confidence"],
+      timeline: [
+        {
+          index: 28,
+          event: "open-loop",
+          summary: "Implement telemetry canary and dashboard confidence"
+        }
+      ],
+      lastUserMessages: [
+        "Continue provider evaluation, then telemetry and dashboard confidence"
+      ],
       lastErrors: []
     }
   }
@@ -2380,7 +2478,15 @@ for (const model of models) {
   const auth = await registry.getApiKeyAndHeaders(model);
   if (!auth.ok || !auth.apiKey) {
     for (const scenario of scenarios)
-      results.push({ model: label, scenario: scenario.name, score: 0, latencyMs: 0, input: 0, output: 0, error: "auth unavailable" });
+      results.push({
+        model: label,
+        scenario: scenario.name,
+        score: 0,
+        latencyMs: 0,
+        input: 0,
+        output: 0,
+        error: "auth unavailable"
+      });
     continue;
   }
   for (const scenario of scenarios) {
@@ -2391,7 +2497,13 @@ for (const model of models) {
     try {
       const response = await rawLlmClient.complete(model, {
         systemPrompt,
-        messages: [{ role: "user", content: [{ type: "text", text: scenario.transcript }], timestamp: Date.now() }]
+        messages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: scenario.transcript }],
+            timestamp: Date.now()
+          }
+        ]
       }, {
         apiKey: auth.apiKey,
         headers: auth.headers,
@@ -2400,7 +2512,7 @@ for (const model of models) {
         codexWatchdogMs: 60000,
         signal: controller.signal
       });
-      const summary = response.content.filter((item) => item.type === "text").map((item) => item.text).join(`
+      const summary = response.content.flatMap((item) => item.type === "text" ? [item.text] : []).join(`
 `).trim();
       results.push({
         model: label,
@@ -2425,12 +2537,15 @@ for (const model of models) {
     }
   }
 }
+function tableCell(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
 console.log(`# Live Provider Scenario Matrix
 `);
 console.log("| Model | Scenario | Verify | Latency | Input | Output | Status |");
 console.log("|---|---|---:|---:|---:|---:|---|");
 for (const result of results) {
-  console.log("| " + result.model + " | " + result.scenario + " | " + result.score + " | " + result.latencyMs + "ms | " + result.input + " | " + result.output + " | " + (result.error ? "error: " + result.error.replace(/\|/g, "\\|") : "ok") + " |");
+  console.log("| " + tableCell(result.model) + " | " + tableCell(result.scenario) + " | " + result.score + " | " + result.latencyMs + "ms | " + result.input + " | " + result.output + " | " + (result.error ? "error: " + tableCell(result.error) : "ok") + " |");
 }
 console.log(`
 Advisory only: stage routes stay on the selected model unless explicitly configured.`);