pi-smart-compact 9.2.1 → 9.3.0

package/dist/index.js

@@ -7,7 +7,7 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { Type as Type2 } from "typebox";
 
 // src/constants.ts
-var VERSION = "9.2.1";
+var VERSION = "9.3.0";
 var CHARS_PER_TOKEN = 3.8;
 var MIN_COMPACTION_SAVING_RATIO = 0.1;
 var ESTIMATOR_ROUNDING_TOLERANCE_TOKENS = 1;
@@ -1131,10 +1131,22 @@ 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((path3) => {
-    const normalizedPath = normalizePath(path3);
-    return normalizedPath === normalizedRef || normalizedPath.endsWith("/" + normalizedRef);
+    const normalizedPath = normalizePath(path3).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 + "/"));
   });
 }
 
@@ -1407,10 +1419,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();
@@ -1483,6 +1505,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((path3) => [path3, summaryPathLine(path3)]);
+  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 path3 of unique) {
+    const fullDigest = createHash("sha256").update(path3).digest("base64url");
+    let digest = fullDigest.slice(0, 12);
+    const owner = owners.get(digest);
+    if (owner && owner !== path3) {
+      digest = fullDigest;
+      digests.set(owner, createHash("sha256").update(owner).digest("base64url"));
+    }
+    owners.set(digest, path3);
+    digests.set(path3, digest);
+  }
+  const perPath = Math.max(JSON.stringify("#" + "x".repeat(12)).length, Math.floor((budgetChars - unique.length * 3) / unique.length));
+  return new Map(unique.map((path3) => [
+    path3,
+    compactPathLine(path3, perPath, digests.get(path3) ?? "")
+  ]));
+}
 function mergeBodies(first, second) {
   const seen = new Set;
   return [first, second].filter(Boolean).flatMap((body) => body.split(`
@@ -1507,7 +1581,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,})(.*)$/);
@@ -1674,7 +1752,14 @@ function extractMediaAttachments(msgs) {
       const source = typeof rec.url === "string" ? "url" : typeof rec.path === "string" ? "path" : typeof rec.data === "string" || typeof rec.base64 === "string" ? "inline" : undefined;
       const kind = mediaKind(type, mimeType);
       if (kind !== "unknown" || source || mimeType || name) {
-        out.push({ index: i, kind, mimeType, name, sizeBytes: typeof sizeBytes === "number" ? sizeBytes : undefined, source });
+        out.push({
+          index: i,
+          kind,
+          mimeType,
+          name,
+          sizeBytes: typeof sizeBytes === "number" ? sizeBytes : undefined,
+          source
+        });
       }
     }
   }
@@ -1698,7 +1783,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
+          });
         }
       }
     }
@@ -1729,7 +1818,10 @@ function trackFileOps(msgs, _tcIdx) {
       const shell = extractShellFileOperations(tc.arguments);
       for (const file of shell.modified) {
         const existing = modMap.get(file);
-        modMap.set(file, { toolCalls: (existing?.toolCalls ?? 0) + 1, lastIdx: i });
+        modMap.set(file, {
+          toolCalls: (existing?.toolCalls ?? 0) + 1,
+          lastIdx: i
+        });
         deletedAt.delete(file);
       }
       for (const file of shell.deleted) {
@@ -1746,7 +1838,10 @@ function trackFileOps(msgs, _tcIdx) {
       const resultText = extractText(m.content);
       if (isTruncated(resultText) || !NO_OP_RE.test(resultText)) {
         const existing = modMap.get(filePath);
-        modMap.set(filePath, { toolCalls: (existing?.toolCalls ?? 0) + 1, lastIdx: i });
+        modMap.set(filePath, {
+          toolCalls: (existing?.toolCalls ?? 0) + 1,
+          lastIdx: i
+        });
         deletedAt.delete(filePath);
       }
     } else if (operation === "delete") {
@@ -1759,7 +1854,11 @@ function trackFileOps(msgs, _tcIdx) {
     }
   }
   return {
-    modified: [...modMap.entries()].map(([p, d]) => ({ path: p, toolCalls: d.toolCalls, lastModifiedIndex: d.lastIdx })),
+    modified: [...modMap.entries()].map(([p, d]) => ({
+      path: p,
+      toolCalls: d.toolCalls,
+      lastModifiedIndex: d.lastIdx
+    })),
     read: [...readAt.entries()].sort((a, b) => a[1] - b[1]).map(([file]) => file),
     deleted: [...deletedAt.entries()].sort((a, b) => a[1] - b[1]).map(([file]) => file),
     referenced: [...referencedAt.entries()].sort((a, b) => a[1] - b[1]).map(([file]) => file)
@@ -1851,10 +1950,10 @@ function catalogErrors(msgs, _tcIdx) {
         const result = msgs[k];
         if (result?.role !== "toolResult" || result.isError)
           continue;
-        const resolved = retryTool.id != null ? result.toolCallId === retryTool.id : (() => {
+        const resolved = retryTool.id == null ? (() => {
           const resultCall = tcIdx.get(result.toolCallId ?? "");
           return Boolean(resultCall && sameToolOperation(retryTool, resultCall));
-        })();
+        })() : result.toolCallId === retryTool.id;
         if (resolved) {
           err.resolved = true;
           break;
@@ -1877,7 +1976,12 @@ function extractDecisions(msgs, _tcIdx) {
       continue;
     for (let i = tc.msgIndex + 1;i < Math.min(msgs.length, tc.msgIndex + 4); i++) {
       if (msgs[i]?.role === "toolResult" && msgs[i]?.toolCallId === id) {
-        decisions.push({ index: tc.msgIndex, type: "explicit", summary: question.slice(0, TRUNC.DECISION_SUMMARY), userResponse: extractText(msgs[i].content).slice(0, TRUNC.USER_RESPONSE) });
+        decisions.push({
+          index: tc.msgIndex,
+          type: "explicit",
+          summary: question.slice(0, TRUNC.DECISION_SUMMARY),
+          userResponse: extractText(msgs[i].content).slice(0, TRUNC.USER_RESPONSE)
+        });
         break;
       }
     }
@@ -1887,18 +1991,46 @@ function extractDecisions(msgs, _tcIdx) {
       continue;
     const txt = extractText(msgs[i].content);
     if (CHOICE_RE.test(txt)) {
-      decisions.push({ index: i, type: "implicit", summary: txt.slice(0, TRUNC.DECISION_SUMMARY) });
+      decisions.push({
+        index: i,
+        type: "implicit",
+        summary: txt.slice(0, TRUNC.DECISION_SUMMARY)
+      });
     }
   }
   return decisions;
 }
 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();
@@ -1923,7 +2055,12 @@ function mineConstraints(msgs) {
         const normalized = candidate.toLowerCase().replace(/\s+/g, " ");
         if (!seen.has(normalized)) {
           seen.add(normalized);
-          constraints.push({ index: i, text: candidate.slice(0, TRUNC.CONSTRAINT_TEXT), category: cat, confidence: conf });
+          constraints.push({
+            index: i,
+            text: candidate.slice(0, TRUNC.CONSTRAINT_TEXT),
+            category: cat,
+            confidence: conf
+          });
         }
         break;
       }
@@ -1932,6 +2069,12 @@ function mineConstraints(msgs) {
   return constraints;
 }
 function segmentTopicsHeuristic(msgs, pc, maxSegs = 20, _tcIdx) {
+  const shiftBasename = (filePath) => {
+    if (!filePath)
+      return null;
+    const base = path3.basename(filePath);
+    return GENERIC_BASENAMES.has(base.toLowerCase()) ? null : base;
+  };
   const topics = [];
   let startIdx = 0, tokenAcc = 0, lastFile = null, errAcc = 0;
   let currentType = "exploration";
@@ -1943,7 +2086,7 @@ function segmentTopicsHeuristic(msgs, pc, maxSegs = 20, _tcIdx) {
     const messageTokens = estimateTokens(text);
     const tools = message.role === "assistant" ? (Array.isArray(message.content) ? message.content : []).flatMap(flattenToolCallBlock) : [];
     const nextFile = tools.map((tool) => extractToolPath(tool.arguments)).find((value) => Boolean(value));
-    const nextBasename = nextFile ? path3.basename(nextFile) : null;
+    const nextBasename = shiftBasename(nextFile);
     const closesActiveTool = message.role === "toolResult" && (tcIdx.get(message.toolCallId ?? "")?.msgIndex ?? -1) >= startIdx;
     const fileShift = Boolean(lastFile && nextBasename && nextBasename !== lastFile);
     const userShift = message.role === "user" && SHIFT_RE.test(text);
@@ -1968,7 +2111,7 @@ function segmentTopicsHeuristic(msgs, pc, maxSegs = 20, _tcIdx) {
     for (const tool of tools) {
       const filePath = extractToolPath(tool.arguments);
       if (filePath) {
-        lastFile = path3.basename(filePath);
+        lastFile = shiftBasename(filePath) ?? lastFile;
         currentPrimaryFile = filePath;
       }
       const operation = classifyToolOperation(tool.arguments, tool.name);
@@ -1991,7 +2134,13 @@ function segmentTopicsHeuristic(msgs, pc, maxSegs = 20, _tcIdx) {
     }
   }
   if (startIdx < msgs.length) {
-    topics.push({ startIndex: startIdx, endIndex: msgs.length - 1, primaryFile: currentPrimaryFile, type: currentType, errorDensity: errAcc });
+    topics.push({
+      startIndex: startIdx,
+      endIndex: msgs.length - 1,
+      primaryFile: currentPrimaryFile,
+      type: currentType,
+      errorDensity: errAcc
+    });
   }
   return topics;
 }
@@ -2003,10 +2152,18 @@ function buildTimeline(msgs, errors) {
     if (m.role === "user") {
       const txt = extractText(m.content);
       if (!txt.startsWith("/"))
-        timeline.push({ index: i, event: "user_request", summary: txt.slice(0, TRUNC.TIMELINE_EVENT) });
+        timeline.push({
+          index: i,
+          event: "user_request",
+          summary: txt.slice(0, TRUNC.TIMELINE_EVENT)
+        });
     }
     if (errorIndices.has(i))
-      timeline.push({ index: i, event: "error", summary: errors.find((e) => e.index === i)?.message.slice(0, TRUNC.TIMELINE_ERROR) ?? "error" });
+      timeline.push({
+        index: i,
+        event: "error",
+        summary: errors.find((e) => e.index === i)?.message.slice(0, TRUNC.TIMELINE_ERROR) ?? "error"
+      });
   }
   return timeline.length > 30 ? [
     ...timeline.filter((t) => t.event === "user_request").slice(-TRUNC.TIMELINE_DISPLAY),
@@ -2080,6 +2237,13 @@ function extractOpenLoops(msgs, extraction) {
       sourceIndex: err.index
     });
   }
+  const isNearbyDuplicate = (existing, text, index) => {
+    if (Math.abs((existing.sourceIndex ?? 0) - index) >= 5)
+      return false;
+    const existingKey = normalizeFactKey(existing.summary);
+    const textKey = normalizeFactKey(text);
+    return existingKey === textKey || existingKey.includes(textKey) || textKey.includes(existingKey);
+  };
   const FOLLOWUP_RE = /(?:next\s+(?:step|thing)|todo|action item|follow\s*up|still (?:need|have) to|gotta|yapalim|yapal\u0131m|yapmamiz|yapmam\u0131z|gerekiyor|eklenecek|d\u00FCzeltilecek|duzeltilecek|bitmedi|kaldi|kald\u0131)/iu;
   for (let idx = 0;idx < msgs.length; idx++) {
     const msg = msgs[idx];
@@ -2089,7 +2253,7 @@ function extractOpenLoops(msgs, extraction) {
     if (txt.length < 10 || txt.startsWith("/"))
       continue;
     if (FOLLOWUP_RE.test(txt)) {
-      const isDup = loops.some((l) => Math.abs((l.sourceIndex ?? 0) - idx) < 5);
+      const isDup = loops.some((l) => isNearbyDuplicate(l, txt, idx));
       if (!isDup) {
         loops.push({
           id: ID_PREFIX.OPEN_LOOP + ++loopId,
@@ -2112,7 +2276,7 @@ function extractOpenLoops(msgs, extraction) {
     if (txt.length < 10 || txt.startsWith("/"))
       continue;
     if (BLOCKED_RE.test(txt)) {
-      const isDup = loops.some((l) => Math.abs((l.sourceIndex ?? 0) - idx) < 5);
+      const isDup = loops.some((l) => isNearbyDuplicate(l, txt, idx));
       if (!isDup) {
         loops.push({
           id: ID_PREFIX.OPEN_LOOP + ++loopId,
@@ -2126,20 +2290,6 @@ function extractOpenLoops(msgs, extraction) {
       }
     }
   }
-  for (const err of extraction.errors.filter((e) => e.retryAttempted && !e.resolved)) {
-    const exists = loops.some((l) => l.type === "bugfix" && l.sourceIndex === err.index);
-    if (!exists) {
-      loops.push({
-        id: ID_PREFIX.OPEN_LOOP + ++loopId,
-        type: "retry",
-        priority: "high",
-        status: "open",
-        summary: "Retried but unresolved: " + err.message.slice(0, TRUNC.SNIPPET),
-        files: [],
-        sourceIndex: err.index
-      });
-    }
-  }
   for (const loop of loops) {
     if (loop.type !== "follow-up" || loop.sourceIndex == null)
       continue;
@@ -2149,8 +2299,12 @@ function extractOpenLoops(msgs, extraction) {
     const end = Math.min(msgs.length, loop.sourceIndex + 50);
     for (let index = loop.sourceIndex + 1;index < end; index++) {
       const message = msgs[index];
-      if (message?.role === "user")
+      if (message?.role === "user") {
+        const turn = extractText(message.content);
+        if (turn.length < 10 || ACK_ONLY_RE.test(turn))
+          continue;
         break;
+      }
       if (message?.role !== "assistant")
         continue;
       const response = extractText(message.content);
@@ -3065,7 +3219,10 @@ function withCodexWireLimit(model, 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;
+      return body && typeof body === "object" ? {
+        ...body,
+        max_output_tokens: opts.maxTokens
+      } : body;
     }
   };
 }
@@ -3086,11 +3243,12 @@ function assertSuccessful(message) {
   }
   return message;
 }
-async function withProviderDeadline(opts, invoke) {
+async function withProviderDeadline(opts, invoke, modelId) {
   if (opts.signal?.aborted)
     throw new Error("LLM request aborted before dispatch");
   const controller = new AbortController;
-  const watchdogMs = resolveCodexWatchdogMs(opts.maxTokens, opts.codexWatchdogMs);
+  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);
@@ -3163,7 +3321,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);
   }
 };
 var defaultLlmClient = rawLlmClient;
@@ -3177,7 +3335,10 @@ import crypto4 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 },
@@ -3186,8 +3347,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,
@@ -3196,12 +3364,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) {
@@ -3209,15 +3400,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)
@@ -3247,7 +3445,6 @@ var SECRET_KEY_NAMES = {
   set_cookie: true,
   otp: true,
   one_time_password: true,
-  pin: true,
   passcode: true
 };
 function normalizeObjectKey(key) {
@@ -3313,7 +3510,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();
@@ -3324,7 +3521,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;
@@ -4772,7 +4972,7 @@ function writeMetricsDashboard(entries = readMetricsLog(200), damageEntries = re
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/app/session-run-lock.ts
-import { createHash, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
 import fs5 from "fs";
 import path6 from "path";
 function processAlive(pid) {
@@ -4898,7 +5098,7 @@ function createSessionRunLock(maxConcurrent = 2, options = {}) {
         return true;
       }
       try {
-        const sessionHash = createHash("sha256").update(sessionId).digest("hex").slice(0, 24);
+        const sessionHash = createHash2("sha256").update(sessionId).digest("hex").slice(0, 24);
         const session = acquireFileLease(path6.join(leaseDir, "session-" + sessionHash + ".lock"), staleMs);
         if (!session)
           return false;
@@ -5937,7 +6137,15 @@ function sanitizeCompactionStateEvidence(state) {
   const criticalContext = state.criticalContext.filter((item) => !isNoise(item));
   if (goal === state.goal && constraints.length === state.constraints.length && unresolvedErrors.length === state.unresolvedErrors.length && resolvedErrors.length === state.resolvedErrors.length && openLoops.length === state.openLoops.length && criticalContext.length === state.criticalContext.length)
     return state;
-  return { ...state, goal, constraints, unresolvedErrors, resolvedErrors, openLoops, criticalContext };
+  return {
+    ...state,
+    goal,
+    constraints,
+    unresolvedErrors,
+    resolvedErrors,
+    openLoops,
+    criticalContext
+  };
 }
 function freshState(fp, data) {
   if (!data)
@@ -6040,7 +6248,12 @@ function applyLoopOverrides(loops, overrides) {
 function upsertLoopOverride(overrides, loop, patch) {
   const summaryKey = normalizeFactKey(loop.summary);
   const index = overrides.findIndex((override) => override.summaryKey === summaryKey);
-  const next = { ...index >= 0 ? overrides[index] : { id: loop.id, summaryKey }, ...patch, id: loop.id, summaryKey };
+  const next = {
+    ...index >= 0 ? overrides[index] : { id: loop.id, summaryKey },
+    ...patch,
+    id: loop.id,
+    summaryKey
+  };
   if (index < 0)
     return [...overrides, next];
   const copy = overrides.slice();
@@ -6065,7 +6278,10 @@ function buildCompactionState(extraction, openLoops, report, nextActions, critic
   let decisionId = 0;
   let constraintId = 0;
   let errorId = 0;
-  const fileNeedles = extraction.modifiedFiles.map((f) => ({ path: f.path, needles: buildPathNeedles(f.path) }));
+  const fileNeedles = extraction.modifiedFiles.map((f) => ({
+    path: f.path,
+    needles: buildPathNeedles(f.path)
+  }));
   return {
     goal: extraction.mainGoal,
     goalKey: extraction.mainGoal ? normalizeFactKey(extraction.mainGoal) : undefined,
@@ -6123,9 +6339,17 @@ function mergeBy(current, previous, key, limit) {
     return true;
   }).slice(0, limit);
 }
-var LOOP_PRIORITY = { critical: 0, high: 1, normal: 2, low: 3 };
+var LOOP_PRIORITY = {
+  critical: 0,
+  high: 1,
+  normal: 2,
+  low: 3
+};
 function mergeOpenLoops(current, previous) {
-  return mergeBy(current, previous, (item) => normalizeFactKey(item.summary), Number.MAX_SAFE_INTEGER).map((item, order) => ({ item, order })).sort((a, b) => Number(a.item.status === "resolved") - Number(b.item.status === "resolved") || LOOP_PRIORITY[a.item.priority] - LOOP_PRIORITY[b.item.priority] || a.order - b.order).slice(0, MAX_STATE_OPEN_LOOPS).map(({ item }, index) => ({ ...item, id: ID_PREFIX.OPEN_LOOP + (index + 1) }));
+  return mergeBy(current, previous, (item) => normalizeFactKey(item.summary), Number.MAX_SAFE_INTEGER).map((item, order) => ({ item, order })).sort((a, b) => Number(a.item.status === "resolved") - Number(b.item.status === "resolved") || LOOP_PRIORITY[a.item.priority] - LOOP_PRIORITY[b.item.priority] || a.order - b.order).slice(0, MAX_STATE_OPEN_LOOPS).map(({ item }, index) => ({
+    ...item,
+    id: ID_PREFIX.OPEN_LOOP + (index + 1)
+  }));
 }
 function mergeCompactionStates(previous, current) {
   if (!previous) {
@@ -6138,13 +6362,27 @@ function mergeCompactionStates(previous, current) {
   const currentPresent = new Set([...activeCurrent.modifiedFiles, ...activeCurrent.readFiles].map(normalizeFactKey));
   const currentDeleted = new Set(activeCurrent.deletedFiles.map(normalizeFactKey));
   const resolvedKeys = new Set(activeCurrent.resolvedErrors.map((error2) => normalizeFactKey(error2.message)));
+  const isResolvedLoop = (loop) => {
+    if (loop.type !== "bugfix" || loop.status !== "open")
+      return false;
+    const summaryKey = normalizeFactKey(loop.summary);
+    if (summaryKey.length < 16)
+      return false;
+    for (const key of resolvedKeys) {
+      if (key === summaryKey || key.length > summaryKey.length && key.startsWith(summaryKey))
+        return true;
+    }
+    return false;
+  };
   const decisions = mergeBy(activeCurrent.decisions, activePrevious.decisions, (item) => normalizeFactKey(item.summary), 30).map((item, index) => ({ ...item, id: ID_PREFIX.DECISION + (index + 1) }));
   const constraints = mergeBy(activeCurrent.constraints, activePrevious.constraints, (item) => normalizeFactKey(item.text), 30).map((item, index) => ({ ...item, id: "constraint-" + (index + 1) }));
   const unresolvedErrors = mergeBy(activeCurrent.unresolvedErrors, activePrevious.unresolvedErrors.filter((error2) => !resolvedKeys.has(normalizeFactKey(error2.message))), (item) => normalizeFactKey(item.message), 15).map((item, index) => ({ ...item, id: ID_PREFIX.ERROR + (index + 1) }));
-  const openLoops = mergeOpenLoops(activeCurrent.openLoops, activePrevious.openLoops);
+  const openLoops = mergeOpenLoops(activeCurrent.openLoops, activePrevious.openLoops.map((loop) => isResolvedLoop(loop) ? { ...loop, status: "resolved" } : loop));
   const currentGoalKey = activeCurrent.goalKey ?? (activeCurrent.goal ? normalizeFactKey(activeCurrent.goal) : "");
   const previousGoalKey = activePrevious.goalKey ?? (activePrevious.goal ? normalizeFactKey(activePrevious.goal) : "");
-  const oldGoal = previousGoalKey && currentGoalKey && previousGoalKey !== currentGoalKey ? ["Previous goal: " + activePrevious.goal] : [];
+  const PREV_GOAL_PREFIX = "Previous goal: ";
+  const durablePreviousContext = activePrevious.criticalContext.filter((line) => !line.startsWith(PREV_GOAL_PREFIX));
+  const oldGoal = previousGoalKey && currentGoalKey && previousGoalKey !== currentGoalKey ? [PREV_GOAL_PREFIX + activePrevious.goal] : [];
   return applyContinuityOverrides({
     ...activeCurrent,
     goal: activeCurrent.goal ?? activePrevious.goal,
@@ -6161,7 +6399,7 @@ function mergeCompactionStates(previous, current) {
     factOverrides,
     topics: mergeBy(activeCurrent.topics, activePrevious.topics, (item) => normalizeFactKey(item.title), 30),
     nextActions: mergeBy(activeCurrent.nextActions, activePrevious.nextActions, normalizeFactKey, 15),
-    criticalContext: mergeBy([...oldGoal, ...activeCurrent.criticalContext], activePrevious.criticalContext, normalizeFactKey, 20),
+    criticalContext: mergeBy([...oldGoal, ...activeCurrent.criticalContext], durablePreviousContext, normalizeFactKey, 20),
     updatedAt: Date.now()
   }, factOverrides);
 }
@@ -7555,7 +7793,11 @@ function extractWithCache(rc) {
         return convText;
       const safeMessages = scrubLlmMessages(selectedMessages, rc.services.scrubber);
       const backupText = serializeConversation(asSerializableMessages(safeMessages));
-      return rc.services.scrubber.scrubText(backupText).value;
+      const scrubbed = rc.services.scrubber.scrubText(backupText);
+      if (scrubbed.findings.length > 0) {
+        rc.notify("Backup written with redactions (" + scrubbed.findings.map((f) => f.count + "x " + f.kind).join(", ") + ") \u2014 restore will lack that data", "info");
+      }
+      return scrubbed.value;
     };
     preparedBackup = prepareConversationBackup(materializeBackup, rc.sessionId, {
       branchLeafId: branchEntryIds(rc.branch).at(-1),
@@ -7583,7 +7825,7 @@ function extractWithCache(rc) {
       cacheUsable = branchPrefixMatch && prunedPrefixMatch && boundedCacheShape && cachedExt.messageCount === keptCount && cachedExt.messageCount <= rc.llmMessages.length;
       cacheExact = cacheUsable && cachedExt.messageCount === rc.llmMessages.length;
       if (!cacheUsable) {
-        missReason = !branchPrefixMatch ? "entry-prefix-mismatch" : !prunedPrefixMatch ? "pruned-prefix-changed" : !boundedCacheShape ? "cache-evidence-unbounded" : cachedExt.messageCount !== keptCount ? "cache-shape-mismatch" : "cache-domain-ahead";
+        missReason = branchPrefixMatch ? prunedPrefixMatch ? boundedCacheShape ? cachedExt.messageCount === keptCount ? "cache-domain-ahead" : "cache-shape-mismatch" : "cache-evidence-unbounded" : "pruned-prefix-changed" : "entry-prefix-mismatch";
       }
     } else {
       missReason = "legacy-no-kept-entryids";
@@ -8149,13 +8391,13 @@ Output ONLY JSON: {"mainGoal":"...","sessionType":"implementation|review|debuggi
 }
 
 // src/infra/synthesis-cache.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var cache = new Map;
 var batchCache = new Map;
 var TTL_MS = 10 * 60000;
 var MAX_ENTRIES = 16;
 function fingerprint(value) {
-  return createHash2("sha256").update(value ?? "").digest("hex");
+  return createHash3("sha256").update(value ?? "").digest("hex");
 }
 function cloneExplorationReport(report) {
   if (!report)
@@ -8219,7 +8461,7 @@ function synthesisCacheKey(rc) {
     userNote: rc.userNote,
     zeroCall: rc.config.zeroCallEnabled !== false
   });
-  return createHash2("sha256").update(payload).digest("hex");
+  return createHash3("sha256").update(payload).digest("hex");
 }
 function getCachedSynthesis(key, now = Date.now()) {
   const entry = cache.get(key);
@@ -8244,7 +8486,7 @@ function setCachedSynthesis(key, value, now = Date.now()) {
   cache.set(key, { value: cloneSynthesis(value), createdAt: now });
 }
 function batchCacheKey(value) {
-  return createHash2("sha256").update(VERSION + `
+  return createHash3("sha256").update(VERSION + `
 ` + JSON.stringify(value)).digest("hex");
 }
 function getCachedBatch(key, now = Date.now()) {
@@ -8309,9 +8551,12 @@ function fitChunkBudget(messages, maxTokens, estimator) {
       const head = Math.max(8, Math.floor(target * 0.6));
       const tail = Math.max(4, target - head);
       changed = true;
-      return { ...message, content: text.slice(0, head) + `
+      return {
+        ...message,
+        content: text.slice(0, head) + `
 [\u2026tool evidence bounded for synthesis\u2026]
-` + text.slice(-tail) };
+` + text.slice(-tail)
+      };
     });
     if (!changed)
       break;
@@ -8326,12 +8571,14 @@ function fitChunkBudget(messages, maxTokens, estimator) {
     if (chars <= 0)
       return [{ role: "user", content: marker }];
     const head = Math.ceil(chars * 0.6);
-    return [{
-      role: "user",
-      content: rendered.slice(0, head) + `
+    return [
+      {
+        role: "user",
+        content: rendered.slice(0, head) + `
 ` + marker + `
 ` + rendered.slice(-(chars - head))
-    }];
+      }
+    ];
   };
   let best = candidate(0);
   if (estimateChunkTokens(best, estimator) > maxTokens) {
@@ -8410,7 +8657,10 @@ function splitOversizedChunk(ch, maxTokens, estimator) {
     });
     start = end;
   }
-  return parts.map((part, index) => ({ ...part, topic: ch.topic + " (part " + (index + 1) + "/" + parts.length + ")" }));
+  return parts.map((part, index) => ({
+    ...part,
+    topic: ch.topic + " (part " + (index + 1) + "/" + parts.length + ")"
+  }));
 }
 function chunkLlmMessages(msgs, boundaries, pc, estimator = makeTokenEstimator(), focus) {
   if (!msgs.length)
@@ -8506,10 +8756,23 @@ Preserve extra detail about: ` + focus + `
   const resp = await trackedComplete("single-pass", model, {
     systemPrompt: COMPACT_SYSTEM_PREFIX,
     messages: [
-      { role: "user", content: [{ type: "text", text: adaptedPrefix }], timestamp: Date.now() },
-      { role: "user", content: [{ type: "text", text: dynamicSuffix }], timestamp: Date.now() }
+      {
+        role: "user",
+        content: [{ type: "text", text: adaptedPrefix }],
+        timestamp: Date.now()
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: dynamicSuffix }],
+        timestamp: Date.now()
+      }
     ]
-  }, { apiKey: auth.apiKey, headers: auth.headers, maxTokens: Math.min(budgetTokens, getProviderCaps(model.provider).maxOutputTokens), signal }, services);
+  }, {
+    apiKey: auth.apiKey,
+    headers: auth.headers,
+    maxTokens: Math.min(budgetTokens, getProviderCaps(model.provider).maxOutputTokens),
+    signal
+  }, services);
   const summary = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `).trim();
   if (!summary.startsWith("##"))
@@ -8517,7 +8780,10 @@ Preserve extra detail about: ` + focus + `
   return { summary, llmCalls: 1 };
 }
 async function summarizeBatch(batch, extraction, model, auth, signal, services, maxOutputTokens, cacheScope) {
-  const range = { start: batch[0].startIndex, end: batch[batch.length - 1].endIndex };
+  const range = {
+    start: batch[0].startIndex,
+    end: batch[batch.length - 1].endIndex
+  };
   const extractionCtx = buildExtractionContext(extraction, range);
   const activeDecisions = extraction.decisions.filter((d) => d.index < range.start).map((d) => "- " + d.summary.slice(0, TRUNC.OPEN_LOOP_SUMMARY) + (d.userResponse ? " \u2192 " + d.userResponse.slice(0, TRUNC.DECISION_DETAIL) : ""));
   const decisionCtx = activeDecisions.length ? `
@@ -8548,8 +8814,16 @@ async function summarizeBatch(batch, extraction, model, auth, signal, services,
   const resp = await trackedComplete("batch", model, {
     systemPrompt: COMPACT_SYSTEM_PREFIX,
     messages: [
-      { role: "user", content: [{ type: "text", text: promptPrefix }], timestamp: Date.now() },
-      { role: "user", content: [{ type: "text", text: dynamicSuffix }], timestamp: Date.now() }
+      {
+        role: "user",
+        content: [{ type: "text", text: promptPrefix }],
+        timestamp: Date.now()
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: dynamicSuffix }],
+        timestamp: Date.now()
+      }
     ]
   }, {
     apiKey: auth.apiKey,
@@ -8600,29 +8874,56 @@ async function summarizeBatch(batch, extraction, model, auth, signal, services,
     setCachedBatch(cacheKey, result);
   return result;
 }
-async function assembleLLM(summaries, extraction, report, model, auth, budget, prevContext, signal, services, focus) {
+function deterministicFileEvidence(extraction, budgetTokens, continuity = null) {
+  const modifiedPaths = extraction.modifiedFiles.map((file) => file.path);
+  const readPaths = extraction.readFiles;
+  const deletedPaths = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
+  const evidence = buildSummaryPathEvidence([...modifiedPaths, ...readPaths, ...deletedPaths], budgetTokens);
+  return {
+    modified: modifiedPaths.map((path12) => evidence.get(path12)).filter((path12) => Boolean(path12)),
+    read: readPaths.map((path12) => evidence.get(path12)).filter((path12) => Boolean(path12)),
+    deleted: deletedPaths.map((path12) => evidence.get(path12)).filter((path12) => Boolean(path12))
+  };
+}
+async function assembleLLM(summaries, extraction, report, model, auth, budget, prevContext, signal, services, focus, continuity = null) {
   const pp = preProcessSummaries(summaries, budget, focus);
-  const detModified = extraction.modifiedFiles.map((f) => f.path);
-  const detRead = extraction.readFiles;
-  const detDeleted = extraction.deletedFiles;
+  const files = deterministicFileEvidence(extraction, budget, continuity);
+  const detModified = files.modified;
+  const detRead = files.read;
+  const detDeleted = files.deleted;
   const explorationCtx = report ? buildExplorationContext(report) : "";
   const dynamicSuffix = ASSEMBLY_PROMPT_SUFFIX.replace("{DECISIONS}", pp.decisions.join("; ") || "None").replace("{MODIFIED}", detModified.join(", ") || "None").replace("{READ}", detRead.join(", ") || "None").replace("{DELETED}", detDeleted.join(", ") || "None").replace("{EXPLORATION_CONTEXT}", explorationCtx).replace("{PREV_CONTEXT}", prevContext).replace("{SUMMARIES}", pp.text);
   const resp = await trackedComplete("assemble", model, {
     systemPrompt: COMPACT_SYSTEM_PREFIX,
     messages: [
-      { role: "user", content: [{ type: "text", text: ASSEMBLY_PROMPT_PREFIX }], timestamp: Date.now() },
-      { role: "user", content: [{ type: "text", text: dynamicSuffix }], timestamp: Date.now() }
+      {
+        role: "user",
+        content: [{ type: "text", text: ASSEMBLY_PROMPT_PREFIX }],
+        timestamp: Date.now()
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: dynamicSuffix }],
+        timestamp: Date.now()
+      }
     ]
-  }, { apiKey: auth.apiKey, headers: auth.headers, maxTokens: Math.min(budget, getProviderCaps(model.provider).maxOutputTokens), signal }, services);
+  }, {
+    apiKey: auth.apiKey,
+    headers: auth.headers,
+    maxTokens: Math.min(budget, getProviderCaps(model.provider).maxOutputTokens),
+    signal
+  }, services);
   return resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
 `).trim();
 }
-function assembleFallback(summaries, extraction, steering = {}) {
+function assembleFallback(summaries, extraction, steering = {}, budgetTokens = 6000, continuity = null) {
   const safe = (value, max = TRUNC.PREVIEW_MID) => summaryEvidenceLine(value, max);
-  const detModified = extraction.modifiedFiles.map((f) => safe(f.path)).filter(Boolean);
-  const detRead = extraction.readFiles.map((file) => safe(file)).filter(Boolean);
-  const detDeleted = extraction.deletedFiles.map((file) => safe(file)).filter(Boolean);
+  const files = deterministicFileEvidence(extraction, budgetTokens, continuity);
+  const detModified = files.modified;
+  const detRead = files.read;
+  const detDeleted = files.deleted;
   const unresolved = extraction.errors.filter((error2) => !error2.resolved).map((error2) => safe(error2.message, TRUNC.PREVIEW)).filter(Boolean);
+  const resolved = extraction.errors.filter((error2) => error2.resolved).slice(-5).map((error2) => safe(error2.message, TRUNC.PREVIEW)).filter(Boolean);
   const constraints = extraction.constraints.map((item) => "- [" + item.category + "] " + safe(item.text)).filter((line) => !line.endsWith("] "));
   if (steering.focus?.trim())
     constraints.push("- [focus] Preserve detail about: " + safe(steering.focus, TRUNC.CONSTRAINT_TEXT));
@@ -8637,12 +8938,13 @@ function assembleFallback(summaries, extraction, steering = {}) {
   if (!inProgress.length) {
     inProgress.push(...extraction.lastUserMessages.slice(-3).map((message) => safe(message, TRUNC.PREVIEW)).filter(Boolean).map((message) => "- [ ] " + message));
   }
-  inProgress.push(...detModified.map((file) => "- [ ] Continue work in " + file));
+  inProgress.push(...detModified.slice(-5).map((file) => "- [ ] Continue work in " + file));
   const next = safe(extraction.lastUserMessages.at(-1) ?? extraction.timeline.at(-1)?.summary ?? "", TRUNC.PREVIEW) || "Continue from the latest preserved context.";
   const goal = safe(extraction.mainGoal ?? "", TRUNC.DETAIL) || "Continue the current task.";
   const overflow = Object.entries(extraction.evidenceOverflow ?? {}).filter(([, count]) => typeof count === "number" && count > 0).map(([kind, count]) => "- Safety bound omitted " + count + " older " + kind + " item(s) from the human summary.");
   const critical = [
     ...unresolved.map((error2) => "- Unresolved error: " + safe(error2, TRUNC.TOPIC_LABEL)),
+    ...resolved.map((error2) => "- Resolved error: " + safe(error2, TRUNC.TOPIC_LABEL)),
     ...overflow
   ];
   return [
@@ -8787,7 +9089,7 @@ async function summarizeConversation(rc) {
       phaseName: "Synthesize",
       detail: "Building a deterministic continuation summary \xB7 no LLM call"
     });
-    const finalSummary2 = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote });
+    const finalSummary2 = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
     setCachedSynthesis(cacheKey, {
       finalSummary: finalSummary2,
       method: "heuristic",
@@ -8818,7 +9120,7 @@ async function summarizeConversation(rc) {
   rc.vlog("Tier=" + rc.tier + " | convTokens=" + rc.convTokens + " | singlePassMax=" + singlePassMaxTokens);
   let finalSummary;
   let method;
-  let summaries = [];
+  const summaries = [];
   let explorationReport = null;
   let explorationRounds = 0;
   let chunkCount = 0;
@@ -8839,7 +9141,7 @@ async function summarizeConversation(rc) {
       phaseName: "Synthesize",
       detail: "Summary route unavailable \xB7 building a deterministic summary"
     });
-    finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote });
+    finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
     method = "heuristic";
   } else if (rc.convTokens < singlePassMaxTokens) {
     showProgressOverlay(rc.ctx, {
@@ -8859,7 +9161,7 @@ async function summarizeConversation(rc) {
       generationFallbacks.push("single-pass generation failed");
       debugError("Single-pass synthesis used deterministic fallback", err);
       rc.notify("Single-pass generation stopped \xB7 using deterministic fallback", "info");
-      finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote });
+      finalSummary = assembleFallback([], extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
       method = "heuristic";
     }
   } else {
@@ -8876,7 +9178,10 @@ async function summarizeConversation(rc) {
       });
       try {
         const segAuth = await resolveStageAuth(rc, "explore");
-        const expResult = await exploreConversation(rc.llmMessages, extraction, rc.segModel, segAuth, rc.prevContext || undefined, [rc.userNote, rc.config.focusWeighting && rc.focus ? "Focus extra preservation on: " + rc.focus : undefined].filter(Boolean).join(`
+        const expResult = await exploreConversation(rc.llmMessages, extraction, rc.segModel, segAuth, rc.prevContext || undefined, [
+          rc.userNote,
+          rc.config.focusWeighting && rc.focus ? "Focus extra preservation on: " + rc.focus : undefined
+        ].filter(Boolean).join(`
 `) || undefined, rc.cancellation.signal, MAX_EXPLORATION_ROUNDS, rc.notify, rc.services);
         explorationReport = expResult.report;
         explorationRounds = expResult.rounds;
@@ -9050,7 +9355,7 @@ async function summarizeConversation(rc) {
       totalBatches: batches.length
     });
     try {
-      const r = await assembleLLM(summaries, extraction, explorationReport, rc.summaryModel, summaryAuth, pc.summaryBudgetTokens, rc.prevContext, rc.cancellation.signal, rc.services, rc.config.focusWeighting ? rc.focus : undefined);
+      const r = await assembleLLM(summaries, extraction, explorationReport, rc.summaryModel, summaryAuth, pc.summaryBudgetTokens, rc.prevContext, rc.cancellation.signal, rc.services, rc.config.focusWeighting ? rc.focus : undefined, rc.previousState);
       if (r?.startsWith("##"))
         finalSummary = r;
       else
@@ -9059,7 +9364,7 @@ async function summarizeConversation(rc) {
       cacheable = false;
       generationFallbacks.push("assembly generation failed");
       debugError("Assembly used deterministic fallback", err);
-      finalSummary = assembleFallback(summaries, extraction, { focus: rc.focus, note: rc.userNote });
+      finalSummary = assembleFallback(summaries, extraction, { focus: rc.focus, note: rc.userNote }, pc.summaryBudgetTokens, rc.previousState);
     }
     method = "eesv";
   }
@@ -9092,6 +9397,76 @@ async function summarizeConversation(rc) {
 // 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);
 }
@@ -9110,6 +9485,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)
@@ -9293,8 +9690,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"))
@@ -9409,7 +9870,7 @@ function repairSummaryDeterministically(summary, result, extraction, continuity
     const patchable = result.gaps.filter(isDeterministicallyPatchable);
     if (!patchable.length)
       break;
-    const next = patchDeterministic(summary, patchable, extraction, continuity);
+    const next = patchDeterministic(summary, patchable, extraction, continuity, evidence);
     if (next === summary)
       break;
     for (const gap of patchable) {
@@ -9442,11 +9903,15 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
   };
   const unresolvedEvidence = uniqueByText([
     ...extraction.errors.filter((error2) => !error2.resolved).map((error2) => ({ message: error2.message })),
-    ...(continuity?.unresolvedErrors ?? []).map((error2) => ({ message: error2.message }))
+    ...(continuity?.unresolvedErrors ?? []).map((error2) => ({
+      message: error2.message
+    }))
   ], (item) => item.message);
   const resolvedEvidence = uniqueByText([
     ...extraction.errors.filter((error2) => error2.resolved).map((error2) => ({ message: error2.message })),
-    ...(continuity?.resolvedErrors ?? []).map((error2) => ({ message: error2.message }))
+    ...(continuity?.resolvedErrors ?? []).map((error2) => ({
+      message: error2.message
+    }))
   ], (item) => item.message).slice(-5);
   const steeringConstraints = [
     evidence.steering?.focus ? { text: "Preserve detail about: " + evidence.steering.focus } : null,
@@ -9473,40 +9938,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, ([path12, owners]) => [path12, 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 error2 of unresolvedEvidence) {
-    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase();
+    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
       gaps.push({ kind: "missing-error", message: error2.message });
       score -= 5;
     }
   }
   for (const error2 of resolvedEvidence) {
-    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase();
+    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase().replace(/\\/g, "/");
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
-      gaps.push({ kind: "missing-error", message: error2.message, resolved: true });
+      gaps.push({
+        kind: "missing-error",
+        message: error2.message,
+        resolved: true
+      });
       score -= 2;
     }
   }
@@ -9521,7 +10010,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;
     }
   }
@@ -9532,32 +10024,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((error2) => error2.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;
     }
@@ -9566,8 +10078,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));
@@ -9581,7 +10097,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;
       }
     }
@@ -9593,7 +10112,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;
     }
   }
@@ -9614,8 +10136,17 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
   const finalScore = Math.max(0, score);
   return { ok: gaps.length === 0 && finalScore >= 85, gaps, score: finalScore };
 }
-function patchDeterministic(summary, gaps, extraction, continuity = null) {
+function patchDeterministic(summary, gaps, extraction, continuity = null, evidence = {}) {
   let canonical = parseSummary(summary);
+  const modifiedPaths = extraction.modifiedFiles.map((file) => file.path);
+  const readPaths = extraction.readFiles;
+  const deletedPaths = Array.from(new Set([...extraction.deletedFiles, ...continuity?.deletedFiles ?? []]));
+  const pathEvidence = buildSummaryPathEvidence([...modifiedPaths, ...readPaths, ...deletedPaths], evidence.summaryBudgetTokens);
+  const replaceFileSection = (kind, paths) => {
+    const body = paths.map((path12) => "- " + (pathEvidence.get(path12) ?? JSON.stringify(path12))).join(`
+`);
+    canonical = upsertSection(canonical, kind, body || "- None recorded.");
+  };
   const safe = (value, max = TRUNC.MESSAGE) => summaryEvidenceLine(value, max);
   const unresolvedMessages = Array.from(new Set([
     ...extraction.errors.filter((error2) => !error2.resolved).map((error2) => error2.message),
@@ -9630,9 +10161,24 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
     const progress = findSection(canonical, "progress");
     if (!progress || !blockedItems.length)
       return;
-    const body = progress.body.replace(/(###\s*Blocked\s*\n)(?:-\s*(?:none|none recorded|no blockers?|yok)[.!]?\s*)/i, "$1" + blockedItems.join(`
+    const lines = progress.body.split(/\r?\n/);
+    const start = lines.findIndex((line) => /^###\s*Blocked\s*$/i.test(line.trim()));
+    if (start < 0)
+      return;
+    let end = lines.findIndex((line, index) => index > start && /^###\s+/.test(line.trim()));
+    if (end < 0)
+      end = lines.length;
+    const existing = lines.slice(start + 1, end);
+    const noneIndexes = noneBlockerLineIndexes(existing);
+    if (!noneIndexes.size)
+      return;
+    const replacement = Array.from(new Set([
+      ...blockedItems,
+      ...existing.filter((line, index) => line.trim() && !noneIndexes.has(index))
+    ]));
+    lines.splice(start + 1, end - start - 1, ...replacement);
+    canonical = upsertSection(canonical, "progress", lines.join(`
 `));
-    canonical = upsertSection(canonical, "progress", body);
   };
   for (const gap of gaps) {
     switch (gap.kind) {
@@ -9648,20 +10194,23 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
 ` + (blockedItems.join(`
 `) || "- None recorded."));
         } else if (gap.section === "critical-context") {
-          const critical = unresolvedMessages.map((message) => safe(message)).filter(Boolean).map((message) => "- Unresolved error: " + message);
+          const critical = unresolvedMessages.flatMap((message) => {
+            const text = safe(message);
+            return text ? ["- Unresolved error: " + text] : [];
+          });
           canonical = upsertSection(canonical, "critical-context", critical.join(`
 `) || "- None recorded.");
         }
         break;
       }
       case "missing-file":
-        canonical = appendToSection(canonical, "files-modified", "- " + safe(gap.path));
+        replaceFileSection("files-modified", modifiedPaths);
         break;
       case "missing-read-file":
-        canonical = appendToSection(canonical, "files-read", "- " + safe(gap.path));
+        replaceFileSection("files-read", readPaths);
         break;
       case "missing-deleted-file":
-        canonical = appendToSection(canonical, "files-deleted", "- " + safe(gap.path));
+        replaceFileSection("files-deleted", deletedPaths);
         break;
       case "missing-error": {
         const existing = findSection(canonical, "critical-context")?.body.toLowerCase() ?? "";
@@ -9683,7 +10232,10 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
       case "missing-open-loops": {
         const current = extraction.errors.filter((error2) => !error2.resolved).map((error2) => safe(error2.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
         const carriedErrors = (continuity?.unresolvedErrors ?? []).map((error2) => safe(error2.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
-        const carriedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved").map((loop) => ({ priority: loop.priority, summary: safe(loop.summary, TRUNC.SNIPPET) })).filter((item) => item.summary).map((item) => "- [" + item.priority + "] " + item.summary);
+        const carriedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved").map((loop) => ({
+          priority: loop.priority,
+          summary: safe(loop.summary, TRUNC.SNIPPET)
+        })).filter((item) => item.summary).map((item) => "- [" + item.priority + "] " + item.summary);
         const body = Array.from(new Set([...current, ...carriedErrors, ...carriedLoops])).slice(0, gap.unresolvedCount).join(`
 `);
         canonical = upsertSection(canonical, "open-loops", body || "- Review unresolved errors.", "next-steps");
@@ -9754,7 +10306,13 @@ Return the COMPLETE corrected summary in the same format.`;
     const maxTokens = Math.min(8192, getProviderCaps(model.provider).maxOutputTokens);
     const response = await trackedComplete("patch", model, {
       systemPrompt: COMPACT_SYSTEM_PREFIX,
-      messages: [{ role: "user", content: [{ type: "text", text: patchPrompt }], timestamp: Date.now() }]
+      messages: [
+        {
+          role: "user",
+          content: [{ type: "text", text: patchPrompt }],
+          timestamp: Date.now()
+        }
+      ]
     }, { apiKey: auth.apiKey, headers: auth.headers, maxTokens, signal }, services);
     const patched = response.content.filter((content) => content.type === "text").map((content) => content.text).join(`
 `).trim();
@@ -9762,7 +10320,10 @@ Return the COMPLETE corrected summary in the same format.`;
       return summary;
     const originalSections = parseSummary(summary).sections;
     const patchedSections = parseSummary(patched).sections;
-    const patchedBodies = new Map(patchedSections.map((section) => [sectionIdentity(section), section.body.trim()]));
+    const patchedBodies = new Map(patchedSections.map((section) => [
+      sectionIdentity(section),
+      section.body.trim()
+    ]));
     const preserved = originalSections.every((section) => !section.body.trim() || Boolean(patchedBodies.get(sectionIdentity(section))));
     return preserved ? patched : summary;
   } catch (error2) {
@@ -9775,9 +10336,11 @@ Return the COMPLETE corrected summary in the same format.`;
 async function verifyAndPatch(rc) {
   const extraction = rc.extraction;
   let summary = rc.finalSummary;
+  const summaryBudgetTokens = rc.profileCfg?.summaryBudgetTokens ?? 6000;
   const evidence = {
     sourceMessages: rc.llmMessages,
-    steering: { focus: rc.focus, note: rc.userNote }
+    steering: { focus: rc.focus, note: rc.userNote },
+    summaryBudgetTokens
   };
   showProgressOverlay(rc.ctx, {
     phase: 4,
@@ -9840,7 +10403,7 @@ async function verifyAndPatch(rc) {
       detail: "Trying the deterministic safety summary",
       explorationRounds: rc.explorationRounds
     });
-    let deterministic = assembleFallback([], extraction, evidence.steering);
+    let deterministic = assembleFallback([], extraction, evidence.steering, summaryBudgetTokens, rc.previousState);
     let deterministicVerification = verifySummary(deterministic, extraction, rc.previousState, evidence);
     const repaired = repairSummaryDeterministically(deterministic, deterministicVerification, extraction, rc.previousState, evidence);
     deterministic = repaired.summary;
@@ -10062,7 +10625,7 @@ function buildState(rc) {
 }
 
 // src/infra/context-graph.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import fs9 from "fs";
 import path13 from "path";
 import { createRequire } from "module";
@@ -10193,7 +10756,7 @@ function openDatabase() {
   return db;
 }
 function stableId(...parts) {
-  return "cg-" + createHash3("sha256").update(parts.join("\x00")).digest("hex").slice(0, 24);
+  return "cg-" + createHash4("sha256").update(parts.join("\x00")).digest("hex").slice(0, 24);
 }
 function factKey(text) {
   return normalizeFactKey(text) || text.trim().toLowerCase();