pi-smart-compact 9.2.1 → 9.3.1

package/dist/provider-scenario-eval.js

@@ -4,172 +4,8 @@ var __require = import.meta.require;
 // scripts/provider-scenario-eval.ts
 import { ModelRegistry, ModelRuntime } from "@earendil-works/pi-coding-agent";
 
-// src/infra/llm-client.ts
-var _complete = null;
-var _completeSimple = null;
-var _stream = null;
-var _streamSimple = null;
-async function resolveComplete() {
-  if (_complete)
-    return _complete;
-  const mod = await import("@earendil-works/pi-ai/compat");
-  const fn = mod.complete;
-  if (typeof fn !== "function")
-    throw new Error("smart-compact: pi-ai /compat did not export complete()");
-  _complete = fn;
-  return fn;
-}
-async function resolveCompleteSimple() {
-  if (_completeSimple)
-    return _completeSimple;
-  const mod = await import("@earendil-works/pi-ai/compat");
-  const fn = mod.completeSimple;
-  if (typeof fn !== "function")
-    throw new Error("smart-compact: pi-ai /compat did not export completeSimple()");
-  _completeSimple = fn;
-  return fn;
-}
-async function resolveStream() {
-  if (_stream)
-    return _stream;
-  const mod = await import("@earendil-works/pi-ai/compat");
-  if (typeof mod.stream !== "function")
-    throw new Error("smart-compact: pi-ai /compat did not export stream()");
-  _stream = mod.stream;
-  return _stream;
-}
-async function resolveStreamSimple() {
-  if (_streamSimple)
-    return _streamSimple;
-  const mod = await import("@earendil-works/pi-ai/compat");
-  if (typeof mod.streamSimple !== "function")
-    throw new Error("smart-compact: pi-ai /compat did not export streamSimple()");
-  _streamSimple = mod.streamSimple;
-  return _streamSimple;
-}
-function isChatGptCodex(model) {
-  if (model.api !== "openai-codex-responses")
-    return false;
-  return !model.baseUrl || model.baseUrl.includes("chatgpt.com");
-}
-function withCodexWireLimit(model, opts) {
-  if (model.api !== "openai-codex-responses" || isChatGptCodex(model) || !opts.maxTokens)
-    return opts;
-  const previous = opts.onPayload;
-  return {
-    ...opts,
-    onPayload: async (payload, requestModel) => {
-      const transformed = await previous?.(payload, requestModel);
-      const body = transformed ?? payload;
-      return body && typeof body === "object" ? { ...body, max_output_tokens: opts.maxTokens } : body;
-    }
-  };
-}
-function resolveCodexWatchdogMs(maxTokens, configuredMs = 0) {
-  if (configuredMs > 0)
-    return configuredMs;
-  return Math.min(90000, Math.max(15000, 1e4 + (maxTokens ?? 4096) * 8));
-}
-function streamedChars(event) {
-  if (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") {
-    return event.delta.length;
-  }
-  return 0;
-}
-function assertSuccessful(message) {
-  if (message.stopReason === "error" || message.stopReason === "aborted") {
-    throw new Error(message.errorMessage || "LLM request failed");
-  }
-  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);
-  let watchdogReason = null;
-  let visibleChars = 0;
-  const abortFromCaller = () => controller.abort(opts.signal?.reason);
-  opts.signal?.addEventListener("abort", abortFromCaller, { once: true });
-  if (opts.signal?.aborted)
-    abortFromCaller();
-  const timer = setTimeout(() => {
-    watchdogReason = "time";
-    controller.abort("codex-watchdog");
-  }, watchdogMs);
-  timer.unref?.();
-  try {
-    const limited = { ...opts, signal: controller.signal };
-    const events = opts.reasoning === undefined ? (await resolveStream())(model, body, limited) : (await resolveStreamSimple())(model, body, limited);
-    let final;
-    for await (const event of events) {
-      visibleChars += streamedChars(event);
-      if (!watchdogReason && opts.maxTokens && visibleChars > opts.maxTokens * 3) {
-        watchdogReason = "visible-output";
-        controller.abort("codex-visible-output-cap");
-      }
-      if (event.type === "done")
-        final = event.message;
-      else if (event.type === "error")
-        final = event.error;
-    }
-    if (watchdogReason) {
-      throw new Error("Codex " + watchdogReason + " watchdog stopped generation after " + watchdogMs + "ms / " + visibleChars + " streamed chars");
-    }
-    if (!final)
-      throw new Error("Codex stream ended without a final message");
-    return assertSuccessful(final);
-  } finally {
-    clearTimeout(timer);
-    opts.signal?.removeEventListener("abort", abortFromCaller);
-  }
-}
-var rawLlmClient = {
-  complete: async (model, body, originalOpts) => {
-    const opts = withCodexWireLimit(model, originalOpts);
-    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;
-var _client = defaultLlmClient;
-function getLlmClient() {
-  return _client;
-}
-
 // src/constants.ts
-var VERSION = "9.2.1";
+var VERSION = "9.3.1";
 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 = {
@@ -391,9 +227,6 @@ var EXPLORER_SYSTEM_PROMPT = `You are a conversation analyst. You have determini
 ` + `After exploration, output ONLY a JSON object (no markdown):
 ` + '{"boundaries":[{"afterIndex":N,"topic":"...","priority":"critical|high|normal|low","confidence":0.0-1.0}],"mainGoal":"...","sessionType":"implementation|review|debugging|discussion","enrichedConstraints":[...],"crossReferences":[...],"statusAssessment":{"done":[...],"inProgress":[...],"blocked":[...]},"criticalContext":[...],"keyDecisions":[...]}';
 
-// src/utils/cache.ts
-import fs2 from "fs";
-
 // src/utils/lru.ts
 function lruGet(m, key) {
   if (!m.has(key))
@@ -416,6 +249,188 @@ function lruSet(m, key, value, max) {
 }
 
 // src/utils/tokens.ts
+var PROVIDER_MAP = {
+  "zai-anthropic": {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 3.5,
+    concurrencyLimit: 3,
+    cacheStrategy: "anthropic",
+    timeoutMultiplier: 1.2,
+    singlePassTokenMultiplier: 1,
+    multimodal: "metadata-only"
+  },
+  "kimi-coding": {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 3.5,
+    concurrencyLimit: 2,
+    cacheStrategy: "anthropic",
+    timeoutMultiplier: 1.5,
+    singlePassTokenMultiplier: 0.95,
+    multimodal: "metadata-only"
+  },
+  anthropic: {
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 3.5,
+    concurrencyLimit: 3,
+    cacheStrategy: "anthropic",
+    timeoutMultiplier: 1.2,
+    singlePassTokenMultiplier: 1,
+    multimodal: "native"
+  },
+  openai: {
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 4,
+    concurrencyLimit: 5,
+    cacheStrategy: "openai",
+    timeoutMultiplier: 1,
+    singlePassTokenMultiplier: 1.15,
+    multimodal: "native"
+  },
+  google: {
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 3.8,
+    concurrencyLimit: 3,
+    cacheStrategy: "openai",
+    timeoutMultiplier: 1.15,
+    singlePassTokenMultiplier: 1.1,
+    multimodal: "native"
+  },
+  deepseek: {
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.6,
+    concurrencyLimit: 2,
+    cacheStrategy: "none",
+    timeoutMultiplier: 1.5,
+    singlePassTokenMultiplier: 0.85,
+    multimodal: "metadata-only"
+  },
+  minimax: {
+    maxOutputTokens: 4096,
+    supportsTools: "probe",
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.8,
+    concurrencyLimit: 2,
+    cacheStrategy: "anthropic",
+    timeoutMultiplier: 1.6,
+    singlePassTokenMultiplier: 0.8,
+    multimodal: "metadata-only"
+  },
+  "xiaomi-token-plan": {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.3,
+    concurrencyLimit: 2,
+    cacheStrategy: "openai",
+    timeoutMultiplier: 1.35,
+    singlePassTokenMultiplier: 0.9,
+    multimodal: "metadata-only"
+  },
+  "xiaomi-mimo": {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.3,
+    concurrencyLimit: 2,
+    cacheStrategy: "anthropic",
+    timeoutMultiplier: 1.35,
+    singlePassTokenMultiplier: 0.9,
+    multimodal: "metadata-only"
+  },
+  crofai: {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.8,
+    concurrencyLimit: 3,
+    cacheStrategy: "none",
+    timeoutMultiplier: 1.2,
+    singlePassTokenMultiplier: 0.95,
+    multimodal: "metadata-only"
+  },
+  mistral: {
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 3.5,
+    concurrencyLimit: 3,
+    cacheStrategy: "openai",
+    timeoutMultiplier: 1.2,
+    singlePassTokenMultiplier: 1,
+    multimodal: "metadata-only"
+  },
+  xai: {
+    maxOutputTokens: 8192,
+    supportsTools: true,
+    jsonReliability: "medium",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 3.8,
+    concurrencyLimit: 3,
+    cacheStrategy: "openai",
+    timeoutMultiplier: 1.2,
+    singlePassTokenMultiplier: 1,
+    multimodal: "native"
+  }
+};
+var PROVIDER_ALIASES = [
+  { pattern: /anthropic/i, provider: "anthropic" },
+  { pattern: /kimi/i, provider: "kimi-coding" },
+  { pattern: /zai/i, provider: "zai-anthropic" },
+  { pattern: /openai/i, provider: "openai" },
+  { pattern: /gpt/i, provider: "openai" },
+  { pattern: /google|gemini/i, provider: "google" },
+  { pattern: /deepseek/i, provider: "deepseek" },
+  { pattern: /minimax/i, provider: "minimax" },
+  { pattern: /xiaomi-mimo/i, provider: "xiaomi-mimo" },
+  { pattern: /xiaomi/i, provider: "xiaomi-token-plan" },
+  { pattern: /crofai/i, provider: "crofai" },
+  { pattern: /mistral/i, provider: "mistral" },
+  { pattern: /xai|grok/i, provider: "xai" }
+];
+var DEFAULT_CAPS = {
+  maxOutputTokens: 8192,
+  supportsTools: "probe",
+  jsonReliability: "medium",
+  instructionFollowing: "medium",
+  tokenRatioEstimate: 3.8,
+  concurrencyLimit: 2,
+  cacheStrategy: "none",
+  timeoutMultiplier: 1.35,
+  singlePassTokenMultiplier: 0.9,
+  multimodal: "metadata-only"
+};
+function getProviderCaps(provider) {
+  if (PROVIDER_MAP[provider])
+    return PROVIDER_MAP[provider];
+  for (const { pattern, provider: key } of PROVIDER_ALIASES) {
+    if (pattern.test(provider))
+      return PROVIDER_MAP[key] ?? DEFAULT_CAPS;
+  }
+  return DEFAULT_CAPS;
+}
 class TokenCalibrationStore {
   maxEntries;
   factors = new Map;
@@ -452,6 +467,177 @@ function calibrationKey(provider, model) {
   return model ? provider + "/" + model : provider + "/*";
 }
 
+// src/infra/llm-client.ts
+var _complete = null;
+var _completeSimple = null;
+var _stream = null;
+var _streamSimple = null;
+async function resolveComplete() {
+  if (_complete)
+    return _complete;
+  const mod = await import("@earendil-works/pi-ai/compat");
+  const fn = mod.complete;
+  if (typeof fn !== "function")
+    throw new Error("smart-compact: pi-ai /compat did not export complete()");
+  _complete = fn;
+  return fn;
+}
+async function resolveCompleteSimple() {
+  if (_completeSimple)
+    return _completeSimple;
+  const mod = await import("@earendil-works/pi-ai/compat");
+  const fn = mod.completeSimple;
+  if (typeof fn !== "function")
+    throw new Error("smart-compact: pi-ai /compat did not export completeSimple()");
+  _completeSimple = fn;
+  return fn;
+}
+async function resolveStream() {
+  if (_stream)
+    return _stream;
+  const mod = await import("@earendil-works/pi-ai/compat");
+  if (typeof mod.stream !== "function")
+    throw new Error("smart-compact: pi-ai /compat did not export stream()");
+  _stream = mod.stream;
+  return _stream;
+}
+async function resolveStreamSimple() {
+  if (_streamSimple)
+    return _streamSimple;
+  const mod = await import("@earendil-works/pi-ai/compat");
+  if (typeof mod.streamSimple !== "function")
+    throw new Error("smart-compact: pi-ai /compat did not export streamSimple()");
+  _streamSimple = mod.streamSimple;
+  return _streamSimple;
+}
+function isChatGptCodex(model) {
+  if (model.api !== "openai-codex-responses")
+    return false;
+  return !model.baseUrl || model.baseUrl.includes("chatgpt.com");
+}
+function withCodexWireLimit(model, opts) {
+  if (model.api !== "openai-codex-responses" || isChatGptCodex(model) || !opts.maxTokens)
+    return opts;
+  const previous = opts.onPayload;
+  return {
+    ...opts,
+    onPayload: async (payload, requestModel) => {
+      const transformed = await previous?.(payload, requestModel);
+      const body = transformed ?? payload;
+      return body && typeof body === "object" ? {
+        ...body,
+        max_output_tokens: opts.maxTokens
+      } : body;
+    }
+  };
+}
+function resolveCodexWatchdogMs(maxTokens, configuredMs = 0) {
+  if (configuredMs > 0)
+    return configuredMs;
+  return Math.min(90000, Math.max(15000, 1e4 + (maxTokens ?? 4096) * 8));
+}
+function streamedChars(event) {
+  if (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") {
+    return event.delta.length;
+  }
+  return 0;
+}
+function assertSuccessful(message) {
+  if (message.stopReason === "error" || message.stopReason === "aborted") {
+    throw new Error(message.errorMessage || "LLM request failed");
+  }
+  return message;
+}
+async function withProviderDeadline(opts, invoke, modelId) {
+  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 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);
+  let watchdogReason = null;
+  let visibleChars = 0;
+  const abortFromCaller = () => controller.abort(opts.signal?.reason);
+  opts.signal?.addEventListener("abort", abortFromCaller, { once: true });
+  if (opts.signal?.aborted)
+    abortFromCaller();
+  const timer = setTimeout(() => {
+    watchdogReason = "time";
+    controller.abort("codex-watchdog");
+  }, watchdogMs);
+  timer.unref?.();
+  try {
+    const limited = { ...opts, signal: controller.signal };
+    const events = opts.reasoning === undefined ? (await resolveStream())(model, body, limited) : (await resolveStreamSimple())(model, body, limited);
+    let final;
+    for await (const event of events) {
+      visibleChars += streamedChars(event);
+      if (!watchdogReason && opts.maxTokens && visibleChars > opts.maxTokens * 3) {
+        watchdogReason = "visible-output";
+        controller.abort("codex-visible-output-cap");
+      }
+      if (event.type === "done")
+        final = event.message;
+      else if (event.type === "error")
+        final = event.error;
+    }
+    if (watchdogReason) {
+      throw new Error("Codex " + watchdogReason + " watchdog stopped generation after " + watchdogMs + "ms / " + visibleChars + " streamed chars");
+    }
+    if (!final)
+      throw new Error("Codex stream ended without a final message");
+    return assertSuccessful(final);
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", abortFromCaller);
+  }
+}
+var rawLlmClient = {
+  complete: async (model, body, originalOpts) => {
+    const opts = withCodexWireLimit(model, originalOpts);
+    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);
+    }, model.id);
+  }
+};
+var defaultLlmClient = rawLlmClient;
+var _client = defaultLlmClient;
+function getLlmClient() {
+  return _client;
+}
+
+// src/utils/cache.ts
+import fs2 from "fs";
+
 // src/utils/type-guards.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -513,13 +699,54 @@ function buildUniquePathNeedles(filePath, allPaths) {
   });
 }
 function isKnownPathReference(ref, knownPaths) {
-  const normalizedRef = normalizePath(ref);
+  const normalizedRef = normalizePath(ref).replace(/^\/+/, "");
+  if (!normalizedRef)
+    return false;
+  const pathShaped = normalizedRef.includes("/");
   return knownPaths.some((path) => {
-    const normalizedPath = normalizePath(path);
-    return normalizedPath === normalizedRef || normalizedPath.endsWith("/" + normalizedRef);
+    const normalizedPath = normalizePath(path).replace(/^\/+/, "");
+    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))
+        return true;
+    }
+    if (!pathShaped)
+      return false;
+    return normalizedPath.split("/").some((_, index, parts) => parts.slice(index).join("/").startsWith(normalizedRef + "/"));
   });
 }
 
+// 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",
@@ -602,10 +829,20 @@ function isLikelyFileRef(candidate) {
   return CODE_EXT_RE.test(candidate);
 }
 function extractFileRefs(summary) {
-  const candidates = summary.match(FILE_REF_CANDIDATE_RE) ?? [];
-  return candidates.filter(isLikelyFileRef);
+  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] ?? ""))
+      continue;
+    if (isLikelyFileRef(match[0]))
+      refs.push(match[0]);
+  }
+  return refs;
 }
 
+// src/domain/summary-parse.ts
+import { createHash } from "crypto";
+
 // src/domain/summary-schema.ts
 function classifyHeading(raw) {
   const text = raw.replace(/^#+\s*/, "").replace(/[:\s]+$/, "").trim().toLowerCase();
@@ -645,6 +882,58 @@ var HEADING_RE = /^(#{1,3})\s+(.+?)\s*$/;
 function summaryEvidenceLine(value, maxLength) {
   return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim().replace(/^(?:(?:#{1,6}|[-*+]|>)\s+)+/, "").slice(0, maxLength).trim();
 }
+function summaryPathLine(value) {
+  return JSON.stringify(value);
+}
+function compactPathLine(value, maxLength, digest) {
+  const minimal = JSON.stringify("#" + digest);
+  if (minimal.length >= maxLength)
+    return minimal;
+  const chars = Array.from(value.replace(/\\/g, "/"));
+  let low = 0;
+  let high = chars.length;
+  let best = minimal;
+  while (low <= high) {
+    const length = Math.floor((low + high) / 2);
+    const candidate = JSON.stringify("\u2026/" + chars.slice(-length).join("") + "#" + digest);
+    if (candidate.length <= maxLength) {
+      best = candidate;
+      low = length + 1;
+    } else {
+      high = length - 1;
+    }
+  }
+  return best;
+}
+function buildSummaryPathEvidence(paths, budgetTokens = PROFILES.balanced.summaryBudgetTokens) {
+  const unique = Array.from(new Set(paths.filter(Boolean)));
+  if (!unique.length)
+    return new Map;
+  const full = unique.map((path2) => [path2, summaryPathLine(path2)]);
+  const minimumPerLine = JSON.stringify("#" + "x".repeat(12)).length + 3;
+  const budgetChars = Math.max(unique.length * minimumPerLine, Math.min(20000, Math.max(4000, Math.floor(budgetTokens * 2))));
+  if (full.reduce((total, [, line]) => total + line.length + 3, 0) <= budgetChars) {
+    return new Map(full);
+  }
+  const digests = new Map;
+  const owners = new Map;
+  for (const path2 of unique) {
+    const fullDigest = createHash("sha256").update(path2).digest("base64url");
+    let digest = fullDigest.slice(0, 12);
+    const owner = owners.get(digest);
+    if (owner && owner !== path2) {
+      digest = fullDigest;
+      digests.set(owner, createHash("sha256").update(owner).digest("base64url"));
+    }
+    owners.set(digest, path2);
+    digests.set(path2, digest);
+  }
+  const perPath = Math.max(JSON.stringify("#" + "x".repeat(12)).length, Math.floor((budgetChars - unique.length * 3) / unique.length));
+  return new Map(unique.map((path2) => [
+    path2,
+    compactPathLine(path2, perPath, digests.get(path2) ?? "")
+  ]));
+}
 function mergeBodies(first, second) {
   const seen = new Set;
   return [first, second].filter(Boolean).flatMap((body) => body.split(`
@@ -669,7 +958,11 @@ function parseSummary(markdown) {
     if (existing)
       existing.body = mergeBodies(existing.body, body);
     else
-      sections.push({ kind: currentKind, heading: currentHeading.trim(), body });
+      sections.push({
+        kind: currentKind,
+        heading: currentHeading.trim(),
+        body
+      });
   };
   for (const line of lines) {
     const fenceMatch = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
@@ -760,7 +1053,11 @@ function buildToolCallIndex(msgs) {
         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 });
+          idx.set(id, {
+            name: tool.name,
+            arguments: tool.arguments,
+            msgIndex: i
+          });
         }
       }
     }
@@ -768,46 +1065,42 @@ function buildToolCallIndex(msgs) {
   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_])(?: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 }
+  {
+    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_])(?: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) {
   const candidate = text.replace(/^\s*[-*]\s+/, "").trim();
   return /^(?:\[[^\]]+\]\s*)?(?:npm\s+(?:error|warn|notice|audit|verbose|info)\b|(?:rg|grep):|command exited\b)/i.test(candidate);
 }
 
-// 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";
-function home() {
-  return process.env.HOME ?? "/tmp";
-}
-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/infra/fs.ts
 import fs from "fs";
 function readJsonlTail(target, limit, maxBytes = 512 * 1024) {
@@ -850,7 +1143,10 @@ import crypto from "crypto";
 
 // src/domain/scrub.ts
 var SECRET_PATTERNS = [
-  { kind: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
+  {
+    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: "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 },
@@ -859,8 +1155,15 @@ var SECRET_PATTERNS = [
   { 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-]{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._~+\/-]{12,}=*/gi, replacement: () => "Bearer [REDACTED:bearer-token]" },
+  {
+    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._~+/-]{12,}=*/gi,
+    replacement: () => "Bearer [REDACTED:bearer-token]"
+  },
   {
     kind: "connection-password",
     regex: /\b([a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)[^@\s/]+(@)/gi,
@@ -869,12 +1172,35 @@ var SECRET_PATTERNS = [
   {
     kind: "credential",
     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]"
+    replacement: (name, separator, value, match) => /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(value) ? match : name + separator + "[REDACTED:credential]"
   }
 ];
+function passesLuhn(candidate) {
+  const digits = candidate.replace(/\D/g, "");
+  if (digits.length < 13 || digits.length > 19)
+    return false;
+  if (/^(\d)\1+$/.test(digits))
+    return false;
+  let sum = 0, double = false;
+  for (let i = digits.length - 1;i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (double) {
+      d *= 2;
+      if (d > 9)
+        d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
 var PII_PATTERNS = [
   { kind: "email", regex: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi },
-  { kind: "payment-card", regex: /\b(?:\d[ -]*?){13,19}\b/g },
+  {
+    kind: "payment-card",
+    regex: /\b(?:\d[ -]*?){13,19}\b/g,
+    replacement: (candidate) => passesLuhn(candidate) ? "[REDACTED:payment-card]" : candidate
+  },
   { kind: "phone", regex: /(?<![\w.])(?:\+?\d[\d ()-]{8,}\d)(?![\w.])/g }
 ];
 function redact(text, patterns) {
@@ -882,15 +1208,22 @@ function redact(text, patterns) {
   let value = text;
   for (const pattern of patterns) {
     value = value.replace(pattern.regex, (...args) => {
-      counts.set(pattern.kind, (counts.get(pattern.kind) ?? 0) + 1);
+      const match = String(args[0]);
+      let replacement = "[REDACTED:" + pattern.kind + "]";
       if (pattern.replacement) {
         const groups = args.slice(1, -2).map(String);
-        return pattern.replacement(...groups);
+        replacement = pattern.replacement(...groups, match);
       }
-      return "[REDACTED:" + pattern.kind + "]";
+      if (replacement === match)
+        return match;
+      counts.set(pattern.kind, (counts.get(pattern.kind) ?? 0) + 1);
+      return replacement;
     });
   }
-  return { value, findings: [...counts].map(([kind, count]) => ({ kind, count })) };
+  return {
+    value,
+    findings: [...counts].map(([kind, count]) => ({ kind, count }))
+  };
 }
 function mergeFindings(target, findings) {
   for (const finding of findings)
@@ -920,7 +1253,6 @@ var SECRET_KEY_NAMES = {
   set_cookie: true,
   otp: true,
   one_time_password: true,
-  pin: true,
   passcode: true
 };
 function normalizeObjectKey(key) {
@@ -986,7 +1318,7 @@ class SecretScrubber {
       const output = {};
       seen.set(value2, output);
       for (const [key, item] of Object.entries(value2)) {
-        const carriesSecret = typeof item === "string" ? item.length > 0 : item != null;
+        const carriesSecret = typeof item === "string" && item.length >= 8;
         if (this.secretsEnabled && isSecretBearingKey(key) && carriesSecret) {
           output[key] = "[REDACTED:credential]";
           recordCredential();
@@ -997,7 +1329,10 @@ class SecretScrubber {
       return output;
     };
     const value = visit(input);
-    return { value, findings: [...findings].map(([kind, count]) => ({ kind, count })) };
+    return {
+      value,
+      findings: [...findings].map(([kind, count]) => ({ kind, count }))
+    };
   }
   count() {
     return this.total;
@@ -1283,6 +1618,76 @@ 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;
+var NONE_BLOCKER_VALUE_RE = /^(?:none|no blockers?|yok)\s*(?:recorded|known)?[.!]?$/i;
+var BULLET_NONE_BLOCKER_RE = /^(?:[-*+]|\d+[.)])\s+(?:none|no blockers?|yok)\s*(?:recorded|known)?[.!]?$/i;
+var PATH_PLACEHOLDER_RE = /^(?:none|none recorded|no blockers?|yok)[.!]?$/i;
+function noneBlockerLineIndexes(lines) {
+  const indexes = new Set;
+  const nonEmpty = lines.map((line, index) => ({ index, text: line.trim() })).filter((item) => item.text);
+  for (const item of nonEmpty) {
+    if (BULLET_NONE_BLOCKER_RE.test(item.text))
+      indexes.add(item.index);
+  }
+  if (nonEmpty.length === 1 && NONE_BLOCKER_VALUE_RE.test(nonEmpty[0].text)) {
+    indexes.add(nonEmpty[0].index);
+  }
+  return indexes;
+}
+function collectListedPaths(body, expectedPaths) {
+  const values = new Set;
+  const encodedValues = new Set;
+  for (const line of body.split(`
+`)) {
+    const raw = line.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").trim();
+    if (!raw)
+      continue;
+    if (raw.startsWith('"')) {
+      try {
+        const decoded = JSON.parse(raw);
+        if (typeof decoded === "string") {
+          values.add(decoded);
+          encodedValues.add(decoded);
+          continue;
+        }
+      } catch {}
+    }
+    values.add(raw);
+    if (expectedPaths.has(raw))
+      continue;
+    const unwrapped = raw.startsWith("`") && raw.endsWith("`") ? raw.slice(1, -1) : raw;
+    const unchecked = unwrapped.replace(/^\[[ x]\]\s+/i, "");
+    if (expectedPaths.has(unchecked))
+      values.add(unchecked);
+  }
+  return {
+    values,
+    encodedValues,
+    normalizedValues: new Set(Array.from(values, normalizePath))
+  };
+}
+function decodePathDisplay(display) {
+  try {
+    const decoded = JSON.parse(display);
+    return typeof decoded === "string" ? decoded : display;
+  } catch {
+    return display;
+  }
+}
+function hasListedPath(listed, file, display, normalizedOwners) {
+  const decodedDisplay = decodePathDisplay(display);
+  if (listed.encodedValues.has(decodedDisplay))
+    return true;
+  if (PATH_PLACEHOLDER_RE.test(file))
+    return false;
+  if (listed.values.has(file))
+    return true;
+  for (const candidate of [file, decodedDisplay]) {
+    const normalized = normalizePath(candidate);
+    if (normalizedOwners.get(normalized) === 1 && listed.normalizedValues.has(normalized))
+      return true;
+  }
+  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);
 }
@@ -1301,6 +1706,28 @@ function classifyOutcomeClaim(claim) {
   return "generic";
 }
 var successfulToolEvidenceCache = new WeakMap;
+var sourceTextCache = new WeakMap;
+function sourceSupportsFileReference(ref, messages) {
+  let texts = sourceTextCache.get(messages);
+  if (!texts) {
+    texts = messages.map((message) => extractText(message.content).replace(/\\/g, "/").toLowerCase());
+    sourceTextCache.set(messages, texts);
+  }
+  const needle = ref.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+  if (!needle)
+    return false;
+  for (const text of texts) {
+    let index = text.indexOf(needle);
+    while (index >= 0) {
+      const before = text[index - 1] ?? "";
+      const after = text[index + needle.length] ?? "";
+      if ((!before || !/[\w.-]/.test(before)) && (!after || !/[\w.-]/.test(after)))
+        return true;
+      index = text.indexOf(needle, index + 1);
+    }
+  }
+  return false;
+}
 function successfulToolEvidence(messages) {
   const cached = successfulToolEvidenceCache.get(messages);
   if (cached)
@@ -1419,8 +1846,72 @@ var SEMANTIC_STOP = new Set([
   "de\u011Fil",
   "olmadan"
 ]);
+var TR_SUFFIXES = [
+  "lar\u0131",
+  "leri",
+  "\u0131n\u0131n",
+  "inin",
+  "unun",
+  "\xFCn\xFCn",
+  "\u0131nda",
+  "inde",
+  "unda",
+  "\xFCnde",
+  "m\u0131\u015F",
+  "mi\u015F",
+  "mu\u015F",
+  "m\xFC\u015F",
+  "lar",
+  "ler",
+  "\u0131n\u0131",
+  "ini",
+  "unu",
+  "\xFCn\xFC",
+  "\u0131na",
+  "ine",
+  "una",
+  "\xFCne",
+  "dan",
+  "den",
+  "tan",
+  "ten",
+  "d\u0131r",
+  "dir",
+  "dur",
+  "d\xFCr",
+  "t\u0131r",
+  "tir",
+  "tur",
+  "t\xFCr",
+  "yor",
+  "mak",
+  "mek",
+  "da",
+  "de",
+  "ta",
+  "te",
+  "d\u0131",
+  "di",
+  "du",
+  "d\xFC",
+  "t\u0131",
+  "ti",
+  "tu",
+  "t\xFC",
+  "\u0131n",
+  "in",
+  "un",
+  "\xFCn",
+  "sa",
+  "se"
+];
 function stemToken(token) {
   const lower = token.toLocaleLowerCase();
+  for (const suffix of TR_SUFFIXES) {
+    if (lower.length >= 4 + suffix.length && lower.endsWith(suffix)) {
+      return lower.slice(0, -suffix.length);
+    }
+  }
   if (lower.length > 6 && lower.endsWith("ing"))
     return lower.slice(0, -3);
   if (lower.length > 5 && lower.endsWith("ed"))
@@ -1539,11 +2030,15 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
   };
   const unresolvedEvidence = uniqueByText([
     ...extraction.errors.filter((error) => !error.resolved).map((error) => ({ message: error.message })),
-    ...(continuity?.unresolvedErrors ?? []).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 }))
+    ...(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,
@@ -1570,40 +2065,64 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
       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 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);
+    for (const candidate of [
+      file,
+      ...display ? [decodePathDisplay(display)] : []
+    ]) {
+      const normalized = normalizePath(candidate);
+      const owners = normalizedOwnerSets.get(normalized) ?? new Set;
+      owners.add(file);
+      normalizedOwnerSets.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) {
-    if (!modifiedListed.has(normalizePath(file)))
+    const display = pathEvidence.get(file);
+    if (display && !hasListedPath(modifiedListed, file, display, normalizedOwners)) {
       gaps.push({ kind: "missing-file", path: file });
+    }
   }
-  for (const file of extraction.readFiles) {
-    if (!readListed.has(normalizePath(file)))
+  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 });
+    }
   }
-  const deletedEvidence = Array.from(new Set([
-    ...extraction.deletedFiles,
-    ...continuity?.deletedFiles ?? []
-  ]));
   for (const file of deletedEvidence) {
-    if (!deletedListed.has(normalizePath(file)))
+    const display = pathEvidence.get(file);
+    if (display && !hasListedPath(deletedListed, file, display, normalizedOwners)) {
       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();
+    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;
     }
   }
   for (const error of resolvedEvidence) {
-    const snippet = summaryEvidenceLine(error.message, TRUNC.ERROR_SNIPPET).toLowerCase();
+    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 });
+      gaps.push({
+        kind: "missing-error",
+        message: error.message,
+        resolved: true
+      });
       score -= 2;
     }
   }
@@ -1618,7 +2137,10 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
       score -= 8;
     }
     if (hasSemanticContradiction(constraint.text, constraintTarget)) {
-      gaps.push({ kind: "inconsistency", detail: "semantic-contradiction: constraint contradicts " + constraint.text.slice(0, TRUNC.SNIPPET) });
+      gaps.push({
+        kind: "inconsistency",
+        detail: "semantic-contradiction: constraint contradicts " + constraint.text.slice(0, TRUNC.SNIPPET)
+      });
       score -= 20;
     }
   }
@@ -1629,32 +2151,52 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
       score -= 12;
     }
     if (hasSemanticContradiction(goalEvidence, goalTarget)) {
-      gaps.push({ kind: "inconsistency", detail: "semantic-contradiction: goal polarity or condition changed" });
+      gaps.push({
+        kind: "inconsistency",
+        detail: "semantic-contradiction: goal polarity or condition changed"
+      });
       score -= 20;
     }
   }
-  const groundedEvidenceFiles = [
+  const groundedEvidence = [
     ...unresolvedEvidence.map((item) => item.message),
+    ...resolvedEvidence.map((item) => item.message),
     ...constraintEvidence.map((item) => item.text),
     ...decisionEvidence.map((item) => item.summary),
     ...goalEvidence ? [goalEvidence] : [],
+    ...extraction.lastUserMessages,
+    ...extraction.timeline.map((item) => item.summary),
+    ...extraction.topics.map((item) => item.primaryFile ?? ""),
     ...continuity?.openLoops.map((item) => item.summary) ?? [],
     ...continuity?.criticalContext ?? []
-  ].flatMap(extractFileRefs);
-  const knownFiles = Array.from(new Set([
+  ];
+  const groundedEvidenceFiles = 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) => [
+    decodePathDisplay(line),
+    line.startsWith('"') && line.endsWith('"') ? line.slice(1, -1) : line
+  ]);
+  const rawKnownFiles = Array.from(new Set([
     ...modifiedPaths,
-    ...extraction.readFiles,
-    ...extraction.deletedFiles,
+    ...readPaths,
+    ...deletedEvidence,
     ...extraction.referencedFiles ?? [],
     ...groundedEvidenceFiles,
+    ...renderedPathEvidence,
+    ...renderedPathEvidence.flatMap(extractFileRefs),
     ...continuity?.modifiedFiles ?? [],
     ...continuity?.readFiles ?? [],
-    ...continuity?.deletedFiles ?? [],
     ...(continuity?.unresolvedErrors ?? []).flatMap((error) => error.files),
     ...(continuity?.openLoops ?? []).flatMap((loop) => loop.files)
   ]));
   for (const ref of new Set(extractFileRefs(summary))) {
-    if (!isKnownPathReference(ref, knownFiles)) {
+    const grounded = isKnownPathReference(ref, rawKnownFiles) || Boolean(evidence.sourceMessages && sourceSupportsFileReference(ref, evidence.sourceMessages));
+    if (!grounded) {
       gaps.push({ kind: "fabricated-file", ref });
       score -= 4;
     }
@@ -1663,8 +2205,12 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
   if (progressSection) {
     const doneSection = progressSection.body.match(/###\s*Done[\s\S]*?(?=###|$)/i)?.[0] ?? "";
     const blockedSection = progressSection.body.match(/###\s*Blocked[\s\S]*?(?=###|$)/i)?.[0] ?? "";
-    if (unresolvedEvidence.length > 0 && /(?:none|no blockers?|yok)\s*(?:recorded|known)?[.!]?\s*$/im.test(blockedSection)) {
-      gaps.push({ kind: "inconsistency", detail: "blocked-none: Blocked says none despite unresolved errors" });
+    const blockedLines = blockedSection.split(/\r?\n/).slice(1);
+    if (unresolvedEvidence.length > 0 && noneBlockerLineIndexes(blockedLines).size > 0) {
+      gaps.push({
+        kind: "inconsistency",
+        detail: "blocked-none: Blocked says none despite unresolved errors"
+      });
       score -= 12;
     }
     const doneRefs = new Set(extractFileRefs(doneSection).map(normalizePath));
@@ -1678,7 +2224,10 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
         return uniqueNeedles.some((needle) => errorRefs.includes(normalizePath(needle)));
       });
       if (unresolved) {
-        gaps.push({ kind: "inconsistency", detail: file.path + " marked Done but has unresolved error" });
+        gaps.push({
+          kind: "inconsistency",
+          detail: file.path + " marked Done but has unresolved error"
+        });
         score -= 5;
       }
     }
@@ -1690,7 +2239,10 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
       score -= 8;
     }
     if (hasSemanticContradiction(decision.summary, decisionBody)) {
-      gaps.push({ kind: "inconsistency", detail: "semantic-contradiction: decision contradicts " + decision.summary.slice(0, TRUNC.SNIPPET) });
+      gaps.push({
+        kind: "inconsistency",
+        detail: "semantic-contradiction: decision contradicts " + decision.summary.slice(0, TRUNC.SNIPPET)
+      });
       score -= 20;
     }
   }