pi-smart-compact 8.0.8 → 9.1.0

package/dist/provider-scenario-eval.js

@@ -82,6 +82,35 @@ function assertSuccessful(message) {
   }
   return message;
 }
+async function withProviderDeadline(opts, invoke) {
+  if (opts.signal?.aborted)
+    throw new Error("LLM request aborted before dispatch");
+  const controller = new AbortController;
+  const watchdogMs = resolveCodexWatchdogMs(opts.maxTokens, opts.codexWatchdogMs);
+  const abort = Promise.withResolvers();
+  const abortFromCaller = () => {
+    controller.abort(opts.signal?.reason);
+    abort.reject(new Error("LLM request aborted by caller"));
+  };
+  opts.signal?.addEventListener("abort", abortFromCaller, { once: true });
+  const timeout = Promise.withResolvers();
+  const timer = setTimeout(() => {
+    controller.abort("provider-watchdog");
+    timeout.reject(new Error("Provider watchdog stopped generation after " + watchdogMs + "ms"));
+  }, watchdogMs);
+  if (typeof timer === "object" && "unref" in timer)
+    timer.unref();
+  try {
+    return await Promise.race([
+      invoke({ ...opts, signal: controller.signal }),
+      abort.promise,
+      timeout.promise
+    ]);
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", abortFromCaller);
+  }
+}
 async function completeChatGptCodex(model, body, opts) {
   const controller = new AbortController;
   const watchdogMs = resolveCodexWatchdogMs(opts.maxTokens, opts.codexWatchdogMs);
@@ -125,10 +154,12 @@ async function completeChatGptCodex(model, body, opts) {
 var rawLlmClient = {
   complete: async (model, body, originalOpts) => {
     const opts = withCodexWireLimit(model, originalOpts);
-    if (isChatGptCodex(model))
-      return completeChatGptCodex(model, body, opts);
-    const response = opts.reasoning === undefined ? await (await resolveComplete())(model, body, opts) : await (await resolveCompleteSimple())(model, body, opts);
-    return assertSuccessful(response);
+    return withProviderDeadline(opts, async (bounded) => {
+      if (isChatGptCodex(model))
+        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);
+    });
   }
 };
 var defaultLlmClient = rawLlmClient;
@@ -138,7 +169,7 @@ function getLlmClient() {
 }
 
 // src/constants.ts
-var VERSION = "8.0.8";
+var VERSION = "9.1.0";
 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 = {
   light: {
@@ -180,7 +211,7 @@ var DEFAULT_CONFIG = {
   backupEnabled: true,
   backupDir: "",
   minContextPercent: 60,
-  requireApproval: false,
+  requireApproval: true,
   scrubSecrets: true,
   scrubPii: false,
   maxLlmCalls: 8,
@@ -220,6 +251,8 @@ Output EXACTLY this format:
 - **[Decision]**: [Rationale]
 ` + `## Files Modified
 - [Verified list from deterministic extraction]
+` + `## Files Deleted
+- [Verified deleted paths from deterministic extraction]
 ` + `## Files Read
 - [Verified list from deterministic extraction]
 ` + `## Next Steps
@@ -243,6 +276,7 @@ Rules for Accuracy:
 ` + `**Summary**: [2-4 sentences: what happened, errors, code changes with paths]
 ` + `**Decisions**: [comma-separated, or "None"]
 ` + `**Modified**: [comma-separated paths, or "None"]
+` + `**Deleted**: [comma-separated paths, or "None"]
 ` + `**Read**: [comma-separated paths, or "None"]
 `;
 var ASSEMBLY_PROMPT_PREFIX = `Merge these topic summaries into ONE coherent summary.
@@ -274,6 +308,8 @@ var ASSEMBLY_PROMPT_PREFIX = `Merge these topic summaries into ONE coherent summ
 - **[Decision]**: [Rationale]
 ` + `## Files Modified
 - [Verified deterministic list]
+` + `## Files Deleted
+- [Verified deterministic deleted paths]
 ` + `## Files Read
 - [Verified deterministic list]
 ` + `## Next Steps
@@ -289,6 +325,14 @@ var FIVE_MINUTES_MS = 5 * 60 * 1000;
 var ONE_HOUR_MS = 60 * 60 * 1000;
 var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+var ID_PREFIX = {
+  PROJECT: "proj-",
+  COMPACT_SESSION: "sc-",
+  MULTI_TOOL_USE_SYNTHETIC: "mtu_",
+  OPEN_LOOP: "loop-",
+  DECISION: "decision-",
+  ERROR: "error-"
+};
 var TUNING = {
   EMA_PREV: 0.7,
   EMA_SAMPLE: 0.3,
@@ -328,6 +372,7 @@ var TRUNC = {
   BACKUP_PREVIEW_LINES: 5,
   FINGERPRINT_SEG: 2
 };
+var LIKELY_ERROR_RE = /(?:command not found|no such file|permission denied|syntax error|cannot find|module not found|compilation error|build failed|test failed|^FAIL\b|ERROR:)/i;
 var METRICS_BUFFER_MAX = 200;
 var RUNTIME_LOG_MAX_BYTES = 5 * 1024 * 1024;
 var EXPLORER_SYSTEM_PROMPT = `You are a conversation analyst. You have deterministic extraction data and can query the raw conversation using tools.
@@ -406,6 +451,15 @@ function calibrationKey(provider, model) {
 }
 
 // src/utils/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isTextBlock(c) {
+  return isRecord(c) && c.type === "text" && typeof c.text === "string";
+}
+function isToolCallBlock(c) {
+  return isRecord(c) && c.type === "toolCall" && typeof c.name === "string" && isRecord(c.arguments);
+}
 var KNOWN_METHODS = new Set(["eesv", "single-pass", "heuristic"]);
 var KNOWN_PROFILES = new Set(["light", "balanced", "aggressive"]);
 var KNOWN_MODES = new Set(["balanced", "aggressive", "fast", "thorough"]);
@@ -464,6 +518,74 @@ function isKnownPathReference(ref, knownPaths) {
   });
 }
 
+// src/domain/tool-semantics.ts
+var PATH_KEYS = [
+  "path",
+  "file_path",
+  "filePath",
+  "filename",
+  "file",
+  "target_file",
+  "file_uri",
+  "absolute_path"
+];
+var PAYLOAD_KEYS = [
+  "content",
+  "newText",
+  "oldText",
+  "new_str",
+  "old_str",
+  "new_string",
+  "old_string",
+  "edits",
+  "patch",
+  "replacement"
+];
+var COMMAND_KEYS = ["command", "cmd", "script"];
+function hasPresent(args, keys) {
+  return keys.some((k) => args[k] != null);
+}
+function extractToolPath(args) {
+  if (!args || typeof args !== "object")
+    return;
+  const a = args;
+  for (const k of PATH_KEYS) {
+    const v = a[k];
+    if (typeof v === "string" && v.length > 0)
+      return v;
+  }
+  return;
+}
+function normalizeToolName(name) {
+  if (typeof name !== "string")
+    return "";
+  return name.replace(/^functions[.:/_-]+/i, "").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function nameHas(name, hints) {
+  const words = name.split("_");
+  return hints.some((hint) => words.includes(hint));
+}
+function classifyToolOperation(args, toolName) {
+  const a = args && typeof args === "object" ? args : {};
+  const name = normalizeToolName(toolName);
+  const hasPath = extractToolPath(a) !== undefined;
+  if (hasPath && hasPresent(a, PAYLOAD_KEYS))
+    return "mutate";
+  if (hasPresent(a, COMMAND_KEYS))
+    return "execute";
+  if (hasPath && hasPresent(a, ["text"]) && nameHas(name, ["write", "edit", "patch", "replace", "append", "create", "update", "insert"]))
+    return "mutate";
+  if (hasPath && nameHas(name, ["delete", "remove", "unlink"]))
+    return "delete";
+  if (hasPresent(a, ["pattern", "query", "glob"]) || nameHas(name, ["grep", "search", "find", "glob", "rg"]))
+    return "search";
+  if (nameHas(name, ["list", "ls", "tree"]))
+    return "list";
+  if (hasPath || nameHas(name, ["read"]))
+    return "read";
+  return "unknown";
+}
+
 // 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;
@@ -499,6 +621,8 @@ function classifyHeading(raw) {
     return "files-modified";
   if (text.includes("file") && (text.includes("read") || text.includes("viewed")))
     return "files-read";
+  if (text.includes("file") && (text.includes("delet") || text.includes("remov")))
+    return "files-deleted";
   if (text.includes("next step") || text === "next actions")
     return "next-steps";
   if (text.includes("critical context") || text === "important context")
@@ -532,6 +656,7 @@ function parseSummary(markdown) {
   let currentHeading = "";
   let currentKind = "unknown";
   let bodyLines = [];
+  let fence = null;
   let started = false;
   const flush = () => {
     if (!started)
@@ -545,16 +670,31 @@ function parseSummary(markdown) {
       sections.push({ kind: currentKind, heading: currentHeading.trim(), body });
   };
   for (const line of lines) {
-    const m = line.match(HEADING_RE);
-    if (m) {
-      const kind = classifyHeading(m[2]);
-      if (m[1].length <= 2 || kind !== "unknown") {
-        flush();
-        currentHeading = "## " + m[2].trim();
-        currentKind = kind;
-        bodyLines = [];
-        started = true;
-        continue;
+    const fenceMatch = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      const markerLength = fenceMatch[1].length;
+      if (!fence) {
+        fence = { marker, length: markerLength };
+      } else if (marker === fence.marker && markerLength >= fence.length && !fenceMatch[2].trim()) {
+        fence = null;
+      }
+      if (started)
+        bodyLines.push(line);
+      continue;
+    }
+    if (!fence) {
+      const heading = line.match(HEADING_RE);
+      if (heading) {
+        const kind = classifyHeading(heading[2]);
+        if (heading[1].length <= 2 || kind !== "unknown") {
+          flush();
+          currentHeading = "## " + heading[2].trim();
+          currentKind = kind;
+          bodyLines = [];
+          started = true;
+          continue;
+        }
       }
     }
     if (started)
@@ -569,12 +709,68 @@ function findSection(summary, kind) {
 }
 
 // src/utils/extraction.ts
+function nestedToolCallId(wrapperId, messageIndex, toolIndex, nestedId) {
+  return typeof nestedId === "string" ? nestedId : wrapperId ? wrapperId + "_" + toolIndex : ID_PREFIX.MULTI_TOOL_USE_SYNTHETIC + messageIndex + "_" + toolIndex;
+}
+function flattenToolCallBlock(b) {
+  if (!isToolCallBlock(b))
+    return [];
+  if (b.name === "multi_tool_use.parallel" && Array.isArray(b.arguments?.tool_uses)) {
+    return b.arguments.tool_uses.map((u) => {
+      const recipient = u?.recipient_name ?? "";
+      return {
+        name: recipient.replace(/^functions\./, ""),
+        id: u?.id ?? undefined,
+        arguments: u?.parameters ?? {}
+      };
+    });
+  }
+  return [{ name: b.name, id: b.id, arguments: b.arguments }];
+}
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((b) => {
+    if (typeof b === "string")
+      return b;
+    if (isTextBlock(b))
+      return b.text;
+    return "";
+  }).join("");
+}
+function buildToolCallIndex(msgs) {
+  const idx = new Map;
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    if (m.role !== "assistant")
+      continue;
+    const blocks = Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (!isToolCallBlock(b))
+        continue;
+      if (b.id) {
+        idx.set(b.id, { name: b.name, arguments: b.arguments, msgIndex: i });
+      }
+      if (b.name === "multi_tool_use.parallel" && Array.isArray(b.arguments?.tool_uses)) {
+        const nested = flattenToolCallBlock(b);
+        for (let t = 0;t < nested.length; t++) {
+          const tool = nested[t];
+          const id = nestedToolCallId(b.id, i, t, tool.id);
+          idx.set(id, { name: tool.name, arguments: tool.arguments, msgIndex: i });
+        }
+      }
+    }
+  }
+  return idx;
+}
 var CONSTRAINT_PATTERNS = [
   { re: /\b(?:must|need|require|has to|important)\b.*\b(?:be|use|have|include|support)\b/i, cat: "requirement", conf: TUNING.CONFIDENCE_HIGH },
   { re: /\b(?:don't|never|avoid|shouldn't|must not|do not|no\s+(?:need|want))\b/i, cat: "prohibition", conf: TUNING.CONFIDENCE_MEDIUM },
   { re: /\b(?:prefer|like|want|would rather|should)\b.*\b(?:use|be|have|with)\b/i, cat: "preference", conf: TUNING.CONFIDENCE_LOW },
-  { re: /(?<![A-Za-z0-9_])(?:kritik|kritikal|\u00F6nemli|onemli|\u015Fart|sart|zorunlu|\u015Fart ko\u015Ful|\u00F6nemli \u015Fart|kesinlikle|kesinlikle \u015Fart|asla|sak\u0131n|sak\u0131nha|bunu yapma|b\u00F6yle olsun|b\u00F6yle yap\u0131n|\u015F\u00F6yle olsun|\u015F\u00F6yle yap\u0131n)(?![A-Za-z0-9_])/iu, cat: "requirement", conf: TUNING.CONFIDENCE_MEDIUM },
-  { re: /(?<![A-Za-z0-9_])(?:yapma|kullanma|sak\u0131n|asla\s+(?:kullanma|yapma|getirme))(?![A-Za-z0-9_])/iu, cat: "prohibition", conf: TUNING.CONFIDENCE_MEDIUM },
+  { re: /(?<![A-Za-z0-9_])(?:yapma|kullanma|sak\u0131n|sak\u0131nha|asla(?:\s+(?:kullanma|yapma|getirme))?|bunu yapma)(?![A-Za-z0-9_])/iu, cat: "prohibition", conf: TUNING.CONFIDENCE_MEDIUM },
+  { re: /(?<![A-Za-z0-9_])(?:kritik|kritikal|\u00F6nemli|onemli|\u015Fart|sart|zorunlu|\u015Fart ko\u015Ful|\u00F6nemli \u015Fart|kesinlikle|kesinlikle \u015Fart|b\u00F6yle olsun|b\u00F6yle yap\u0131n|\u015F\u00F6yle olsun|\u015F\u00F6yle yap\u0131n)(?![A-Za-z0-9_])/iu, cat: "requirement", conf: TUNING.CONFIDENCE_MEDIUM },
   { re: /(?<![A-Za-z0-9_])(?:tercih|isterim|olsun|kullanal\u0131m|yapal\u0131m|istiyorum)(?![A-Za-z0-9_])/iu, cat: "preference", conf: TUNING.CONFIDENCE_LOW }
 ];
 function isDiagnosticConstraintText(text) {
@@ -641,7 +837,6 @@ function readJsonlTail(target, limit, maxBytes = 512 * 1024) {
   }
   return values.slice(-limit);
 }
-var scheduledTailTrims = new Set;
 
 // src/infra/clock.ts
 var systemClock = {
@@ -655,14 +850,23 @@ import crypto from "crypto";
 var SECRET_PATTERNS = [
   { kind: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
   { kind: "aws-access-key", regex: /\bAKIA[0-9A-Z]{16}\b/g },
-  { kind: "github-token", regex: /\bgh[pousr]_[A-Za-z0-9]{30,}\b/g },
+  { kind: "google-api-key", regex: /\bAIza[0-9A-Za-z_-]{30,}\b/g },
+  { kind: "stripe-key", regex: /\b[rs]k_(?:live|test)_[0-9A-Za-z]{16,}\b/g },
+  { kind: "gitlab-token", regex: /\bglpat-[0-9A-Za-z_-]{20,}\b/g },
+  { kind: "npm-token", regex: /\bnpm_[0-9A-Za-z]{30,}\b/g },
+  { kind: "github-token", regex: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g },
   { kind: "api-key", regex: /\bsk-(?:ant-)?[A-Za-z0-9_-]{20,}\b/g },
-  { kind: "slack-token", regex: /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/g },
+  { kind: "slack-token", regex: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
   { kind: "jwt", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g },
-  { kind: "bearer-token", regex: /\bBearer\s+[A-Za-z0-9._~+\/-]{24,}/gi, replacement: () => "Bearer [REDACTED:bearer-token]" },
+  { kind: "bearer-token", regex: /\bBearer\s+[A-Za-z0-9._~+\/-]{12,}=*/gi, replacement: () => "Bearer [REDACTED:bearer-token]" },
+  {
+    kind: "connection-password",
+    regex: /\b([a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)[^@\s/]+(@)/gi,
+    replacement: (prefix, suffix) => prefix + "[REDACTED:password]" + suffix
+  },
   {
     kind: "credential",
-    regex: /\b(api[_-]?key|access[_-]?token|auth[_-]?token|token|password|passwd|secret)\s*([:=])\s*["']?([A-Za-z0-9._~+\/-]{16,})["']?/gi,
+    regex: /\b((?:[A-Za-z0-9]+[_-])*(?:api[_-]?key|access[_-]?token|auth[_-]?token|token|password|passwd|secret(?:[_-]?(?:access)?[_-]?key)?|client[_-]?secret)(?:[_-][A-Za-z0-9]+)*)\s*([:=])\s*["']?([^\s"']{16,})["']?/gi,
     replacement: (name, separator) => name + separator + "[REDACTED:credential]"
   }
 ];
@@ -690,6 +894,42 @@ function mergeFindings(target, findings) {
   for (const finding of findings)
     target.set(finding.kind, (target.get(finding.kind) ?? 0) + finding.count);
 }
+var SECRET_KEY_NAMES = {
+  api_key: true,
+  apikey: true,
+  access_token: true,
+  auth_token: true,
+  authorization: true,
+  password: true,
+  passwd: true,
+  secret: true,
+  secret_key: true,
+  secret_access_key: true,
+  client_secret: true,
+  private_key: true,
+  database_url: true,
+  connection_string: true,
+  token: true,
+  refresh_token: true,
+  session_token: true,
+  credential: true,
+  credentials: true,
+  cookie: true,
+  set_cookie: true,
+  otp: true,
+  one_time_password: true,
+  pin: true,
+  passcode: true
+};
+function normalizeObjectKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function isSecretBearingKey(key) {
+  const normalized = normalizeObjectKey(key);
+  if (SECRET_KEY_NAMES[normalized])
+    return true;
+  return /(?:^|_)(?:api_key|access_token|auth_token|password|passwd|secret_access_key|client_secret|private_key|refresh_token|session_token|one_time_password|passcode)(?:_|$)/.test(normalized);
+}
 
 class SecretScrubber {
   secretsEnabled;
@@ -719,6 +959,10 @@ class SecretScrubber {
   scrubValue(input) {
     const findings = new Map;
     const seen = new WeakMap;
+    const recordCredential = () => {
+      findings.set("credential", (findings.get("credential") ?? 0) + 1);
+      this.total++;
+    };
     const visit = (value2) => {
       if (typeof value2 === "string") {
         const result = this.scrubText(value2);
@@ -739,8 +983,15 @@ class SecretScrubber {
       }
       const output = {};
       seen.set(value2, output);
-      for (const [key, item] of Object.entries(value2))
-        output[key] = visit(item);
+      for (const [key, item] of Object.entries(value2)) {
+        const carriesSecret = typeof item === "string" ? item.length > 0 : item != null;
+        if (this.secretsEnabled && isSecretBearingKey(key) && carriesSecret) {
+          output[key] = "[REDACTED:credential]";
+          recordCredential();
+        } else {
+          output[key] = visit(item);
+        }
+      }
       return output;
     };
     const value = visit(input);
@@ -999,8 +1250,8 @@ function readMetricsLog(limit = 100) {
     const fd = fs2.openSync(logPath, "r");
     try {
       const buf = Buffer.alloc(wantBytes);
-      fs2.readSync(fd, buf, 0, wantBytes, startPos);
-      let text = buf.toString("utf8");
+      const bytesRead = fs2.readSync(fd, buf, 0, wantBytes, startPos);
+      let text = buf.subarray(0, bytesRead).toString("utf8");
       if (startPos > 0) {
         const nl = text.indexOf(`
 `);
@@ -1028,6 +1279,79 @@ function readMetricsLog(limit = 100) {
 }
 
 // src/phases/verify.ts
+var HIGH_RISK_OUTCOME_RE = /(?:\ball\s+tests?\s+(?:pass|passed|passing)\b|\btests?\s+(?:pass|passed|passing)\b|\b(?:build|deployment|migration)\s+(?:completed|succeeded|passed|successful)\b|\b(?:deployed|published|released)\b|\b(?:bug|issue|error)\s+(?:fixed|resolved)\b|\bno\s+(?:errors?|failures?)\b|\bcompleted successfully\b|\btestler?\s+(?:ge\u00E7ti|ba\u015Far\u0131l\u0131)\b|\bba\u015Far\u0131yla\s+(?:tamamland\u0131|da\u011F\u0131t\u0131ld\u0131|yay\u0131nland\u0131)\b|\b(?:deploy edildi|yay\u0131nland\u0131|hata yok)\b)/iu;
+var NEGATED_OUTCOME_RE = /\b(?:not|never|pending|failed|failing|unresolved|hen\u00FCz|de\u011Fil|ba\u015Far\u0131s\u0131z)\b/iu;
+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 classifyOutcomeClaim(claim) {
+  const lower = claim.toLowerCase();
+  if (/\btests?\b|\btestler?\b/.test(lower))
+    return "test";
+  if (/\bbuild\b|\bcompil(?:e|ed|ation)\b|\btypecheck\b/.test(lower))
+    return "build";
+  if (/\bdeploy(?:ed|ment)?\b|\bpublish(?:ed)?\b|\breleas(?:e|ed)\b/.test(lower))
+    return "release";
+  if (/\bbug\b|\bissue\b|\berror\b|\bfail(?:ed|ure)?\b|\bhata\b/.test(lower))
+    return "error";
+  if (/\bfile\b|\bdosya\b/.test(lower))
+    return "file";
+  return "generic";
+}
+var successfulToolEvidenceCache = new WeakMap;
+function successfulToolEvidence(messages) {
+  const cached = successfulToolEvidenceCache.get(messages);
+  if (cached)
+    return cached;
+  const toolCalls = buildToolCallIndex(messages);
+  const evidence = [];
+  for (const message of messages) {
+    if (message.role !== "toolResult" || message.isError)
+      continue;
+    const call = toolCalls.get(message.toolCallId ?? "");
+    if (!call)
+      continue;
+    const result = extractText(message.content).slice(0, 8000);
+    if (!result.trim() || LIKELY_ERROR_RE.test(result))
+      continue;
+    const command = [call.arguments.command, call.arguments.cmd, call.arguments.script].find((value) => typeof value === "string") ?? "";
+    evidence.push({
+      name: normalizeToolName(call.name),
+      operation: classifyToolOperation(call.arguments, call.name),
+      command,
+      path: extractToolPath(call.arguments),
+      result
+    });
+  }
+  successfulToolEvidenceCache.set(messages, evidence);
+  return evidence;
+}
+function successfulToolSupportsClaim(claim, tools, extraction) {
+  const shape = semanticShape(claim);
+  const category = classifyOutcomeClaim(claim);
+  if (category === "error" && extraction.errors.some((error) => error.resolved && hasSemanticEvidence(claim, error.message)))
+    return true;
+  if (category === "file" && extraction.modifiedFiles.some((file) => claim.toLowerCase().includes(file.path.toLowerCase())))
+    return true;
+  for (const tool of tools) {
+    const operationText = tool.name + " " + tool.command;
+    const operationSupports = category === "test" ? /\b(?:test|tests|pytest|jest|vitest|mocha|rspec)\b/i.test(operationText) : category === "build" ? /\b(?:build|compile|typecheck|tsc|check)\b/i.test(operationText) : category === "release" ? /\b(?:deploy|publish|release)\b/i.test(operationText) : category === "file" ? tool.operation === "mutate" || tool.operation === "delete" : category === "error" ? tool.operation === "execute" || tool.operation === "mutate" || tool.operation === "delete" : tool.operation !== "read" && tool.operation !== "search" && tool.operation !== "list";
+    if (!operationSupports)
+      continue;
+    if (hasSemanticEvidence(claim, tool.result))
+      return true;
+    const lower = tool.result.toLowerCase();
+    if (category === "test" && /\b\d+\s+(?:tests?\s+)?pass(?:ed)?\b/.test(lower) && !/\b(?:fail(?:ed|ures?)?|errors?)\s*[:=]?\s*[1-9]\d*\b/.test(lower))
+      return true;
+    if (category === "build" && /\b(?:succeeded|successful|passed|exit(?:ed)?\s+(?:code\s+)?0)\b/.test(lower))
+      return true;
+    if (category === "release" && /\b(?:succeeded|successful|completed|published|deployed|released)\b/.test(lower))
+      return true;
+    if (category === "error" && shape.concepts.length > 0 && /\b(?:fixed|resolved|passed|succeeded|successful)\b/.test(lower) && hasSemanticEvidence(claim, tool.result))
+      return true;
+  }
+  return false;
+}
 var NEGATION_MARKERS = new Set([
   "no",
   "not",
@@ -1108,9 +1432,15 @@ function stemToken(token) {
 function semanticTokens(text) {
   return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2);
 }
-function evidenceFragments(text) {
-  const fragments = text.split(/\r?\n/).flatMap((line) => [line, ...line.split(/[.;]/)]).map((part) => part.replace(/^\s*[-*\d.)]+\s*/, "").trim()).filter(Boolean);
-  return Array.from(new Set(fragments));
+var semanticShapeCache = new Map;
+var semanticFragmentCache = new Map;
+function semanticFragments(text) {
+  const cached = lruGet(semanticFragmentCache, text);
+  if (cached)
+    return cached;
+  const fragments = Array.from(new Set(text.split(/\r?\n/).flatMap((line) => [line, ...line.split(/[.;]/)]).map((part) => part.replace(/^\s*[-*\d.)]+\s*/, "").trim()).filter(Boolean))).map(semanticTokens);
+  lruSet(semanticFragmentCache, text, fragments, 256);
+  return fragments;
 }
 function hasNearbyMarker(tokens, anchor, markers) {
   return tokens.some((token, index) => token === anchor && tokens.slice(Math.max(0, index - 2), index + 3).some((near) => markers.has(near)));
@@ -1134,20 +1464,24 @@ function hasEffectiveTargetNegation(tokens, anchor) {
   });
 }
 function semanticShape(source) {
+  const cached = lruGet(semanticShapeCache, source);
+  if (cached)
+    return cached;
   const sourceTokens = semanticTokens(source);
   const concepts = Array.from(new Set(sourceTokens.filter((token) => !/^\d+$/.test(token) && !SEMANTIC_STOP.has(token) && !NEGATION_MARKERS.has(token) && !CONDITION_MARKERS.has(token))));
   const negative = sourceTokens.some((token) => NEGATION_MARKERS.has(token));
   const conditional = sourceTokens.some((token) => CONDITION_MARKERS.has(token));
   const anchor = concepts.find((concept) => hasNearbyMarker(sourceTokens, concept, NEGATION_MARKERS)) ?? concepts[0] ?? "";
-  return { sourceTokens, concepts, anchor, negative, conditional };
+  const shape = { sourceTokens, concepts, anchor, negative, conditional };
+  lruSet(semanticShapeCache, source, shape, 512);
+  return shape;
 }
 function hasSemanticEvidence(source, target) {
   const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
   if (!concepts.length)
     return true;
   const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return evidenceFragments(target).some((fragment) => {
-    const tokens = semanticTokens(fragment);
+  return semanticFragments(target).some((tokens) => {
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
     if (overlap < required)
       return false;
@@ -1169,8 +1503,7 @@ function hasSemanticContradiction(source, target) {
   if (!anchor)
     return false;
   const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return evidenceFragments(target).some((fragment) => {
-    const tokens = semanticTokens(fragment);
+  return semanticFragments(target).some((tokens) => {
     if (!tokens.includes(anchor))
       return false;
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
@@ -1186,7 +1519,7 @@ function hasSemanticContradiction(source, target) {
     return conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token));
   });
 }
-function verifySummary(summary, extraction, continuity = null) {
+function verifySummary(summary, extraction, continuity = null, evidence = {}) {
   const parsed = parseSummary(summary);
   const gaps = [];
   const lower = summary.toLowerCase().replace(/\\/g, "/");
@@ -1206,9 +1539,18 @@ function verifySummary(summary, extraction, continuity = null) {
     ...extraction.errors.filter((error) => !error.resolved).map((error) => ({ 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 })),
+    ...(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 }))
+    ...(continuity?.constraints ?? []).filter((item) => item.confidence >= 0.8).map((item) => ({ 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 })),
@@ -1226,16 +1568,29 @@ function verifySummary(summary, extraction, continuity = null) {
       score -= req.penalty;
     }
   }
+  const listedPaths = (kind) => new Set((findSection(parsed, kind)?.body ?? "").split(`
+`).map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").trim()).map((line) => line.startsWith("`") && line.endsWith("`") ? line.slice(1, -1) : line).filter((line) => line.length > 0 && !/^none(?: recorded)?[.!]?$/i.test(line)).map(normalizePath));
   const modifiedPaths = extraction.modifiedFiles.map((file) => file.path);
-  const listedModifiedPaths = new Set((findSection(parsed, "files-modified")?.body ?? "").split(`
-`).map((line) => line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").replace(/^\[[ x]\]\s+/i, "").trim()).map((line) => line.startsWith("`") && line.endsWith("`") ? line.slice(1, -1) : line).filter(Boolean).map(normalizePath));
-  for (const file of extraction.modifiedFiles) {
-    const needles = buildUniquePathNeedles(file.path, modifiedPaths);
-    if (!listedModifiedPaths.has(normalizePath(file.path)) && !needles.some((needle) => lower.includes(needle))) {
-      gaps.push({ kind: "missing-file", path: file.path });
-      score -= 5;
-    }
+  const modifiedListed = listedPaths("files-modified");
+  const readListed = listedPaths("files-read");
+  const deletedListed = listedPaths("files-deleted");
+  for (const file of modifiedPaths) {
+    if (!modifiedListed.has(normalizePath(file)))
+      gaps.push({ kind: "missing-file", path: file });
+  }
+  for (const file of extraction.readFiles) {
+    if (!readListed.has(normalizePath(file)))
+      gaps.push({ kind: "missing-read-file", path: file });
+  }
+  const deletedEvidence = Array.from(new Set([
+    ...extraction.deletedFiles,
+    ...continuity?.deletedFiles ?? []
+  ]));
+  for (const file of deletedEvidence) {
+    if (!deletedListed.has(normalizePath(file)))
+      gaps.push({ kind: "missing-deleted-file", path: file });
   }
+  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) {
     const snippet = summaryEvidenceLine(error.message, TRUNC.ERROR_SNIPPET).toLowerCase();
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
@@ -1243,6 +1598,13 @@ function verifySummary(summary, extraction, continuity = null) {
       score -= 5;
     }
   }
+  for (const error of resolvedEvidence) {
+    const snippet = summaryEvidenceLine(error.message, TRUNC.ERROR_SNIPPET).toLowerCase();
+    if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
+      gaps.push({ kind: "missing-error", message: error.message, resolved: true });
+      score -= 2;
+    }
+  }
   const constraintTarget = [
     findSection(parsed, "constraints")?.body ?? "",
     findSection(parsed, "critical-context")?.body ?? ""
@@ -1303,16 +1665,18 @@ function verifySummary(summary, extraction, continuity = null) {
       gaps.push({ 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 basename = file.path.split("/").pop() ?? "";
-      if (!doneSection.toLowerCase().includes(basename.toLowerCase()))
+      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] ?? "";
-        return extractFileRefs(firstLine).some((ref) => isKnownPathReference(ref, [file.path]));
+        const errorRefs = extractFileRefs(firstLine).map(normalizePath);
+        return uniqueNeedles.some((needle) => errorRefs.includes(normalizePath(needle)));
       });
       if (unresolved) {
-        gaps.push({ kind: "inconsistency", detail: basename + " marked Done but has unresolved error" });
+        gaps.push({ kind: "inconsistency", detail: file.path + " marked Done but has unresolved error" });
         score -= 5;
       }
     }
@@ -1333,6 +1697,15 @@ function verifySummary(summary, extraction, continuity = null) {
     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;
+      }
+    }
+  }
   const finalScore = Math.max(0, score);
   return { ok: gaps.length === 0 && finalScore >= 85, gaps, score: finalScore };
 }