pi-smart-compact 9.0.0 → 9.1.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.0.0";
+var VERSION = "9.1.0";
 var CHARS_PER_TOKEN = 3.8;
 var MIN_COMPACTION_SAVING_RATIO = 0.1;
 var ESTIMATOR_ROUNDING_TOLERANCE_TOKENS = 1;
@@ -225,6 +225,7 @@ var BACKUP_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
 var FIVE_MINUTES_MS = 5 * 60 * 1000;
 var ONE_HOUR_MS = 60 * 60 * 1000;
 var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+var STATE_SNAPSHOT_MAX_FILES = 64;
 var EXTRACTION_LIMITS = {
   MODIFIED_FILES: 120,
   READ_FILES: 160,
@@ -232,8 +233,10 @@ var EXTRACTION_LIMITS = {
   ERRORS: 80,
   DECISIONS: 80,
   CONSTRAINTS: 80,
+  TOPICS: 80,
   TIMELINE: 120,
-  MEDIA_ATTACHMENTS: 40
+  MEDIA_ATTACHMENTS: 40,
+  REFERENCED_FILES: 200
 };
 var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
 var EXTRACTION_CACHE_PREFIX = "compact-extraction-";
@@ -285,6 +288,7 @@ var TRUNC = {
   FINGERPRINT_SEG: 2
 };
 var MAX_TOOL_OUTPUT_CHARS = 800;
+var MAX_EXPLORER_OUTPUT_CHARS = 12000;
 var LIKELY_ERROR_RE = /(?:command not found|no such file|permission denied|syntax error|cannot find|module not found|compilation error|build failed|test failed|^FAIL\b|ERROR:)/i;
 var ERROR_RETRY_WINDOW = 6;
 var ERROR_RESOLVE_WINDOW = 10;
@@ -485,6 +489,51 @@ function appendLineLocked(target, line, maxBytes) {
     release();
   }
 }
+async function appendLineLockedAsync(target, line, maxBytes) {
+  await ensureDirAsync(path.dirname(target));
+  const payload = Buffer.from(line.endsWith(`
+`) ? line : line + `
+`);
+  if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
+    throw new Error("maxBytes must be a positive safe integer");
+  }
+  if (maxBytes !== undefined && payload.length > maxBytes) {
+    throw new Error("Log entry exceeds retention cap for " + target);
+  }
+  const release = await acquireLock(target);
+  try {
+    let stat = null;
+    try {
+      stat = await fsp.stat(target);
+    } catch (error2) {
+      if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "ENOENT")
+        throw error2;
+    }
+    if (maxBytes !== undefined && stat && stat.size + payload.length > maxBytes) {
+      const retainedLength = Math.min(stat.size, Math.max(0, maxBytes - payload.length));
+      const buffer = Buffer.allocUnsafe(retainedLength);
+      if (retainedLength > 0) {
+        const handle = await fsp.open(target, "r");
+        try {
+          await handle.read(buffer, 0, retainedLength, stat.size - retainedLength);
+        } finally {
+          await handle.close();
+        }
+      }
+      let tail = buffer.toString("utf8");
+      if (retainedLength < stat.size) {
+        const firstNewline = tail.indexOf(`
+`);
+        tail = firstNewline >= 0 ? tail.slice(firstNewline + 1) : "";
+      }
+      await atomicWriteFile(target, tail);
+    }
+    await fsp.appendFile(target, payload, { mode: 384 });
+    await fsp.chmod(target, 384);
+  } finally {
+    release();
+  }
+}
 function readJsonlTail(target, limit, maxBytes = 512 * 1024) {
   if (limit <= 0 || !fs.existsSync(target))
     return [];
@@ -810,6 +859,13 @@ function getProviderCaps(provider) {
   }
   return DEFAULT_CAPS;
 }
+function safeContextPercent(totalTokens, contextWindow) {
+  if (!Number.isFinite(totalTokens) || !Number.isFinite(contextWindow))
+    return 0;
+  if ((totalTokens ?? 0) <= 0 || (contextWindow ?? 0) <= 0)
+    return 0;
+  return totalTokens / contextWindow * 100;
+}
 
 class TokenCalibrationStore {
   maxEntries;
@@ -894,11 +950,14 @@ function makeTokenEstimator(provider, model, calibration = _fallbackCalibration)
 }
 
 // src/utils/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
 function isTextBlock(c) {
-  return typeof c === "object" && c !== null && c.type === "text" && typeof c.text === "string";
+  return isRecord(c) && c.type === "text" && typeof c.text === "string";
 }
 function isToolCallBlock(c) {
-  return typeof c === "object" && c !== null && c.type === "toolCall" && typeof c.name === "string";
+  return isRecord(c) && c.type === "toolCall" && typeof c.name === "string" && isRecord(c.arguments);
 }
 function getToolCallNames(content) {
   if (!Array.isArray(content))
@@ -1056,6 +1115,19 @@ function buildPathNeedles(filePath) {
   }
   return needles;
 }
+function buildUniquePathNeedles(filePath, allPaths) {
+  const normalized = allPaths.map(normalizePath);
+  return buildPathNeedles(filePath).filter((needle) => {
+    let owners = 0;
+    for (const candidate of normalized) {
+      if (candidate === needle || candidate.endsWith("/" + needle))
+        owners++;
+      if (owners > 1)
+        return false;
+    }
+    return owners === 1;
+  });
+}
 function isKnownPathReference(ref, knownPaths) {
   const normalizedRef = normalizePath(ref);
   return knownPaths.some((path3) => {
@@ -1102,6 +1174,152 @@ function extractToolPath(args) {
   }
   return;
 }
+function tokenizeShell(command) {
+  const tokens = [];
+  let word = "";
+  let quote = null;
+  const flush = () => {
+    if (word)
+      tokens.push({ kind: "word", value: word });
+    word = "";
+  };
+  for (let index = 0;index < command.length; index++) {
+    const char = command[index];
+    if (char === "\\" && quote !== "'" && index + 1 < command.length) {
+      word += command[++index];
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      if (!quote)
+        quote = char;
+      else if (quote === char)
+        quote = null;
+      else
+        word += char;
+      continue;
+    }
+    if (quote) {
+      word += char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      flush();
+      if (char === `
+`)
+        tokens.push({ kind: "separator", value: char });
+      continue;
+    }
+    if (char === ">" || char === ";" || char === "|" || char === "&" && command[index + 1] === "&") {
+      flush();
+      if (char === ">") {
+        const append = command[index + 1] === ">";
+        if (append)
+          index++;
+        tokens.push({ kind: "redirect", value: append ? ">>" : ">" });
+      } else {
+        const paired = char === "|" && command[index + 1] === "|" || char === "&" && command[index + 1] === "&";
+        if (paired)
+          index++;
+        tokens.push({ kind: "separator", value: paired ? char + char : char });
+      }
+      continue;
+    }
+    word += char;
+  }
+  flush();
+  return tokens;
+}
+function literalShellPath(token) {
+  if (!token || token.startsWith("-") || token === "/dev/null")
+    return;
+  if (/[\u0000$*?\[\]{}()<>|;&]/.test(token) || /^\d+$/.test(token))
+    return;
+  return token;
+}
+function shellOperands(words, start) {
+  const operands = [];
+  let options = true;
+  for (let index = start;index < words.length; index++) {
+    const word = words[index];
+    if (options && word === "--") {
+      options = false;
+      continue;
+    }
+    if (options && word.startsWith("-"))
+      continue;
+    const target = literalShellPath(word);
+    if (target)
+      operands.push(target);
+  }
+  return operands;
+}
+function commandFileOperations(words) {
+  const modified = [];
+  const deleted = [];
+  let commandIndex = 0;
+  while (commandIndex < words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[commandIndex]))
+    commandIndex++;
+  while (commandIndex < words.length) {
+    const wrapper = words[commandIndex].split("/").pop()?.toLowerCase();
+    if (wrapper !== "env" && wrapper !== "sudo" && wrapper !== "command" && wrapper !== "nohup")
+      break;
+    commandIndex++;
+    while (commandIndex < words.length && words[commandIndex].startsWith("-"))
+      commandIndex++;
+  }
+  const command = words[commandIndex]?.split("/").pop()?.toLowerCase();
+  const operands = shellOperands(words, commandIndex + 1);
+  if (!command || !operands.length)
+    return { modified, deleted };
+  if (command === "rm" || command === "unlink") {
+    deleted.push(...operands);
+  } else if (command === "touch" || command === "tee") {
+    modified.push(...operands);
+  } else if (command === "cp" || command === "install") {
+    modified.push(operands[operands.length - 1]);
+  } else if (command === "mv") {
+    deleted.push(...operands.slice(0, -1));
+    modified.push(operands[operands.length - 1]);
+  } else if (command === "sed" && words.slice(commandIndex + 1).some((word) => /^-i|^--in-place/.test(word))) {
+    modified.push(operands[operands.length - 1]);
+  }
+  return { modified, deleted };
+}
+function extractShellFileOperations(args) {
+  const record = args && typeof args === "object" ? args : null;
+  const command = record ? COMMAND_KEYS.map((key) => record[key]).find((value) => typeof value === "string") : undefined;
+  if (!command)
+    return { modified: [], deleted: [] };
+  const tokens = tokenizeShell(command);
+  const modified = [];
+  const deleted = [];
+  let words = [];
+  const flushCommand = () => {
+    const operations = commandFileOperations(words);
+    modified.push(...operations.modified);
+    deleted.push(...operations.deleted);
+    words = [];
+  };
+  for (let index = 0;index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.kind === "separator") {
+      flushCommand();
+    } else if (token.kind === "redirect") {
+      const target = tokens[index + 1]?.kind === "word" ? literalShellPath(tokens[index + 1].value) : undefined;
+      if (target)
+        modified.push(target);
+      if (target)
+        index++;
+    } else {
+      words.push(token.value);
+    }
+  }
+  flushCommand();
+  return {
+    modified: Array.from(new Set(modified)),
+    deleted: Array.from(new Set(deleted.filter((file) => !modified.includes(file))))
+  };
+}
 function normalizeToolName(name) {
   if (typeof name !== "string")
     return "";
@@ -1276,6 +1494,7 @@ function parseSummary(markdown) {
   let currentHeading = "";
   let currentKind = "unknown";
   let bodyLines = [];
+  let fence = null;
   let started = false;
   const flush = () => {
     if (!started)
@@ -1289,16 +1508,31 @@ function parseSummary(markdown) {
       sections.push({ kind: currentKind, heading: currentHeading.trim(), body });
   };
   for (const line of lines) {
-    const m = line.match(HEADING_RE);
-    if (m) {
-      const kind = classifyHeading(m[2]);
-      if (m[1].length <= 2 || kind !== "unknown") {
-        flush();
-        currentHeading = "## " + m[2].trim();
-        currentKind = kind;
-        bodyLines = [];
-        started = true;
-        continue;
+    const fenceMatch = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      const markerLength = fenceMatch[1].length;
+      if (!fence) {
+        fence = { marker, length: markerLength };
+      } else if (marker === fence.marker && markerLength >= fence.length && !fenceMatch[2].trim()) {
+        fence = null;
+      }
+      if (started)
+        bodyLines.push(line);
+      continue;
+    }
+    if (!fence) {
+      const heading = line.match(HEADING_RE);
+      if (heading) {
+        const kind = classifyHeading(heading[2]);
+        if (heading[1].length <= 2 || kind !== "unknown") {
+          flush();
+          currentHeading = "## " + heading[2].trim();
+          currentKind = kind;
+          bodyLines = [];
+          started = true;
+          continue;
+        }
       }
     }
     if (started)
@@ -1472,39 +1706,61 @@ function buildToolCallIndex(msgs) {
 function trackFileOps(msgs, _tcIdx) {
   const tcIdx = _tcIdx ?? buildToolCallIndex(msgs);
   const modMap = new Map;
-  const readSet = new Set;
-  const delSet = new Set;
+  const readAt = new Map;
+  const deletedAt = new Map;
+  const referencedAt = new Map;
   for (let i = 0;i < msgs.length; i++) {
     const m = msgs[i];
+    for (const ref of extractFileRefs((JSON.stringify(m.content) ?? "").replace(/\\[nrt]/g, " "))) {
+      referencedAt.set(ref, i);
+    }
     if (m.role !== "toolResult" || m.isError)
       continue;
     const tc = tcIdx.get(m.toolCallId ?? "");
     if (!tc)
       continue;
+    const operation = classifyToolOperation(tc.arguments, tc.name);
+    if (operation === "execute") {
+      const resultText = extractText(m.content);
+      if (hasCommandFailureSignal(resultText))
+        continue;
+      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 });
+        deletedAt.delete(file);
+      }
+      for (const file of shell.deleted) {
+        deletedAt.set(file, i);
+        modMap.delete(file);
+        readAt.delete(file);
+      }
+      continue;
+    }
     const filePath = extractToolPath(tc.arguments);
     if (!filePath)
       continue;
-    const operation = classifyToolOperation(tc.arguments, tc.name);
     if (operation === "mutate") {
       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 });
-        delSet.delete(filePath);
+        deletedAt.delete(filePath);
       }
     } else if (operation === "delete") {
-      delSet.add(filePath);
+      deletedAt.set(filePath, i);
       modMap.delete(filePath);
-      readSet.delete(filePath);
+      readAt.delete(filePath);
     } else if (operation === "read" || operation === "search" || operation === "list") {
-      readSet.add(filePath);
-      delSet.delete(filePath);
+      readAt.set(filePath, i);
+      deletedAt.delete(filePath);
     }
   }
   return {
     modified: [...modMap.entries()].map(([p, d]) => ({ path: p, toolCalls: d.toolCalls, lastModifiedIndex: d.lastIdx })),
-    read: [...readSet],
-    deleted: [...delSet]
+    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)
   };
 }
 function isBenignSearchResult(tc, result) {
@@ -1779,6 +2035,29 @@ function extractMainGoal(msgs) {
   }
   return null;
 }
+var FOLLOWUP_COMPLETION_RE = /\b(?:done|completed?|finished|implemented|fixed|resolved|updated|added|removed|shipped|tamamland[\u0131i]|tamamlad[\u0131i]m|bitti|[\u00E7c][\u00F6o]z[\u00FCu]ld[\u00FCu])\b/iu;
+var NEGATED_COMPLETION_RE = /\b(?:not|isn['\u2019]?t|wasn['\u2019]?t|hen[\u00FCu]z|de[\u011Fg]il)\b.{0,20}\b(?:done|complete|finished|fixed|resolved|bitti)\b/iu;
+var FOLLOWUP_TOKEN_STOP = {
+  next: true,
+  step: true,
+  thing: true,
+  todo: true,
+  action: true,
+  item: true,
+  follow: true,
+  still: true,
+  need: true,
+  have: true,
+  gotta: true,
+  eklenecek: true,
+  duzeltilecek: true,
+  d\u{fc}zeltilecek: true,
+  gerekiyor: true,
+  yapalim: true,
+  yapal\u{131}m: true,
+  kaldi: true,
+  kald\u{131}: true
+};
 function extractOpenLoops(msgs, extraction) {
   const loops = [];
   let loopId = 0;
@@ -1859,6 +2138,29 @@ function extractOpenLoops(msgs, extraction) {
       });
     }
   }
+  for (const loop of loops) {
+    if (loop.type !== "follow-up" || loop.sourceIndex == null)
+      continue;
+    const taskTokens = (loop.summary.toLowerCase().match(/[\p{L}\p{N}_-]{4,}/gu) ?? []).filter((token) => !FOLLOWUP_TOKEN_STOP[token]);
+    if (!taskTokens.length)
+      continue;
+    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")
+        break;
+      if (message?.role !== "assistant")
+        continue;
+      const response = extractText(message.content);
+      const normalized = response.toLowerCase();
+      if (!FOLLOWUP_COMPLETION_RE.test(response) || NEGATED_COMPLETION_RE.test(response))
+        continue;
+      if (taskTokens.some((token) => normalized.includes(token))) {
+        loop.status = "resolved";
+        break;
+      }
+    }
+  }
   return loops;
 }
 function extractStructured(msgs, pc, precomputedTcIdx) {
@@ -1877,20 +2179,24 @@ function extractStructured(msgs, pc, precomputedTcIdx) {
   const errors = recent(allErrors, EXTRACTION_LIMITS.ERRORS);
   const decisions = recent(allDecisions, EXTRACTION_LIMITS.DECISIONS);
   const constraints = recent(allConstraints, EXTRACTION_LIMITS.CONSTRAINTS);
+  const boundedTopics = recent(topics, EXTRACTION_LIMITS.TOPICS);
   const timeline = recent(allTimeline, EXTRACTION_LIMITS.TIMELINE);
   const mediaAttachments = recent(allMediaAttachments, EXTRACTION_LIMITS.MEDIA_ATTACHMENTS);
+  const allReferencedFiles = tracked.referenced;
+  const referencedFiles = recent(allReferencedFiles, EXTRACTION_LIMITS.REFERENCED_FILES);
   const overflow = {
     modifiedFiles: tracked.modified.length - modifiedFiles.length,
+    referencedFiles: allReferencedFiles.length - referencedFiles.length,
     readFiles: tracked.read.length - readFiles.length,
     deletedFiles: tracked.deleted.length - deletedFiles.length,
     errors: allErrors.length - errors.length,
     decisions: allDecisions.length - decisions.length,
     constraints: allConstraints.length - constraints.length,
+    topics: topics.length - boundedTopics.length,
     timeline: allTimeline.length - timeline.length,
     mediaAttachments: allMediaAttachments.length - mediaAttachments.length
   };
   const evidenceOverflow = Object.fromEntries(Object.entries(overflow).filter(([, count]) => count > 0));
-  const referencedFiles = Array.from(new Set(msgs.flatMap((message) => extractFileRefs((JSON.stringify(message.content) ?? "").replace(/\\[nrt]/g, " "))))).slice(0, 200);
   const mainGoal = extractMainGoal(msgs);
   const lastUserMessages = msgs.filter((m) => m.role === "user").slice(-5).map((m) => extractText(m.content));
   const lastErrors = errors.slice(-3).map((e) => e.message);
@@ -1902,7 +2208,7 @@ function extractStructured(msgs, pc, precomputedTcIdx) {
     errors,
     decisions,
     constraints,
-    topics,
+    topics: boundedTopics,
     timeline,
     mediaAttachments,
     mainGoal,
@@ -2176,39 +2482,34 @@ function smartKeepBoundaryCandidates(msgs, keepFromIndex, branchEntries) {
   return candidates;
 }
 function collectToolCallIds(blocks, msgIndex, out) {
-  for (const b of blocks) {
-    const block = b;
-    if (block?.type === "toolCall") {
-      if (typeof block.id === "string") {
-        out.set(block.id, msgIndex);
-      }
-      const args = block.arguments;
-      if (block.name === "multi_tool_use.parallel" && args && Array.isArray(args.tool_uses)) {
-        for (const nested of args.tool_uses) {
-          const n = nested;
-          if (typeof n.id === "string") {
-            out.set(n.id, msgIndex);
-          }
-        }
-      }
+  for (const block of blocks) {
+    if (!isRecord(block) || block.type !== "toolCall")
+      continue;
+    if (typeof block.id === "string")
+      out.set(block.id, msgIndex);
+    const args = block.arguments;
+    if (block.name !== "multi_tool_use.parallel" || !isRecord(args) || !Array.isArray(args.tool_uses))
+      continue;
+    for (const nested of args.tool_uses) {
+      if (isRecord(nested) && typeof nested.id === "string")
+        out.set(nested.id, msgIndex);
     }
   }
 }
-function toolCallIndexMap(msgs) {
+function buildToolCallBoundaryIndex(msgs) {
   const map = new Map;
   for (let i = 0;i < msgs.length; i++) {
-    const m = msgs[i].message;
-    if (m?.role !== "assistant")
+    const message = msgs[i].message;
+    if (!isRecord(message) || message.role !== "assistant")
       continue;
-    const blocks = Array.isArray(m?.content) ? m.content : [];
+    const blocks = Array.isArray(message.content) ? message.content : [];
     collectToolCallIds(blocks, i, map);
   }
   return map;
 }
-function guardToolCallBoundary(msgs, keepFrom) {
+function guardToolCallBoundary(msgs, keepFrom, tcMap = buildToolCallBoundaryIndex(msgs)) {
   if (keepFrom <= 0 || keepFrom >= msgs.length)
     return keepFrom;
-  const tcMap = toolCallIndexMap(msgs);
   let adjusted = keepFrom;
   let changed = true;
   const MAX_ITER = msgs.length + 1;
@@ -2220,10 +2521,10 @@ function guardToolCallBoundary(msgs, keepFrom) {
     }
     changed = false;
     for (let i = adjusted;i < msgs.length; i++) {
-      const m = msgs[i].message;
-      if (m?.role !== "toolResult")
+      const message = msgs[i].message;
+      if (!isRecord(message) || message.role !== "toolResult")
         continue;
-      const tcId = m?.toolCallId;
+      const tcId = typeof message.toolCallId === "string" ? message.toolCallId : undefined;
       if (!tcId)
         continue;
       const tcIdx = tcMap.get(tcId);
@@ -2236,18 +2537,17 @@ function guardToolCallBoundary(msgs, keepFrom) {
   }
   return Math.max(0, Math.min(adjusted, msgs.length));
 }
-function advancePastToolCallBoundary(msgs, keepFrom) {
+function advancePastToolCallBoundary(msgs, keepFrom, tcMap = buildToolCallBoundaryIndex(msgs)) {
   if (keepFrom <= 0 || keepFrom >= msgs.length)
     return keepFrom;
-  const tcMap = toolCallIndexMap(msgs);
   let adjusted = keepFrom;
   for (let iter = 0;iter <= msgs.length; iter++) {
     let next = adjusted;
     for (let i = adjusted;i < msgs.length; i++) {
-      const m = msgs[i].message;
-      if (m?.role !== "toolResult")
+      const message = msgs[i].message;
+      if (!isRecord(message) || message.role !== "toolResult")
         continue;
-      const tcIdx = typeof m.toolCallId === "string" ? tcMap.get(m.toolCallId) : undefined;
+      const tcIdx = typeof message.toolCallId === "string" ? tcMap.get(message.toolCallId) : undefined;
       if (i === adjusted && tcIdx === undefined || tcIdx !== undefined && tcIdx < adjusted) {
         next = i + 1;
         break;
@@ -2916,30 +3216,41 @@ function mergeFindings(target, findings) {
   for (const finding of findings)
     target.set(finding.kind, (target.get(finding.kind) ?? 0) + finding.count);
 }
-var SECRET_KEY_NAMES = new Set([
-  "api_key",
-  "apikey",
-  "access_token",
-  "auth_token",
-  "authorization",
-  "password",
-  "passwd",
-  "secret",
-  "secret_key",
-  "secret_access_key",
-  "client_secret",
-  "private_key",
-  "database_url",
-  "connection_string"
-]);
+var SECRET_KEY_NAMES = {
+  api_key: true,
+  apikey: true,
+  access_token: true,
+  auth_token: true,
+  authorization: true,
+  password: true,
+  passwd: true,
+  secret: true,
+  secret_key: true,
+  secret_access_key: true,
+  client_secret: true,
+  private_key: true,
+  database_url: true,
+  connection_string: true,
+  token: true,
+  refresh_token: true,
+  session_token: true,
+  credential: true,
+  credentials: true,
+  cookie: true,
+  set_cookie: true,
+  otp: true,
+  one_time_password: true,
+  pin: true,
+  passcode: true
+};
 function normalizeObjectKey(key) {
   return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
 function isSecretBearingKey(key) {
   const normalized = normalizeObjectKey(key);
-  if (SECRET_KEY_NAMES.has(normalized))
+  if (SECRET_KEY_NAMES[normalized])
     return true;
-  return /(?:^|_)(?:api_key|access_token|auth_token|password|passwd|secret_access_key|client_secret|private_key)(?:_|$)/.test(normalized);
+  return /(?:^|_)(?:api_key|access_token|auth_token|password|passwd|secret_access_key|client_secret|private_key|refresh_token|session_token|one_time_password|passcode)(?:_|$)/.test(normalized);
 }
 
 class SecretScrubber {
@@ -2995,7 +3306,8 @@ class SecretScrubber {
       const output = {};
       seen.set(value2, output);
       for (const [key, item] of Object.entries(value2)) {
-        if (this.secretsEnabled && isSecretBearingKey(key) && typeof item === "string" && item.length > 0) {
+        const carriesSecret = typeof item === "string" ? item.length > 0 : item != null;
+        if (this.secretsEnabled && isSecretBearingKey(key) && carriesSecret) {
           output[key] = "[REDACTED:credential]";
           recordCredential();
         } else {
@@ -3466,76 +3778,125 @@ function reconcileCachedErrors(errors, deltaMessages, deltaToolCalls, baseMsgCou
     return { ...error2, retryAttempted, resolved };
   });
 }
+function boundedTail(items, limit) {
+  const dropped = Math.max(0, items.length - limit);
+  return { values: dropped ? items.slice(-limit) : items, dropped };
+}
+function recentUnique(items, limit) {
+  const seen = new Set;
+  const newestFirst = [];
+  for (let index = items.length - 1;index >= 0; index--) {
+    const item = items[index];
+    if (seen.has(item))
+      continue;
+    seen.add(item);
+    if (newestFirst.length < limit)
+      newestFirst.push(item);
+  }
+  return {
+    values: newestFirst.reverse(),
+    dropped: Math.max(0, seen.size - limit)
+  };
+}
 function mergeExtractions(base, delta, baseMsgCount, deltaMessages = [], deltaToolCalls = new Map) {
-  const offsetErrors = delta.errors.map((e) => ({ ...e, index: e.index + baseMsgCount }));
-  const offsetDecisions = delta.decisions.map((d) => ({ ...d, index: d.index + baseMsgCount }));
-  const offsetConstraints = delta.constraints.map((c) => ({ ...c, index: c.index + baseMsgCount }));
-  const offsetTopics = delta.topics.map((t) => ({
-    ...t,
-    startIndex: t.startIndex + baseMsgCount,
-    endIndex: t.endIndex + baseMsgCount
+  const offsetErrors = delta.errors.map((error2) => ({ ...error2, index: error2.index + baseMsgCount }));
+  const offsetDecisions = delta.decisions.map((decision) => ({ ...decision, index: decision.index + baseMsgCount }));
+  const offsetConstraints = delta.constraints.map((constraint) => ({ ...constraint, index: constraint.index + baseMsgCount }));
+  const offsetTopics = delta.topics.map((topic) => ({
+    ...topic,
+    startIndex: topic.startIndex + baseMsgCount,
+    endIndex: topic.endIndex + baseMsgCount
   }));
-  const offsetTimeline = delta.timeline.map((t) => ({ ...t, index: t.index + baseMsgCount }));
-  const offsetModifiedFiles = delta.modifiedFiles.map((f) => ({
-    ...f,
-    lastModifiedIndex: f.lastModifiedIndex + baseMsgCount
+  const offsetTimeline = delta.timeline.map((event) => ({ ...event, index: event.index + baseMsgCount }));
+  const offsetModifiedFiles = delta.modifiedFiles.map((file) => ({
+    ...file,
+    lastModifiedIndex: file.lastModifiedIndex + baseMsgCount
+  }));
+  const offsetMedia = (delta.mediaAttachments ?? []).map((attachment) => ({
+    ...attachment,
+    index: attachment.index + baseMsgCount
   }));
-  const offsetMedia = (delta.mediaAttachments ?? []).map((a) => ({ ...a, index: a.index + baseMsgCount }));
   const modified = new Map(base.modifiedFiles.map((file) => [file.path, { ...file }]));
   for (const file of offsetModifiedFiles) {
     const previous = modified.get(file.path);
-    modified.set(file.path, previous ? { ...file, toolCalls: previous.toolCalls + file.toolCalls, lastModifiedIndex: Math.max(previous.lastModifiedIndex, file.lastModifiedIndex) } : file);
+    modified.set(file.path, previous ? {
+      ...file,
+      toolCalls: previous.toolCalls + file.toolCalls,
+      lastModifiedIndex: Math.max(previous.lastModifiedIndex, file.lastModifiedIndex)
+    } : file);
   }
   const deltaPresent = new Set([...offsetModifiedFiles.map((file) => file.path), ...delta.readFiles]);
   const deltaDeleted = new Set(delta.deletedFiles);
   for (const file of deltaDeleted)
     modified.delete(file);
-  const readFiles = new Set([...base.readFiles, ...delta.readFiles]);
-  for (const file of deltaDeleted)
-    readFiles.delete(file);
-  const deletedFiles = new Set([...base.deletedFiles, ...delta.deletedFiles]);
-  for (const file of deltaPresent)
-    deletedFiles.delete(file);
+  const modifiedFiles = boundedTail([...modified.values()].sort((a, b) => a.lastModifiedIndex - b.lastModifiedIndex), EXTRACTION_LIMITS.MODIFIED_FILES);
+  const readFiles = recentUnique([...base.readFiles, ...delta.readFiles].filter((file) => !deltaDeleted.has(file)), EXTRACTION_LIMITS.READ_FILES);
+  const deletedFiles = recentUnique([...base.deletedFiles, ...delta.deletedFiles].filter((file) => !deltaPresent.has(file)), EXTRACTION_LIMITS.DELETED_FILES);
+  const referencedFiles = recentUnique([...base.referencedFiles ?? [], ...delta.referencedFiles ?? []], EXTRACTION_LIMITS.REFERENCED_FILES);
+  const mediaAttachments = boundedTail([...base.mediaAttachments ?? [], ...offsetMedia], EXTRACTION_LIMITS.MEDIA_ATTACHMENTS);
   const reconciledBaseErrors = reconcileCachedErrors(base.errors, deltaMessages, deltaToolCalls, baseMsgCount);
-  const mergedErrors = [...reconciledBaseErrors, ...offsetErrors].filter((error2) => !isTransientToolDiagnostic(error2.message));
+  const errors = boundedTail([...reconciledBaseErrors, ...offsetErrors].filter((error2) => !isTransientToolDiagnostic(error2.message)), EXTRACTION_LIMITS.ERRORS);
+  const decisions = boundedTail([...base.decisions, ...offsetDecisions], EXTRACTION_LIMITS.DECISIONS);
+  const constraints = boundedTail([...base.constraints, ...offsetConstraints], EXTRACTION_LIMITS.CONSTRAINTS);
+  const topics = boundedTail([...base.topics, ...offsetTopics], EXTRACTION_LIMITS.TOPICS);
+  const timeline = boundedTail([...base.timeline, ...offsetTimeline], EXTRACTION_LIMITS.TIMELINE);
+  const dropped = {
+    modifiedFiles: modifiedFiles.dropped,
+    referencedFiles: referencedFiles.dropped,
+    readFiles: readFiles.dropped,
+    deletedFiles: deletedFiles.dropped,
+    errors: errors.dropped,
+    decisions: decisions.dropped,
+    constraints: constraints.dropped,
+    topics: topics.dropped,
+    timeline: timeline.dropped,
+    mediaAttachments: mediaAttachments.dropped
+  };
+  const evidenceOverflow = {};
+  for (const key of Object.keys(dropped)) {
+    const total = (base.evidenceOverflow?.[key] ?? 0) + (delta.evidenceOverflow?.[key] ?? 0) + (dropped[key] ?? 0);
+    if (total > 0)
+      Object.assign(evidenceOverflow, { [key]: total });
+  }
   return {
-    modifiedFiles: [...modified.values()],
-    readFiles: [...readFiles],
-    deletedFiles: [...deletedFiles],
-    referencedFiles: [...new Set([...base.referencedFiles ?? [], ...delta.referencedFiles ?? []])].slice(0, 200),
-    mediaAttachments: [...base.mediaAttachments ?? [], ...offsetMedia],
-    errors: mergedErrors,
-    decisions: [...base.decisions, ...offsetDecisions],
-    constraints: [...base.constraints, ...offsetConstraints],
-    topics: [...base.topics, ...offsetTopics],
-    timeline: [...base.timeline, ...offsetTimeline],
+    modifiedFiles: modifiedFiles.values,
+    readFiles: readFiles.values,
+    deletedFiles: deletedFiles.values,
+    referencedFiles: referencedFiles.values,
+    mediaAttachments: mediaAttachments.values,
+    errors: errors.values,
+    decisions: decisions.values,
+    constraints: constraints.values,
+    topics: topics.values,
+    timeline: timeline.values,
     mainGoal: delta.mainGoal ?? base.mainGoal,
     lastUserMessages: [...base.lastUserMessages, ...delta.lastUserMessages].slice(-5),
-    lastErrors: mergedErrors.filter((error2) => !error2.resolved).map((error2) => error2.message).slice(-3),
-    messageCount: baseMsgCount + delta.messageCount
+    lastErrors: errors.values.filter((error2) => !error2.resolved).map((error2) => error2.message).slice(-3),
+    messageCount: baseMsgCount + delta.messageCount,
+    ...Object.keys(evidenceOverflow).length ? { evidenceOverflow } : {}
   };
 }
-function appendMetricsEntry(entry) {
+async function appendMetricsEntry(entry) {
   const logPath = metricsLogFile();
-  appendLineLocked(logPath, JSON.stringify(entry), RUNTIME_LOG_MAX_BYTES);
+  await appendLineLockedAsync(logPath, JSON.stringify(entry), RUNTIME_LOG_MAX_BYTES);
 }
-function appendMetricsSnapshot(sessionId, snapshot) {
+async function appendMetricsSnapshot(sessionId, snapshot) {
   try {
-    appendMetricsEntry({ ts: new Date().toISOString(), sessionId, ...snapshot });
-  } catch (e) {
-    warn("appendMetricsSnapshot failed", e);
+    await appendMetricsEntry({ ts: new Date().toISOString(), sessionId, ...snapshot });
+  } catch (error2) {
+    warn("appendMetricsSnapshot failed", error2);
   }
 }
-function appendMetricsLog(sessionId, extra, services) {
+async function appendMetricsLog(sessionId, extra, services) {
   try {
-    appendMetricsEntry({
+    await appendMetricsEntry({
       ts: new Date().toISOString(),
       sessionId,
       ...getMetricsSummary(services),
       ...extra
     });
-  } catch (e) {
-    warn("appendMetricsLog failed", e);
+  } catch (error2) {
+    warn("appendMetricsLog failed", error2);
   }
 }
 function readMetricsLog(limit = 100) {
@@ -3550,8 +3911,8 @@ function readMetricsLog(limit = 100) {
     const fd = fs4.openSync(logPath, "r");
     try {
       const buf = Buffer.alloc(wantBytes);
-      fs4.readSync(fd, buf, 0, wantBytes, startPos);
-      let text = buf.toString("utf8");
+      const bytesRead = fs4.readSync(fd, buf, 0, wantBytes, startPos);
+      let text = buf.subarray(0, bytesRead).toString("utf8");
       if (startPos > 0) {
         const nl = text.indexOf(`
 `);
@@ -4439,7 +4800,20 @@ function acquireFileLease(file, staleMs) {
       } finally {
         fs5.closeSync(fd);
       }
-      return { file, token };
+      const lease = { file, token };
+      lease.heartbeat = setInterval(() => {
+        if (readLease(file)?.token !== token) {
+          if (lease.heartbeat)
+            clearInterval(lease.heartbeat);
+          lease.heartbeat = undefined;
+          return;
+        }
+        try {
+          fs5.utimesSync(file, new Date, new Date);
+        } catch {}
+      }, Math.max(1e4, Math.floor(staleMs / 3)));
+      lease.heartbeat.unref();
+      return lease;
     } catch (error2) {
       if (error2.code !== "EEXIST")
         throw error2;
@@ -4450,16 +4824,29 @@ function acquireFileLease(file, staleMs) {
   if (first)
     return first;
   const current = readLease(file);
-  let observedAt = Number(current?.createdAt ?? 0);
-  if (!observedAt) {
-    try {
-      observedAt = fs5.statSync(file).mtimeMs;
-    } catch {
-      return null;
-    }
+  let observedStat;
+  try {
+    observedStat = fs5.statSync(file);
+  } catch {
+    return null;
   }
+  const observedAt = Math.max(Number(current?.createdAt ?? 0), observedStat.mtimeMs);
   const age = Date.now() - observedAt;
-  if (current?.pid && processAlive(current.pid) || age <= staleMs)
+  const livePidCeiling = Math.max(ONE_HOUR_MS, staleMs * 4);
+  if (age <= staleMs || current?.pid && processAlive(current.pid) && age <= livePidCeiling)
+    return null;
+  const latest = readLease(file);
+  let latestStat;
+  try {
+    latestStat = fs5.statSync(file);
+  } catch {
+    return null;
+  }
+  const latestAt = Math.max(Number(latest?.createdAt ?? 0), latestStat.mtimeMs);
+  const latestAge = Date.now() - latestAt;
+  if (latestAge <= staleMs || latest?.pid && processAlive(latest.pid) && latestAge <= livePidCeiling)
+    return null;
+  if (current?.token ? latest?.token !== current.token : latestStat.dev !== observedStat.dev || latestStat.ino !== observedStat.ino || latestStat.size !== observedStat.size || latestStat.mtimeMs !== observedStat.mtimeMs)
     return null;
   try {
     fs5.unlinkSync(file);
@@ -4471,6 +4858,8 @@ function acquireFileLease(file, staleMs) {
 function releaseFileLease(lease) {
   if (!lease)
     return;
+  clearInterval(lease.heartbeat);
+  lease.heartbeat = undefined;
   const current = readLease(lease.file);
   if (current?.token !== lease.token)
     return;
@@ -5221,7 +5610,12 @@ function planCompactionWindow(input) {
     overflowedContext,
     finalSummaryAllowanceTokens
   } = input;
-  const allMessageTokens = messageTokens.reduce((sum, tokens) => sum + tokens, 0);
+  const tokenPrefix = new Array(messageTokens.length + 1);
+  tokenPrefix[0] = 0;
+  for (let index = 0;index < messageTokens.length; index++) {
+    tokenPrefix[index + 1] = tokenPrefix[index] + messageTokens[index];
+  }
+  const allMessageTokens = tokenPrefix[messageTokens.length];
   const messageScale = totalTokens > 0 && allMessageTokens > totalTokens ? totalTokens / allMessageTokens : 1;
   const fixedContextTokens = Math.max(0, totalTokens - allMessageTokens);
   const adaptiveKeepTokens = modelContextWindow ? Math.min(profileCfg.keepRecentTokens * 2, Math.max(profileCfg.keepRecentTokens, modelContextWindow * 0.04)) : profileCfg.keepRecentTokens;
@@ -5244,39 +5638,50 @@ function planCompactionWindow(input) {
     keepFrom = i;
   }
   const relaxedSoftBoundaries = [];
-  const retainedAt = (from) => Math.round(messageTokens.slice(from).reduce((sum, tokens) => sum + tokens, 0) * messageScale);
+  const retainedAt = (from) => Math.round((allMessageTokens - tokenPrefix[from]) * messageScale);
+  const toolCallIndex = buildToolCallBoundaryIndex(msgs);
   const effectiveRetentionCeiling = Math.max(retentionCeiling, retainedAt(keepFrom));
   let hardBoundaryAdjusted = false;
   const trySoftBoundary = (kind, candidate) => {
     if (candidate === undefined || candidate >= keepFrom)
       return;
-    const guarded = guardToolCallBoundary(msgs, candidate);
+    const guarded = guardToolCallBoundary(msgs, candidate, toolCallIndex);
     if (retainedAt(guarded) <= effectiveRetentionCeiling) {
       keepFrom = guarded;
       hardBoundaryAdjusted ||= guarded !== candidate;
     } else
       relaxedSoftBoundaries.push(kind);
   };
-  const users = msgs.map((entry, index) => ({ index, role: entry.message?.role })).filter((entry) => entry.role === "user");
-  const protectedUser = users.at(users.length >= 2 ? -2 : -1);
-  trySoftBoundary("recent-user-turn", protectedUser?.index);
+  let userOrdinal = 0;
+  let protectedUserIndex;
+  for (let index = msgs.length - 1;index >= 0; index--) {
+    const message = msgs[index].message;
+    if (!isRecord(message) || message.role !== "user")
+      continue;
+    userOrdinal++;
+    protectedUserIndex = index;
+    if (userOrdinal === 2)
+      break;
+  }
+  trySoftBoundary("recent-user-turn", protectedUserIndex);
   const anchor = smartKeepBoundaryCandidates(msgs, keepFrom, branch).find((candidate) => candidate.kind === "anchor");
   trySoftBoundary("anchor", anchor?.keepFrom);
   const topical = smartKeepBoundaryCandidates(msgs, keepFrom).find((candidate) => candidate.kind === "topical");
   trySoftBoundary("topical", topical?.keepFrom);
   const boundaryBeforeHardGuard = keepFrom;
-  const backwardBoundary = guardToolCallBoundary(msgs, keepFrom);
-  const forwardBoundary = retainedAt(backwardBoundary) > effectiveRetentionCeiling ? advancePastToolCallBoundary(msgs, keepFrom) : keepFrom;
+  const backwardBoundary = guardToolCallBoundary(msgs, keepFrom, toolCallIndex);
+  const forwardBoundary = retainedAt(backwardBoundary) > effectiveRetentionCeiling ? advancePastToolCallBoundary(msgs, keepFrom, toolCallIndex) : keepFrom;
   keepFrom = forwardBoundary > keepFrom && forwardBoundary < msgs.length && retainedAt(forwardBoundary) <= effectiveRetentionCeiling ? forwardBoundary : backwardBoundary;
   hardBoundaryAdjusted ||= keepFrom !== boundaryBeforeHardGuard;
-  const compactTokens = Math.round(messageTokens.slice(0, keepFrom).reduce((sum, tokens) => sum + tokens, 0) * messageScale);
+  const compactTokens = Math.round(tokenPrefix[keepFrom] * messageScale);
   const retainedTokens = retainedAt(keepFrom);
   const projectedAfterTokens = fixedContextTokens + retainedTokens + finalSummaryAllowance;
   const projectedSavedTokens = Math.max(0, totalTokens - projectedAfterTokens);
   const projectedYield = totalTokens > 0 ? projectedSavedTokens / totalTokens : 0;
   const targetAfterTokens = !force && modelContextWindow ? modelContextWindow * targetPercent / 100 : fixedContextTokens + effectiveRetentionCeiling + finalSummaryAllowance;
   let reason = "viable";
-  if (msgs[keepFrom]?.message?.role === "toolResult")
+  const firstKeptMessage = msgs[keepFrom]?.message;
+  if (isRecord(firstKeptMessage) && firstKeptMessage.role === "toolResult")
     reason = "unsafe-tool-boundary";
   else if (keepFrom <= 0)
     reason = "no-eligible-prefix";
@@ -5315,7 +5720,8 @@ function resolveCompactionWindow(rc) {
     return null;
   }
   const mode = rc.mode ?? (rc.profile ? modeFromLegacyProfile(rc.profile) : "balanced");
-  const overflowedContext = !!rc.flags.overflowRecovery || !!rc.ctx.model && totalTokens > rc.ctx.model.contextWindow;
+  const modelContextWindow = rc.ctx.model?.contextWindow;
+  const overflowedContext = !!rc.flags.overflowRecovery || Number.isFinite(modelContextWindow) && (modelContextWindow ?? 0) > 0 && totalTokens > modelContextWindow;
   const plan = planCompactionWindow({
     msgs,
     branch,
@@ -5339,7 +5745,7 @@ function resolveCompactionWindow(rc) {
   if (overflowedContext && plan.relaxedSoftBoundaries.length) {
     rc.notify("Context exceeds the active model window. EESV will summarize through soft recent-turn/checkpoint protections while preserving complete tool-call pairs; native fallback would resend the oversized context.", "warning");
   }
-  const contextPercent = rc.ctx.model && totalTokens ? totalTokens / rc.ctx.model.contextWindow * 100 : 0;
+  const contextPercent = safeContextPercent(totalTokens, modelContextWindow);
   if (rc.flags.force && rc.config.minContextPercent > 0 && contextPercent < rc.config.minContextPercent) {
     rc.notify("Manual compaction override at " + Math.round(contextPercent) + "% (" + totalTokens.toLocaleString() + "t): compacting about " + plan.compactTokens.toLocaleString() + "t while preserving " + plan.retainedTokens.toLocaleString() + "t of recent context. Early compaction is lossy; verification remains fail-closed.", "warning");
   }
@@ -5394,8 +5800,8 @@ function prepareManualPreflightContext(ctx, summaryModel, tokenCalibration) {
   const msgs = branch.filter((entry) => entry.type === "message" && entry.message != null);
   const totalTokens = ctx.getContextUsage()?.tokens ?? 0;
   const modelContextWindow = ctx.model?.contextWindow;
-  const contextWindowTokens = modelContextWindow ?? 0;
-  const contextPercent = contextWindowTokens > 0 ? totalTokens / contextWindowTokens * 100 : 0;
+  const contextWindowTokens = Number.isFinite(modelContextWindow) && (modelContextWindow ?? 0) > 0 ? modelContextWindow : 0;
+  const contextPercent = safeContextPercent(totalTokens, modelContextWindow);
   const toolPercent = computeToolCharPercentage(branch);
   const overflowedContext = contextWindowTokens > 0 && totalTokens > contextWindowTokens;
   const estimator = makeTokenEstimator(summaryModel.provider, summaryModel.id, tokenCalibration);
@@ -5461,10 +5867,11 @@ function planManualPreflight(ctx, summaryModel, mode, tokenCalibration, config,
 }
 
 // src/ui/overlays.ts
-import path9 from "path";
+import path10 from "path";
 
 // src/utils/state.ts
 import fs6 from "fs";
+import path9 from "path";
 function getStatePath(projectId, state) {
   if (!state?.scope)
     return compactionStateFile(projectId);
@@ -5510,9 +5917,30 @@ function freshState(fp, data) {
   }
   return sanitizeCompactionStateEvidence(data);
 }
+function pruneScopedStateSnapshots(target) {
+  try {
+    const dir = path9.dirname(target);
+    const snapshots = fs6.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => {
+      const file = path9.join(dir, entry.name);
+      return { file, mtimeMs: fs6.statSync(file).mtimeMs };
+    }).filter((entry) => entry.file !== target).sort((a, b) => b.mtimeMs - a.mtimeMs || b.file.localeCompare(a.file));
+    for (const snapshot of snapshots.slice(Math.max(0, STATE_SNAPSHOT_MAX_FILES - 1))) {
+      try {
+        fs6.unlinkSync(snapshot.file);
+      } catch (error2) {
+        debug("state snapshot cleanup failed", error2);
+      }
+    }
+  } catch (error2) {
+    debug("state snapshot retention failed", error2);
+  }
+}
 function saveCompactionState(projectId, state) {
   try {
-    writeJsonSync(getStatePath(projectId, state), sanitizeCompactionStateEvidence(state), true);
+    const target = getStatePath(projectId, state);
+    writeJsonSync(target, sanitizeCompactionStateEvidence(state), true);
+    if (state.scope)
+      pruneScopedStateSnapshots(target);
     return true;
   } catch (error2) {
     warn("saveCompactionState failed", error2);
@@ -5520,6 +5948,11 @@ function saveCompactionState(projectId, state) {
   }
 }
 function loadScopedCompactionState(scope, branchEntryIds2 = []) {
+  const snapshotProbe = scopedCompactionStateFile(scope.projectId, scope.sessionId, "__snapshot__");
+  let availableSnapshots = new Set;
+  try {
+    availableSnapshots = new Set(fs6.readdirSync(path9.dirname(snapshotProbe), { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name));
+  } catch {}
   const ancestry = Array.from(new Set([
     ...branchEntryIds2,
     ...scope.branchHeadId ? [scope.branchHeadId] : []
@@ -5527,6 +5960,8 @@ function loadScopedCompactionState(scope, branchEntryIds2 = []) {
   const valid = (state, branchHeadId) => Boolean(state?.scope?.schemaVersion === 2 && state.scope.projectId === scope.projectId && state.scope.sessionId === scope.sessionId && typeof state.scope.branchHeadId === "string" && (!branchHeadId || state.scope.branchHeadId === branchHeadId));
   for (const branchHeadId of ancestry) {
     const fp = scopedCompactionStateFile(scope.projectId, scope.sessionId, branchHeadId);
+    if (!availableSnapshots.has(path9.basename(fp)))
+      continue;
     const state = freshState(fp, readJsonSync(fp));
     if (valid(state, branchHeadId))
       return state;
@@ -5589,6 +6024,7 @@ function buildCompactionState(extraction, openLoops, report, nextActions, critic
   const fileNeedles = extraction.modifiedFiles.map((f) => ({ path: f.path, needles: buildPathNeedles(f.path) }));
   return {
     goal: extraction.mainGoal,
+    goalKey: extraction.mainGoal ? normalizeFactKey(extraction.mainGoal) : undefined,
     decisions: extraction.decisions.map((d) => ({
       id: ID_PREFIX.DECISION + ++decisionId,
       summary: d.summary.slice(0, TRUNC.DECISION_SUMMARY),
@@ -5662,10 +6098,13 @@ function mergeCompactionStates(previous, current) {
   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 oldGoal = activePrevious.goal && activeCurrent.goal && normalizeFactKey(activePrevious.goal) !== normalizeFactKey(activeCurrent.goal) ? ["Previous goal: " + activePrevious.goal] : [];
+  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] : [];
   return applyContinuityOverrides({
     ...activeCurrent,
     goal: activeCurrent.goal ?? activePrevious.goal,
+    goalKey: activeCurrent.goal ? currentGoalKey || undefined : (activePrevious.goalKey ?? previousGoalKey) || undefined,
     decisions,
     constraints,
     modifiedFiles: mergeBy(activeCurrent.modifiedFiles, activePrevious.modifiedFiles.filter((file) => !currentDeleted.has(normalizeFactKey(file))), normalizeFactKey, 100),
@@ -5757,7 +6196,9 @@ function computeDelta(prev, current) {
   ]);
   const resolvedErrors = prev.unresolvedErrors.filter((e) => resolvedErrorKeys.has(normalizeFactKey(e.message))).map((e) => e.message);
   const newErrors = current.unresolvedErrors.filter((e) => !prevErrorMsgs.has(normalizeFactKey(e.message))).map((e) => e.message);
-  const goalChanged = prev.goal !== current.goal && prev.goal !== null && current.goal !== null;
+  const previousGoalKey = prev.goalKey ?? (prev.goal ? normalizeFactKey(prev.goal) : "");
+  const currentGoalKey = current.goalKey ?? (current.goal ? normalizeFactKey(current.goal) : "");
+  const goalChanged = Boolean(previousGoalKey && currentGoalKey && previousGoalKey !== currentGoalKey);
   return {
     newDecisions,
     removedDecisions,
@@ -5824,7 +6265,7 @@ function ensurePinnedPaths(summary, pinned) {
   if (!pinned.length)
     return summary;
   const lower = summary.toLowerCase();
-  const missing = pinned.map((path9) => summaryEvidenceLine(path9, TRUNC.MESSAGE)).filter((path9) => path9 && !lower.includes(path9.toLowerCase()));
+  const missing = pinned.map((path10) => summaryEvidenceLine(path10, TRUNC.MESSAGE)).filter((path10) => path10 && !lower.includes(path10.toLowerCase()));
   if (!missing.length)
     return summary;
   const parsed = parseSummary(summary);
@@ -6123,7 +6564,7 @@ async function showResultScreen(ctx, details, extraction, services, opts = {}) {
         const f = modFiles[i];
         const fc = extraction.modifiedFiles.find((e) => e.path === f);
         const count = fc ? " (" + fc.toolCalls + "x)" : "";
-        c.addChild(new Text(theme.fg("success", "    \u270E ") + theme.fg("text", path9.basename(f)) + theme.fg("dim", count + " \u2192 " + f), 0, 0));
+        c.addChild(new Text(theme.fg("success", "    \u270E ") + theme.fg("text", path10.basename(f)) + theme.fg("dim", count + " \u2192 " + f), 0, 0));
       }
       if (modFiles.length > maxShow) {
         c.addChild(new Text(theme.fg("dim", "    + " + (modFiles.length - maxShow) + " more"), 0, 0));
@@ -6660,10 +7101,13 @@ function asBranchMessage(message) {
 function asSerializableMessages(msgs) {
   return msgs;
 }
+function scrubLlmMessages(msgs, scrubber) {
+  return scrubber.scrubValue(msgs).value;
+}
 
 // src/utils/session-log.ts
 import * as fs7 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 import { StringDecoder } from "string_decoder";
 import { convertToLlm } from "@earendil-works/pi-coding-agent";
 function getSessionsDir() {
@@ -6706,35 +7150,54 @@ function getMaxEntries() {
 }
 var logPathCache = new Map;
 var messageMapCache = new Map;
-function findSessionLogFile(sessionId) {
+function sessionDirectoryForCwd(cwd) {
+  const safeCwd = path11.resolve(cwd).replace(/^[/\\]/, "").replace(/[:/\\]/g, "-");
+  return path11.join(getSessionsDir(), "--" + safeCwd + "--");
+}
+function findLogInDirectory(directory, sessionId) {
+  if (!fs7.existsSync(directory))
+    return null;
+  if (/^[a-zA-Z0-9_-]+$/.test(sessionId)) {
+    const exact = path11.join(directory, sessionId + ".jsonl");
+    if (fs7.existsSync(exact))
+      return exact;
+  }
+  const match = fs7.readdirSync(directory, { withFileTypes: true }).find((entry) => entry.isFile() && entry.name.endsWith("_" + sessionId + ".jsonl"));
+  return match ? path11.join(directory, match.name) : null;
+}
+function findSessionLogFile(sessionId, cwd) {
   const home2 = process.env.HOME ?? "/tmp";
   const now = Date.now();
-  const remember = (path11) => {
-    lruSet(logPathCache, sessionId, { path: path11, expiresAt: now + LOG_PATH_CACHE_TTL_MS, home: home2 }, getMaxEntries());
-    return path11;
+  const directDirectory = cwd ? sessionDirectoryForCwd(cwd) : null;
+  const cacheKey = sessionId + "\x00" + (directDirectory ?? "*");
+  const remember = (foundPath) => {
+    lruSet(logPathCache, cacheKey, { path: foundPath, expiresAt: now + LOG_PATH_CACHE_TTL_MS, home: home2 }, getMaxEntries());
+    return foundPath;
   };
   try {
-    const cached = lruGet(logPathCache, sessionId);
+    const cached = lruGet(logPathCache, cacheKey);
     if (cached && cached.home === home2 && cached.expiresAt > now)
       return cached.path;
     const sessionsDir2 = getSessionsDir();
     if (!fs7.existsSync(sessionsDir2))
       return remember(null);
-    for (const subdir of fs7.readdirSync(sessionsDir2)) {
-      const subdirPath = path10.join(sessionsDir2, subdir);
-      const stat = fs7.statSync(subdirPath);
-      if (!stat.isDirectory())
+    if (directDirectory) {
+      const direct = findLogInDirectory(directDirectory, sessionId);
+      if (direct)
+        return remember(direct);
+    }
+    for (const subdir of fs7.readdirSync(sessionsDir2, { withFileTypes: true })) {
+      if (!subdir.isDirectory())
+        continue;
+      const subdirPath = path11.join(sessionsDir2, subdir.name);
+      if (subdirPath === directDirectory)
         continue;
-      const exact = path10.join(subdirPath, sessionId + ".jsonl");
-      if (fs7.existsSync(exact))
-        return remember(exact);
-      const files = fs7.readdirSync(subdirPath);
-      const match = files.find((f) => f.endsWith("_" + sessionId + ".jsonl"));
-      if (match)
-        return remember(path10.join(subdirPath, match));
+      const found = findLogInDirectory(subdirPath, sessionId);
+      if (found)
+        return remember(found);
     }
-  } catch (e) {
-    debug("findSessionLogFile failed", e);
+  } catch (error2) {
+    debug("findSessionLogFile failed", error2);
   }
   return remember(null);
 }
@@ -6758,8 +7221,8 @@ function normalizeLogMessage(msg, entryTimestamp) {
 function hasTruncatedMessages(msgs) {
   return msgs.some((m) => TRUNCATE_RE.test(extractText(m.content)));
 }
-async function readOriginalMessageMap(sessionId, wantedIds) {
-  const logPath = findSessionLogFile(sessionId);
+async function readOriginalMessageMap(sessionId, wantedIds, cwd) {
+  const logPath = findSessionLogFile(sessionId, cwd);
   if (!logPath) {
     debug("Session log not found for " + sessionId);
     return null;
@@ -6804,9 +7267,9 @@ async function readOriginalMessageMap(sessionId, wantedIds) {
     return null;
   }
 }
-async function resolveCompactionMessages(sessionId, toCompactEntries) {
+async function resolveCompactionMessages(sessionId, toCompactEntries, cwd) {
   const wantedIds = new Set(toCompactEntries.flatMap((entry) => entry.id ? [entry.id] : []));
-  const logMap = await readOriginalMessageMap(sessionId, wantedIds);
+  const logMap = await readOriginalMessageMap(sessionId, wantedIds, cwd);
   if (!logMap)
     return null;
   let restoredCount = 0;
@@ -6840,7 +7303,7 @@ async function recoverSessionLog(rc) {
     return convertToLlm2([asBranchMessage(entry.message)]).map((message) => ({ entryId: entry.id, message }));
   });
   if (hasTruncatedMessages(resolved.map((item) => item.message))) {
-    const fromLog = await resolveCompactionMessages(rc.sessionId, rc.toCompact);
+    const fromLog = await resolveCompactionMessages(rc.sessionId, rc.toCompact, rc.ctx.cwd);
     if (fromLog) {
       resolved = fromLog;
       rc.notify("Using untruncated session log (" + resolved.length + " msgs)", "info");
@@ -7028,21 +7491,26 @@ function extractWithCache(rc) {
   const currentEntryIds = rc.toCompact.map((e) => e.id);
   const selectedMessages = rc.llmMessages;
   const pruning = pruneRedundant(selectedMessages);
+  const pruningUnchanged = pruning.messages.length === selectedMessages.length && pruning.messages.every((message, index) => message === selectedMessages[index]);
   const currentKeptEntryIds = pruning.keptIndices.map((i) => rc.llmEntryIds[i]).filter((id) => typeof id === "string");
   if (pruning.prunedCount > 0) {
     rc.notify("Pruning: " + pruning.prunedCount + " msgs removed (" + pruning.reasons.map((r) => r.count + "x " + r.reason).join(", ") + ")", "info");
   }
-  rc.llmMessages = pruning.messages;
+  const scrubbedMessages = scrubLlmMessages(pruning.messages, rc.services.scrubber);
+  pruning.messages = scrubbedMessages;
+  rc.llmMessages = scrubbedMessages;
   const pruneEnd = Date.now();
   markMeasuredPhase(rc, "prune", extractStepStart, pruneEnd);
   const extractionStart = pruneEnd;
-  const convText = serializeConversation(asSerializableMessages(rc.llmMessages));
+  const convText = rc.services.scrubber.scrubText(serializeConversation(asSerializableMessages(rc.llmMessages))).value;
   const convTokens = rc.estimator.text(convText);
   let preparedBackup;
   if (rc.config.backupEnabled) {
-    const unchanged = pruning.messages.length === selectedMessages.length && pruning.messages.every((message, index) => message === selectedMessages[index]);
     const materializeBackup = () => {
-      const backupText = unchanged ? convText : serializeConversation(asSerializableMessages(selectedMessages));
+      if (pruningUnchanged)
+        return convText;
+      const safeMessages = scrubLlmMessages(selectedMessages, rc.services.scrubber);
+      const backupText = serializeConversation(asSerializableMessages(safeMessages));
       return rc.services.scrubber.scrubText(backupText).value;
     };
     preparedBackup = prepareConversationBackup(materializeBackup, rc.sessionId, {
@@ -7058,6 +7526,7 @@ function extractWithCache(rc) {
   const currentFirstId = rc.toCompact[0]?.id;
   const currentLastId = rc.toCompact[rc.toCompact.length - 1]?.id;
   let cacheUsable = false;
+  let cacheExact = false;
   let keptCount = 0;
   if (cachedExt) {
     const hasNewFp = !!(cachedExt.keptEntryIdsFp && cachedExt.entryIdsFp);
@@ -7066,9 +7535,11 @@ function extractWithCache(rc) {
     const prunedPrefixMatch = hasNewFp ? isPrefixOf(cachedExt.keptEntryIdsFp, currentKeptEntryIds) : legacyPrefixMatch(cachedExt.keptEntryIds, currentKeptEntryIds);
     keptCount = hasNewFp ? cachedExt.keptEntryIdsFp?.count ?? 0 : cachedExt.keptEntryIds?.length ?? 0;
     if (hasNewFp || hasLegacy) {
-      cacheUsable = branchPrefixMatch && prunedPrefixMatch && cachedExt.messageCount === keptCount && cachedExt.messageCount < rc.llmMessages.length;
+      const boundedCacheShape = cachedExt.extraction.modifiedFiles.length <= EXTRACTION_LIMITS.MODIFIED_FILES && (cachedExt.extraction.referencedFiles?.length ?? 0) <= EXTRACTION_LIMITS.REFERENCED_FILES && cachedExt.extraction.readFiles.length <= EXTRACTION_LIMITS.READ_FILES && cachedExt.extraction.deletedFiles.length <= EXTRACTION_LIMITS.DELETED_FILES && cachedExt.extraction.errors.length <= EXTRACTION_LIMITS.ERRORS && cachedExt.extraction.decisions.length <= EXTRACTION_LIMITS.DECISIONS && cachedExt.extraction.constraints.length <= EXTRACTION_LIMITS.CONSTRAINTS && cachedExt.extraction.topics.length <= EXTRACTION_LIMITS.TOPICS && cachedExt.extraction.timeline.length <= EXTRACTION_LIMITS.TIMELINE && (cachedExt.extraction.mediaAttachments?.length ?? 0) <= EXTRACTION_LIMITS.MEDIA_ATTACHMENTS;
+      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" : cachedExt.messageCount !== keptCount ? "cache-shape-mismatch" : "no-new-pruned-messages";
+        missReason = !branchPrefixMatch ? "entry-prefix-mismatch" : !prunedPrefixMatch ? "pruned-prefix-changed" : !boundedCacheShape ? "cache-evidence-unbounded" : cachedExt.messageCount !== keptCount ? "cache-shape-mismatch" : "cache-domain-ahead";
       }
     } else {
       missReason = "legacy-no-kept-entryids";
@@ -7076,12 +7547,18 @@ function extractWithCache(rc) {
     }
   }
   if (cacheUsable && cachedExt) {
-    const newMsgs = rc.llmMessages.slice(cachedExt.messageCount);
-    const deltaTcIdx = buildToolCallIndex(newMsgs);
-    const delta = extractStructured(newMsgs, rc.profileCfg, deltaTcIdx);
-    extraction = mergeExtractions(cachedExt.extraction, delta, cachedExt.messageCount, newMsgs, deltaTcIdx);
-    rc.notify("Phase 1 Incremental: " + cachedExt.messageCount + " cached + " + newMsgs.length + " new pruned messages", "info");
-    rc.vlog("Incremental extraction \u2014 cached pruned messages: " + cachedExt.messageCount + ", current pruned: " + rc.llmMessages.length);
+    if (cacheExact) {
+      extraction = cachedExt.extraction;
+      rc.notify("Phase 1 Cached: exact pruned conversation reused", "info");
+      rc.vlog("Exact extraction cache hit \u2014 " + cachedExt.messageCount + " pruned messages");
+    } else {
+      const newMsgs = rc.llmMessages.slice(cachedExt.messageCount);
+      const deltaTcIdx = buildToolCallIndex(newMsgs);
+      const delta = extractStructured(newMsgs, rc.profileCfg, deltaTcIdx);
+      extraction = mergeExtractions(cachedExt.extraction, delta, cachedExt.messageCount, newMsgs, deltaTcIdx);
+      rc.notify("Phase 1 Incremental: " + cachedExt.messageCount + " cached + " + newMsgs.length + " new pruned messages", "info");
+      rc.vlog("Incremental extraction \u2014 cached pruned messages: " + cachedExt.messageCount + ", current pruned: " + rc.llmMessages.length);
+    }
     missReason = undefined;
     recordExtractionCacheHit(rc.services);
   } else {
@@ -7189,25 +7666,61 @@ var EXPLORATION_TOOLS = [
     parameters: Type.Object({ index: Type.Number(), context_radius: Type.Optional(Type.Number()) })
   }
 ];
-function executeExplorationTool(call, llmMessages) {
+function boundedExplorationValue(value, depth = 0) {
+  if (typeof value === "string") {
+    return value.length > TRUNC.PREVIEW_XL ? value.slice(0, TRUNC.PREVIEW_XL) + "\u2026" : value;
+  }
+  if (value == null || typeof value !== "object")
+    return value;
+  if (depth >= 3)
+    return "[bounded]";
+  if (Array.isArray(value))
+    return value.slice(0, 50).map((item) => boundedExplorationValue(item, depth + 1));
+  return Object.fromEntries(Object.entries(value).slice(0, 16).map(([key, item]) => [key, boundedExplorationValue(item, depth + 1)]));
+}
+function serializeExplorationResult(value, scrubber) {
+  const safe = boundedExplorationValue(scrubber.scrubValue(value).value);
+  const serialized = JSON.stringify(safe);
+  if (serialized.length <= MAX_EXPLORER_OUTPUT_CHARS)
+    return serialized;
+  let excerptChars = Math.max(0, Math.floor((MAX_EXPLORER_OUTPUT_CHARS - 160) / 2));
+  for (;; ) {
+    const result = JSON.stringify({
+      truncated: true,
+      originalChars: serialized.length,
+      head: serialized.slice(0, excerptChars),
+      tail: serialized.slice(-excerptChars)
+    });
+    if (result.length <= MAX_EXPLORER_OUTPUT_CHARS)
+      return result;
+    if (excerptChars === 0)
+      return JSON.stringify({ truncated: true, originalChars: serialized.length });
+    excerptChars = Math.max(0, excerptChars - Math.max(1, result.length - MAX_EXPLORER_OUTPUT_CHARS));
+  }
+}
+function executeExplorationTool(call, llmMessages, scrubber = new SecretScrubber) {
   const args = call.arguments ?? {};
   const boundedInteger = (value, fallback, min, max) => typeof value === "number" && Number.isFinite(value) ? Math.max(min, Math.min(max, Math.trunc(value))) : fallback;
+  let output;
   switch (call.name) {
     case "get_message_range": {
       const s = boundedInteger(args.start, 0, 0, llmMessages.length);
       const e = boundedInteger(args.end, llmMessages.length, s, llmMessages.length);
-      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+      output = llmMessages.slice(s, e).map((m, i) => ({
         idx: s + i,
         role: m?.role,
         preview: extractText(m?.content).slice(0, TRUNC.PREVIEW),
         toolCalls: getToolCallNames(m?.content),
         isError: m?.isError
-      })));
+      }));
+      break;
     }
     case "search_conversation": {
-      const q = (args.query ?? "").toLowerCase();
-      if (!q.trim())
-        return JSON.stringify([{ error: "query must be a non-empty string" }]);
+      const q = typeof args.query === "string" ? args.query.toLowerCase().trim() : "";
+      if (!q) {
+        output = [{ error: "query must be a non-empty string" }];
+        break;
+      }
       const matches = [];
       for (let i = 0;i < llmMessages.length && matches.length < 10; i++) {
         const m = llmMessages[i];
@@ -7216,68 +7729,91 @@ function executeExplorationTool(call, llmMessages) {
           matches.push({ idx: i, m });
           continue;
         }
-        const tcs = filterToolCalls(m?.content);
-        if (tcs.some((tc) => JSON.stringify(tc.arguments).toLowerCase().includes(q))) {
-          matches.push({ idx: i, m });
+        let argumentsMatch = false;
+        for (const tc of filterToolCalls(m?.content)) {
+          const stack = [{ value: tc.arguments, depth: 0 }];
+          let inspected = 0;
+          while (stack.length && inspected++ < 64 && !argumentsMatch) {
+            const current = stack.pop();
+            if (typeof current.value === "string") {
+              argumentsMatch = current.value.slice(0, 2000).toLowerCase().includes(q);
+            } else if (current.value && typeof current.value === "object" && current.depth < 3) {
+              const values = Array.isArray(current.value) ? current.value.slice(0, 16) : Object.values(current.value).slice(0, 16);
+              for (const value of values)
+                stack.push({ value, depth: current.depth + 1 });
+            }
+          }
+          if (argumentsMatch)
+            break;
         }
+        if (argumentsMatch)
+          matches.push({ idx: i, m });
       }
-      return JSON.stringify(matches.map(({ idx, m }) => ({
+      output = matches.map(({ idx, m }) => ({
         idx,
         role: m?.role,
         preview: extractText(m?.content).slice(0, TRUNC.PREVIEW)
-      })));
+      }));
+      break;
     }
     case "get_recent_user_messages": {
       const count = boundedInteger(args.count, 10, 1, 50);
-      return JSON.stringify(llmMessages.filter((m) => m?.role === "user").slice(-count).map((m) => extractText(m.content)));
+      output = llmMessages.filter((m) => m?.role === "user").slice(-count).map((m) => extractText(m.content).slice(0, TRUNC.PREVIEW_XL));
+      break;
     }
     case "get_context_around": {
       const idx = boundedInteger(args.index, 0, 0, Math.max(0, llmMessages.length - 1));
       const radius = boundedInteger(args.radius, 5, 0, 25);
       const s = Math.max(0, idx - radius), e = Math.min(llmMessages.length, idx + radius + 1);
-      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+      output = llmMessages.slice(s, e).map((m, i) => ({
         idx: s + i,
         role: m?.role,
         text: extractText(m?.content).slice(0, TRUNC.DETAIL),
         toolCalls: getToolCallNames(m?.content),
         isError: m?.isError
-      })));
+      }));
+      break;
     }
     case "get_file_changes": {
-      const target = (args.path ?? "").toLowerCase();
-      if (!target.trim())
-        return JSON.stringify([{ error: "path must be a non-empty string" }]);
+      const target = typeof args.path === "string" ? args.path.toLowerCase().trim() : "";
+      if (!target) {
+        output = [{ error: "path must be a non-empty string" }];
+        break;
+      }
       const results = [];
-      for (let i = 0;i < llmMessages.length; i++) {
-        const tcs = filterToolCalls(llmMessages[i]?.content);
-        for (const block of tcs) {
+      for (let i = 0;i < llmMessages.length && results.length < TRUNC.EXPLORE_RESULTS; i++) {
+        for (const block of filterToolCalls(llmMessages[i]?.content)) {
           const a = block.arguments ?? {};
-          const fileFields = [a.path, a.file, a.filePath, a.file_path].filter((v) => typeof v === "string").map((v) => v.toLowerCase());
-          const matchesPath = fileFields.some((f) => f.includes(target));
-          if (classifyTool(block.arguments) === "mutates" && matchesPath) {
-            const surgical = a.oldText != null || a.newText != null || a.edits != null || a.patch != null;
-            const preview = extractText(llmMessages[i]?.content).slice(0, TRUNC.PREVIEW_LONG);
-            results.push(surgical ? { idx: i, role: "assistant", toolCall: block.name ?? "mutates", args: block.arguments, preview } : { idx: i, role: "assistant", toolCall: block.name ?? "mutates", preview });
-          }
+          const fileFields = [a.path, a.file, a.filePath, a.file_path].filter((value) => typeof value === "string").map((value) => value.toLowerCase());
+          if (classifyTool(block.arguments) !== "mutates" || !fileFields.some((file) => file.includes(target)))
+            continue;
+          const preview = extractText(llmMessages[i]?.content).slice(0, TRUNC.PREVIEW_LONG);
+          const surgicalKeys = ["path", "file", "filePath", "file_path", "oldText", "newText", "edits", "patch"];
+          const argsPreview = Object.fromEntries(surgicalKeys.filter((key) => a[key] !== undefined).map((key) => [key, a[key]]));
+          const surgical = a.oldText != null || a.newText != null || a.edits != null || a.patch != null;
+          results.push(surgical ? { idx: i, role: "assistant", toolCall: block.name ?? "mutates", args: argsPreview, preview } : { idx: i, role: "assistant", toolCall: block.name ?? "mutates", preview });
         }
       }
-      return JSON.stringify(results.slice(0, TRUNC.EXPLORE_RESULTS) || [{ info: "No edits found for: " + args.path }]);
+      output = results.length ? results : [{ info: "No edits found for: " + args.path }];
+      break;
     }
     case "get_error_chain": {
       const errIdx = boundedInteger(args.index, 0, 0, Math.max(0, llmMessages.length - 1));
       const ctxRadius = boundedInteger(args.context_radius, 8, 0, 25);
       const s = Math.max(0, errIdx - ctxRadius), e = Math.min(llmMessages.length, errIdx + ctxRadius + 1);
-      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+      output = llmMessages.slice(s, e).map((m, i) => ({
         idx: s + i,
         role: m?.role,
         text: extractText(m?.content).slice(0, TRUNC.PREVIEW_XL),
         isError: m?.isError,
         toolCalls: getToolCallNames(m?.content)
-      })));
+      }));
+      break;
     }
     default:
-      return "Unknown tool: " + call.name;
+      output = { error: "Unknown tool: " + call.name };
   }
+  return serializeExplorationResult(output, scrubber);
 }
 function parseExplorationReport(text, llmMessages) {
   let json = text.trim();
@@ -7424,7 +7960,7 @@ async function exploreConversation(llmMessages, extraction, model, auth, prevSum
         probeResp
       ];
       for (const tc of toolCalls) {
-        const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages);
+        const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages, svc.scrubber);
         messages.push({ role: "toolResult", toolCallId: tc.id, toolName: tc.name, content: [{ type: "text", text: result }], isError: false, timestamp: Date.now() });
       }
       let rounds = 1;
@@ -7457,7 +7993,7 @@ async function exploreConversation(llmMessages, extraction, model, auth, prevSum
         }
         messages.push(response);
         for (const tc of nextToolCalls) {
-          const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages);
+          const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages, svc.scrubber);
           messages.push({ role: "toolResult", toolCallId: tc.id, toolName: tc.name, content: [{ type: "text", text: result }], isError: false, timestamp: Date.now() });
         }
       }
@@ -7737,7 +8273,41 @@ function fitChunkBudget(messages, maxTokens, estimator) {
       break;
     estimate = estimateChunkTokens(fitted, estimator);
   }
-  return fitted;
+  if (estimate <= maxTokens)
+    return fitted;
+  const rendered = fitted.map(renderBatchMessage).join(`
+`);
+  const marker = "[\u2026chunk evidence hard-bounded for synthesis\u2026]";
+  const candidate = (chars) => {
+    if (chars <= 0)
+      return [{ role: "user", content: marker }];
+    const head = Math.ceil(chars * 0.6);
+    return [{
+      role: "user",
+      content: rendered.slice(0, head) + `
+` + marker + `
+` + rendered.slice(-(chars - head))
+    }];
+  };
+  let best = candidate(0);
+  if (estimateChunkTokens(best, estimator) > maxTokens) {
+    if (estimateChunkTokens([], estimator) <= maxTokens)
+      return [];
+    throw new RangeError("Token estimator cannot represent a chunk within maxChunkTokens");
+  }
+  let low = 0;
+  let high = rendered.length;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const next = candidate(middle);
+    if (estimateChunkTokens(next, estimator) <= maxTokens) {
+      best = next;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return best;
 }
 function extendThroughToolResults(messages, start, proposedEnd) {
   const callIndexes = new Map;
@@ -7765,7 +8335,10 @@ function splitOversizedChunk(ch, maxTokens, estimator) {
     return [ch];
   if (ch.messages.length <= 1) {
     const messages = fitChunkBudget(ch.messages, maxTokens, estimator);
-    return [{ ...ch, tokenEstimate: estimateChunkTokens(messages, estimator), messages }];
+    const tokenEstimate = estimateChunkTokens(messages, estimator);
+    if (tokenEstimate > maxTokens)
+      throw new RangeError("Chunk budget postcondition failed");
+    return [{ ...ch, tokenEstimate, messages }];
   }
   const parts = [];
   let start = 0;
@@ -7781,11 +8354,14 @@ function splitOversizedChunk(ch, maxTokens, estimator) {
     }
     const end = extendThroughToolResults(ch.messages, start, proposedEnd);
     const messages = fitChunkBudget(ch.messages.slice(start, end), maxTokens, estimator);
+    const tokenEstimate = estimateChunkTokens(messages, estimator);
+    if (tokenEstimate > maxTokens)
+      throw new RangeError("Chunk budget postcondition failed");
     parts.push({
       ...ch,
       startIndex: ch.startIndex + start,
       endIndex: ch.startIndex + end - 1,
-      tokenEstimate: estimateChunkTokens(messages, estimator),
+      tokenEstimate,
       messages
     });
     start = end;
@@ -8361,24 +8937,24 @@ async function summarizeConversation(rc) {
         generationFallbacks.push(totalBatches - batchCallLimit + " synthesis batch budget fallback(s)");
       }
       let completed = totalBatches - batchCallLimit;
-      for (let wave = 0;wave < batchCallLimit; wave += concurrency) {
-        if (rc.services.budget.reason()) {
-          for (let index = wave;index < totalBatches; index++) {
-            results[index] = batches[index].map((chunk) => failedChunkSummary(chunk));
-          }
-          rc.notify("Synthesis budget reached \xB7 remaining batches use deterministic fallback", "info");
-          cacheable = false;
-          generationFallbacks.push("synthesis budget exhausted during batch wave");
-          break;
-        }
-        const waveBatches = batches.slice(wave, Math.min(wave + concurrency, batchCallLimit));
-        const wavePromises = waveBatches.map(async (batch, i) => {
-          const idx = wave + i;
-          try {
-            results[idx] = await summarizeBatch(batch, extraction, rc.summaryModel, summaryAuth, rc.cancellation.signal, rc.services, batchOutputLimit(rc.mode, batch.length, rc.providerCaps.maxOutputTokens), rc.sessionId);
-          } catch (err) {
-            errors[idx] = err instanceof Error ? err : new Error(String(err));
-            results[idx] = batch.map((ch) => failedChunkSummary(ch));
+      let nextBatch = 0;
+      let budgetStopped = false;
+      const runWorker = async () => {
+        while (true) {
+          const idx = nextBatch++;
+          if (idx >= batchCallLimit)
+            return;
+          if (budgetStopped || rc.services.budget.reason()) {
+            budgetStopped = true;
+            results[idx] = batches[idx].map((chunk) => failedChunkSummary(chunk));
+          } else {
+            try {
+              const batch = batches[idx];
+              results[idx] = await summarizeBatch(batch, extraction, rc.summaryModel, summaryAuth, rc.cancellation.signal, rc.services, batchOutputLimit(rc.mode, batch.length, rc.providerCaps.maxOutputTokens), rc.sessionId);
+            } catch (err) {
+              errors[idx] = err instanceof Error ? err : new Error(String(err));
+              results[idx] = batches[idx].map((chunk) => failedChunkSummary(chunk));
+            }
           }
           completed++;
           showProgressOverlay(rc.ctx, {
@@ -8392,8 +8968,14 @@ async function summarizeConversation(rc) {
             totalBatches,
             currentBatch: completed
           });
-        });
-        await Promise.all(wavePromises);
+        }
+      };
+      const workerCount = Math.max(1, Math.min(concurrency, batchCallLimit));
+      await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+      if (budgetStopped) {
+        rc.notify("Synthesis budget reached \xB7 remaining batches use deterministic fallback", "info");
+        cacheable = false;
+        generationFallbacks.push("synthesis budget exhausted during batch pool");
       }
       for (const r of results)
         if (r)
@@ -8483,29 +9065,56 @@ function classifyOutcomeClaim(claim) {
     return "file";
   return "generic";
 }
-function successfulToolSupportsClaim(claim, messages, extraction) {
+var successfulToolEvidenceCache = new WeakMap;
+function successfulToolEvidence(messages) {
+  const cached = successfulToolEvidenceCache.get(messages);
+  if (cached)
+    return cached;
+  const toolCalls = buildToolCallIndex(messages);
+  const evidence = [];
+  for (const message of messages) {
+    if (message.role !== "toolResult" || message.isError)
+      continue;
+    const call = toolCalls.get(message.toolCallId ?? "");
+    if (!call)
+      continue;
+    const result = extractText(message.content).slice(0, 8000);
+    if (!result.trim() || LIKELY_ERROR_RE.test(result))
+      continue;
+    const command = [call.arguments.command, call.arguments.cmd, call.arguments.script].find((value) => typeof value === "string") ?? "";
+    evidence.push({
+      name: normalizeToolName(call.name),
+      operation: classifyToolOperation(call.arguments, call.name),
+      command,
+      path: extractToolPath(call.arguments),
+      result
+    });
+  }
+  successfulToolEvidenceCache.set(messages, evidence);
+  return evidence;
+}
+function successfulToolSupportsClaim(claim, tools, extraction) {
   const shape = semanticShape(claim);
   const category = classifyOutcomeClaim(claim);
   if (category === "error" && extraction.errors.some((error2) => error2.resolved && hasSemanticEvidence(claim, error2.message)))
     return true;
   if (category === "file" && extraction.modifiedFiles.some((file) => claim.toLowerCase().includes(file.path.toLowerCase())))
     return true;
-  for (const message of messages) {
-    if (message.role !== "toolResult" || message.isError)
+  for (const tool of tools) {
+    const operationText = tool.name + " " + tool.command;
+    const operationSupports = category === "test" ? /\b(?:test|tests|pytest|jest|vitest|mocha|rspec)\b/i.test(operationText) : category === "build" ? /\b(?:build|compile|typecheck|tsc|check)\b/i.test(operationText) : category === "release" ? /\b(?:deploy|publish|release)\b/i.test(operationText) : category === "file" ? tool.operation === "mutate" || tool.operation === "delete" : category === "error" ? tool.operation === "execute" || tool.operation === "mutate" || tool.operation === "delete" : tool.operation !== "read" && tool.operation !== "search" && tool.operation !== "list";
+    if (!operationSupports)
       continue;
-    const bounded = extractText(message.content).slice(0, 8000);
-    if (!bounded.trim() || LIKELY_ERROR_RE.test(bounded))
-      continue;
-    if (hasSemanticEvidence(claim, bounded))
+    if (hasSemanticEvidence(claim, tool.result))
       return true;
-    const lower = bounded.toLowerCase();
+    const lower = tool.result.toLowerCase();
     if (category === "test" && /\b\d+\s+(?:tests?\s+)?pass(?:ed)?\b/.test(lower) && !/\b(?:fail(?:ed|ures?)?|errors?)\s*[:=]?\s*[1-9]\d*\b/.test(lower))
       return true;
-    if (category === "build" && /\b(?:build|compile|typecheck)\b/.test(lower) && /\b(?:succeeded|successful|passed|exit(?:ed)?\s+(?:code\s+)?0)\b/.test(lower))
+    if (category === "build" && /\b(?:succeeded|successful|passed|exit(?:ed)?\s+(?:code\s+)?0)\b/.test(lower))
       return true;
-    if (category === "release" && /\b(?:publish|release|deploy)\b/.test(lower) && /\b(?:succeeded|successful|completed|published|deployed|released)\b/.test(lower))
+    if (category === "release" && /\b(?:succeeded|successful|completed|published|deployed|released)\b/.test(lower))
       return true;
-    if (category === "error" && shape.concepts.length > 0 && /\b(?:fixed|resolved|passed|succeeded|successful)\b/.test(lower) && hasSemanticEvidence(claim, bounded))
+    if (category === "error" && shape.concepts.length > 0 && /\b(?:fixed|resolved|passed|succeeded|successful)\b/.test(lower) && hasSemanticEvidence(claim, tool.result))
       return true;
   }
   return false;
@@ -8653,9 +9262,15 @@ function stemToken(token) {
 function semanticTokens(text) {
   return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2);
 }
-function evidenceFragments(text) {
-  const fragments = text.split(/\r?\n/).flatMap((line) => [line, ...line.split(/[.;]/)]).map((part) => part.replace(/^\s*[-*\d.)]+\s*/, "").trim()).filter(Boolean);
-  return Array.from(new Set(fragments));
+var semanticShapeCache = new Map;
+var semanticFragmentCache = new Map;
+function semanticFragments(text) {
+  const cached = lruGet(semanticFragmentCache, text);
+  if (cached)
+    return cached;
+  const fragments = Array.from(new Set(text.split(/\r?\n/).flatMap((line) => [line, ...line.split(/[.;]/)]).map((part) => part.replace(/^\s*[-*\d.)]+\s*/, "").trim()).filter(Boolean))).map(semanticTokens);
+  lruSet(semanticFragmentCache, text, fragments, 256);
+  return fragments;
 }
 function hasNearbyMarker(tokens, anchor, markers) {
   return tokens.some((token, index) => token === anchor && tokens.slice(Math.max(0, index - 2), index + 3).some((near) => markers.has(near)));
@@ -8679,20 +9294,24 @@ function hasEffectiveTargetNegation(tokens, anchor) {
   });
 }
 function semanticShape(source) {
+  const cached = lruGet(semanticShapeCache, source);
+  if (cached)
+    return cached;
   const sourceTokens = semanticTokens(source);
   const concepts = Array.from(new Set(sourceTokens.filter((token) => !/^\d+$/.test(token) && !SEMANTIC_STOP.has(token) && !NEGATION_MARKERS.has(token) && !CONDITION_MARKERS.has(token))));
   const negative = sourceTokens.some((token) => NEGATION_MARKERS.has(token));
   const conditional = sourceTokens.some((token) => CONDITION_MARKERS.has(token));
   const anchor = concepts.find((concept) => hasNearbyMarker(sourceTokens, concept, NEGATION_MARKERS)) ?? concepts[0] ?? "";
-  return { sourceTokens, concepts, anchor, negative, conditional };
+  const shape = { sourceTokens, concepts, anchor, negative, conditional };
+  lruSet(semanticShapeCache, source, shape, 512);
+  return shape;
 }
 function hasSemanticEvidence(source, target) {
   const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
   if (!concepts.length)
     return true;
   const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return evidenceFragments(target).some((fragment) => {
-    const tokens = semanticTokens(fragment);
+  return semanticFragments(target).some((tokens) => {
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
     if (overlap < required)
       return false;
@@ -8714,8 +9333,7 @@ function hasSemanticContradiction(source, target) {
   if (!anchor)
     return false;
   const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return evidenceFragments(target).some((fragment) => {
-    const tokens = semanticTokens(fragment);
+  return semanticFragments(target).some((tokens) => {
     if (!tokens.includes(anchor))
       return false;
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
@@ -8906,16 +9524,18 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
       gaps.push({ kind: "inconsistency", detail: "blocked-none: Blocked says none despite unresolved errors" });
       score -= 12;
     }
+    const doneRefs = new Set(extractFileRefs(doneSection).map(normalizePath));
     for (const file of extraction.modifiedFiles) {
-      const basename = file.path.split("/").pop() ?? "";
-      if (!doneSection.toLowerCase().includes(basename.toLowerCase()))
+      const uniqueNeedles = buildUniquePathNeedles(file.path, modifiedPaths);
+      if (!uniqueNeedles.some((needle) => doneRefs.has(normalizePath(needle))))
         continue;
       const unresolved = unresolvedEvidence.find((error2) => {
         const firstLine = error2.message.split(/\r?\n/, 1)[0] ?? "";
-        return extractFileRefs(firstLine).some((ref) => isKnownPathReference(ref, [file.path]));
+        const errorRefs = extractFileRefs(firstLine).map(normalizePath);
+        return uniqueNeedles.some((needle) => errorRefs.includes(normalizePath(needle)));
       });
       if (unresolved) {
-        gaps.push({ kind: "inconsistency", detail: basename + " marked Done but has unresolved error" });
+        gaps.push({ kind: "inconsistency", detail: file.path + " marked Done but has unresolved error" });
         score -= 5;
       }
     }
@@ -8937,8 +9557,9 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
     score -= 5;
   }
   if (evidence.sourceMessages) {
+    const tools = successfulToolEvidence(evidence.sourceMessages);
     for (const claim of outcomeClaims(summary)) {
-      if (!successfulToolSupportsClaim(claim, evidence.sourceMessages, extraction)) {
+      if (!successfulToolSupportsClaim(claim, tools, extraction)) {
         gaps.push({ kind: "unsupported-claim", claim });
         score -= 20;
       }
@@ -9050,6 +9671,28 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
   }
   return renderSummary(canonical, { canonicalHeadings: true });
 }
+function hasUnclosedMarkdownFence(markdown) {
+  let open = null;
+  for (const line of markdown.split(/\r?\n/)) {
+    const match = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (!match)
+      continue;
+    const marker = match[1][0];
+    if (!open) {
+      open = { marker, length: match[1].length };
+    } else if (marker === open.marker && match[1].length >= open.length && !match[2].trim()) {
+      open = null;
+    }
+  }
+  return open !== null;
+}
+function patchResponseIsTruncated(patched, stopReason) {
+  const reason = String(stopReason ?? "");
+  return /(?:length|truncat|max(?:imum)?[_ -]?(?:output[_ -]?)?tokens?|token[_ -]?limit)/i.test(reason) || /\u2026\u2702\d+\s*$/.test(patched) || hasUnclosedMarkdownFence(patched);
+}
+function sectionIdentity(section) {
+  return section.kind === "unknown" ? "unknown:" + section.heading.trim().toLowerCase() : section.kind;
+}
 async function patchSummary(summary, gaps, model, auth, signal, services) {
   const patchPrompt = `Correct every verification finding below WITHOUT restructuring the summary. Add missing evidence, remove fabricated references, and rewrite contradictory claims so they preserve the source constraint/decision polarity. Do not add a Verification Note.
 
@@ -9069,7 +9712,13 @@ Return the COMPLETE corrected summary in the same format.`;
     }, { apiKey: auth.apiKey, headers: auth.headers, maxTokens, signal }, services);
     const patched = response.content.filter((content) => content.type === "text").map((content) => content.text).join(`
 `).trim();
-    return patched.startsWith("##") ? patched : summary;
+    if (!patched.startsWith("##") || patchResponseIsTruncated(patched, response.stopReason))
+      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 preserved = originalSections.every((section) => !section.body.trim() || Boolean(patchedBodies.get(sectionIdentity(section))));
+    return preserved ? patched : summary;
   } catch (error2) {
     debug("patchSummary LLM failed", error2);
     return summary;
@@ -9186,7 +9835,7 @@ async function verifyAndPatch(rc) {
 
 // src/app/steps/state.ts
 import fs8 from "fs";
-import path11 from "path";
+import path12 from "path";
 
 // src/domain/yield-gate.ts
 class YieldGateError extends Error {
@@ -9273,7 +9922,7 @@ function buildState(rc) {
   currentState.factOverrides = prevState?.factOverrides ?? [];
   let compactionState = mergeCompactionStates(prevState, currentState);
   compactionState.deletedFiles = compactionState.deletedFiles.filter((file) => {
-    const candidate = path11.isAbsolute(file) ? file : path11.resolve(rc.ctx.cwd, file);
+    const candidate = path12.isAbsolute(file) ? file : path12.resolve(rc.ctx.cwd, file);
     return !fs8.existsSync(candidate);
   });
   if (preserve.length > 0) {
@@ -9369,7 +10018,7 @@ function buildState(rc) {
 // src/infra/context-graph.ts
 import { createHash as createHash3 } from "crypto";
 import fs9 from "fs";
-import path12 from "path";
+import path13 from "path";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var MAX_PROJECT_NODES = 2000;
@@ -9377,7 +10026,27 @@ var MAX_MANUAL_NODES = 500;
 var MAX_SESSION_NODES = 256;
 var MAX_QUERY_CANDIDATES = 80;
 var NINETY_DAYS_MS = 90 * 24 * 60 * 60 * 1000;
-var CONTEXT_GRAPH_SCHEMA_VERSION = 1;
+var CONTEXT_GRAPH_SCHEMA_VERSION = 2;
+function bunSqliteAdapter(db) {
+  return {
+    exec: (sql) => db.exec(sql),
+    query: (sql) => db.query(sql),
+    transaction: (fn) => (...args) => {
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = fn(...args);
+        db.exec("COMMIT");
+        return result;
+      } catch (error2) {
+        try {
+          db.exec("ROLLBACK");
+        } catch {}
+        throw error2;
+      }
+    },
+    close: () => db.close()
+  };
+}
 function nodeSqliteAdapter(db) {
   return {
     exec: (sql) => db.exec(sql),
@@ -9400,11 +10069,11 @@ function nodeSqliteAdapter(db) {
 }
 function openDatabase() {
   const fp = contextGraphFile();
-  ensureDir(path12.dirname(fp));
+  ensureDir(path13.dirname(fp));
   let db;
   if ("bun" in process.versions) {
     const { Database } = require2("bun:sqlite");
-    db = new Database(fp);
+    db = bunSqliteAdapter(new Database(fp));
   } else {
     const { DatabaseSync } = require2("node:sqlite");
     db = nodeSqliteAdapter(new DatabaseSync(fp));
@@ -9432,6 +10101,8 @@ function openDatabase() {
     );
     CREATE INDEX IF NOT EXISTS context_nodes_project_status
       ON context_nodes(project_id, status, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS context_nodes_lineage
+      ON context_nodes(project_id, session_id, source, branch_head_id, kind, fact_key, updated_at DESC);
     CREATE TABLE IF NOT EXISTS context_edges (
       project_id TEXT NOT NULL,
       from_id TEXT NOT NULL REFERENCES context_nodes(id) ON DELETE CASCADE,
@@ -9448,7 +10119,8 @@ function openDatabase() {
     );
   `);
   const version = db.query("PRAGMA user_version").get();
-  if (Number(version?.user_version ?? 0) < CONTEXT_GRAPH_SCHEMA_VERSION) {
+  const schemaVersion = Number(version?.user_version ?? 0);
+  if (schemaVersion < 1) {
     db.transaction(() => {
       db.exec(`
         DROP INDEX IF EXISTS context_nodes_fact;
@@ -9457,6 +10129,17 @@ function openDatabase() {
         DELETE FROM context_nodes WHERE source = 'compaction';
         CREATE UNIQUE INDEX context_nodes_fact
           ON context_nodes(project_id, session_id, kind, fact_key, COALESCE(branch_head_id, ''));
+        PRAGMA user_version = 1;
+      `);
+    })();
+  }
+  if (schemaVersion < 2) {
+    db.transaction(() => {
+      db.exec(`
+        DELETE FROM context_nodes_fts;
+        INSERT INTO context_nodes_fts(rowid, node_id, title, content, kind)
+          SELECT rowid, id, title, content, kind FROM context_nodes
+          WHERE status = 'active' AND kind NOT IN ('project', 'session');
         PRAGMA user_version = ${CONTEXT_GRAPH_SCHEMA_VERSION};
       `);
     })();
@@ -9469,10 +10152,19 @@ function stableId(...parts) {
 function factKey(text) {
   return normalizeFactKey(text) || text.trim().toLowerCase();
 }
+function removeFtsNode(db, nodeId) {
+  db.query(`
+    DELETE FROM context_nodes_fts
+    WHERE rowid = (SELECT rowid FROM context_nodes WHERE id = ?)
+  `).run(nodeId);
+}
 function syncFts(db, node) {
-  db.query("DELETE FROM context_nodes_fts WHERE node_id = ?").run(node.id);
+  const row = db.query("SELECT rowid FROM context_nodes WHERE id = ?").get(node.id);
+  if (!row)
+    return;
+  db.query("DELETE FROM context_nodes_fts WHERE rowid = ?").run(row.rowid);
   if (node.status === "active" && node.kind !== "project" && node.kind !== "session") {
-    db.query("INSERT INTO context_nodes_fts(node_id, title, content, kind) VALUES (?, ?, ?, ?)").run(node.id, node.title, node.content, node.kind);
+    db.query("INSERT INTO context_nodes_fts(rowid, node_id, title, content, kind) VALUES (?, ?, ?, ?, ?)").run(row.rowid, node.id, node.title, node.content, node.kind);
   }
 }
 function upsertNode(db, node, refresh = false) {
@@ -9541,13 +10233,22 @@ function branchLineage(scope) {
   return Array.from(new Set([...scope.branchEntryIds ?? [], scope.branchHeadId].filter((id) => typeof id === "string" && id.length > 0)));
 }
 function lineageFactRows(db, scope, kind, key) {
-  const lineage = new Set(branchLineage(scope));
-  const rows = db.query(`
+  const lineage = branchLineage(scope);
+  const params = [scope.projectId, scope.sessionId];
+  let branchClause = "AND branch_head_id IS NULL";
+  if (lineage.length > 0) {
+    branchClause = "AND branch_head_id IN (" + lineage.map(() => "?").join(",") + ")";
+    params.push(...lineage);
+  }
+  if (kind)
+    params.push(kind);
+  if (key)
+    params.push(key);
+  return db.query(`
     SELECT * FROM context_nodes
     WHERE project_id = ? AND session_id = ? AND source = 'compaction'
-      ${kind ? "AND kind = ?" : ""} ${key ? "AND fact_key = ?" : ""}
-  `).all(scope.projectId, scope.sessionId, ...kind ? [kind] : [], ...key ? [key] : []);
-  return rows.filter((row) => lineage.size > 0 ? Boolean(row.branch_head_id && lineage.has(row.branch_head_id)) : row.branch_head_id == null);
+      ${branchClause} ${kind ? "AND kind = ?" : ""} ${key ? "AND fact_key = ?" : ""}
+  `).all(...params);
 }
 function latestLineageFact(db, scope, kind, key) {
   const rank = new Map(branchLineage(scope).map((id, index) => [id, index]));
@@ -9605,10 +10306,9 @@ function pruneProject(db, projectId) {
     ORDER BY CASE WHEN status = 'active' THEN 1 ELSE 0 END, updated_at ASC
     LIMIT ?
   `).all(projectId, excess) : [];
-  const removeFts = db.query("DELETE FROM context_nodes_fts WHERE node_id = ?");
   const removeNode = db.query("DELETE FROM context_nodes WHERE id = ?");
   for (const victim of victims) {
-    removeFts.run(victim.id);
+    removeFtsNode(db, victim.id);
     removeNode.run(victim.id);
   }
   const staleSessions = db.query(`
@@ -9619,6 +10319,7 @@ function pruneProject(db, projectId) {
   for (const session of staleSessions)
     removeNode.run(session.id);
 }
+var activeCompactionIndexDatabase = null;
 function indexCompactionState(projectId, state) {
   const sessionId = state.scope?.sessionId;
   if (!sessionId || state.scope?.projectId !== projectId)
@@ -9630,8 +10331,9 @@ function indexCompactionState(projectId, state) {
     branchEntryIds: state.scope.branchAncestryIds
   };
   let db = null;
+  const ownsDatabase = activeCompactionIndexDatabase === null;
   try {
-    db = openDatabase();
+    db = activeCompactionIndexDatabase ?? openDatabase();
     const transaction = db.transaction(() => {
       const now = Date.now();
       const projectNode = makeNode({ ...scope, sessionId: "*", branchHeadId: undefined }, "project", "Project", projectId, { confidence: 1 });
@@ -9709,9 +10411,11 @@ function indexCompactionState(projectId, state) {
     warn("indexCompactionState failed", error2);
     return false;
   } finally {
-    try {
-      db?.close();
-    } catch {}
+    if (ownsDatabase) {
+      try {
+        db?.close();
+      } catch {}
+    }
   }
 }
 var pendingCompactionIndexes = new Map;
@@ -9721,8 +10425,20 @@ function drainCompactionIndexes() {
   compactionIndexTimer = null;
   const jobs = [...pendingCompactionIndexes.values()];
   pendingCompactionIndexes.clear();
-  for (const job of jobs)
-    indexCompactionState(job.projectId, job.state);
+  let db = null;
+  try {
+    db = openDatabase();
+    activeCompactionIndexDatabase = db;
+    for (const job of jobs)
+      indexCompactionState(job.projectId, job.state);
+  } catch (error2) {
+    warn("context graph index drain failed", error2);
+  } finally {
+    activeCompactionIndexDatabase = null;
+    try {
+      db?.close();
+    } catch {}
+  }
   if (pendingCompactionIndexes.size)
     armCompactionIndexDrain();
 }
@@ -9737,8 +10453,10 @@ function scheduleCompactionStateIndex(projectId, state) {
   if (!sessionId || !branchHeadId || state.scope?.projectId !== projectId)
     return false;
   const key = projectId + "\x00" + sessionId + "\x00" + branchHeadId;
-  if (!pendingCompactionIndexes.has(key) && pendingCompactionIndexes.size >= MAX_PENDING_COMPACTION_INDEXES) {
-    warn("context graph index queue full; newest derived update was rejected");
+  if (pendingCompactionIndexes.has(key))
+    pendingCompactionIndexes.delete(key);
+  if (pendingCompactionIndexes.size >= MAX_PENDING_COMPACTION_INDEXES) {
+    warn("context graph index queue full; new derived update was rejected");
     return false;
   }
   pendingCompactionIndexes.set(key, { projectId, state });
@@ -9760,9 +10478,8 @@ function closeContextMemory(projectId, kind, content, status) {
         UPDATE context_nodes SET status = ?, updated_at = ?
         WHERE project_id = ? AND kind = ? AND fact_key = ? AND source = 'manual' AND status = 'active'
       `).run(status, Date.now(), projectId, kind, factKey(content));
-      const remove = db.query("DELETE FROM context_nodes_fts WHERE node_id = ?");
       for (const row of rows)
-        remove.run(row.id);
+        removeFtsNode(db, row.id);
     });
     transaction();
     return rows.length;
@@ -9808,10 +10525,9 @@ function saveContextMemory(scope, memory) {
         ...duplicates.flatMap((item) => parsePaths(item.related_paths))
       ])).slice(0, 20);
       upsertNode(db, node, true);
-      const removeFts = db.query("DELETE FROM context_nodes_fts WHERE node_id = ?");
       const removeNode = db.query("DELETE FROM context_nodes WHERE id = ?");
       for (const duplicate of duplicates) {
-        removeFts.run(duplicate.id);
+        removeFtsNode(db, duplicate.id);
         removeNode.run(duplicate.id);
       }
       for (const file of relatedPaths) {
@@ -9838,7 +10554,7 @@ function searchRows(db, projectId, terms) {
   try {
     return db.query(`
       SELECT n.* FROM context_nodes_fts f
-      JOIN context_nodes n ON n.id = f.node_id
+      JOIN context_nodes n ON n.rowid = f.rowid
       WHERE context_nodes_fts MATCH ? AND n.project_id = ? AND n.status = 'active'
         AND n.kind NOT IN ('project', 'session')
       ORDER BY bm25(context_nodes_fts, 0.0, 3.0, 1.0, 0.5)
@@ -10130,8 +10846,8 @@ function buildSuccessMetrics(rc, status) {
     adapted: rc.adapted
   };
 }
-function recordSuccessMetrics(rc, status) {
-  appendMetricsSnapshot(rc.sessionId, buildSuccessMetrics(rc, status));
+async function recordSuccessMetrics(rc, status) {
+  await appendMetricsSnapshot(rc.sessionId, buildSuccessMetrics(rc, status));
   const ecs = getExtractionCacheStats(rc.services);
   const ms = getMetricsSummary(rc.services);
   if (status === "success" && ms.totalCalls > 0) {
@@ -10142,7 +10858,7 @@ function recordSuccessMetrics(rc, status) {
     rc.notify("Metrics: " + ms.totalCalls + " calls, " + inputLabel + ", " + ms.totalOutput + "t out, provider-cache " + providerCacheRate + "% (internal phases disabled), extraction-cache " + extractionCacheRate + "%, " + ms.avgLatency + "ms avg", "info");
   }
 }
-function recordFailureMetrics(rc, err, fields) {
+async function recordFailureMetrics(rc, err, fields) {
   const releaseChannel = rc.config?.telemetryChannel ?? loadConfig().telemetryChannel;
   const failureKind = classifyTelemetryFailure(err, rc.cancellation.timedOut);
   const gate = err && typeof err === "object" ? err : null;
@@ -10165,7 +10881,7 @@ function recordFailureMetrics(rc, err, fields) {
   const verificationScore = typeof gate?.score === "number" && Number.isFinite(gate.score) ? gate.score : undefined;
   const initialVerificationScore = typeof gate?.initialScore === "number" && Number.isFinite(gate.initialScore) ? gate.initialScore : undefined;
   const verificationGaps = typeof gate?.gapCount === "number" && Number.isInteger(gate.gapCount) && gate.gapCount >= 0 ? gate.gapCount : undefined;
-  appendMetricsLog(fields.sessionId ?? "unknown", {
+  await appendMetricsLog(fields.sessionId ?? "unknown", {
     runId: rc.runId,
     metricsSchemaVersion: 2,
     version: VERSION,
@@ -10252,7 +10968,7 @@ async function commitAppliedCompaction(pending) {
     failures.push("conversation backup");
   if (!pending.metricsSnapshot)
     return failures;
-  appendMetricsSnapshot(pending.sessionId, {
+  await appendMetricsSnapshot(pending.sessionId, {
     ...pending.metricsSnapshot,
     persistenceStatus: failures.length ? "partial" : "complete",
     persistenceFailures: failures.length ? failures : undefined,
@@ -10289,10 +11005,14 @@ function runDamageDetection(rc) {
   }
 }
 function stagePendingCompaction(rc, metricsSnapshot) {
+  const originBranchHeadId = branchEntryIds(rc.branch).at(-1);
+  if (!originBranchHeadId)
+    throw new Error("Pending compaction requires an identifiable branch head");
   const pending = {
     runId: rc.runId,
     summary: rc.finalSummary,
     firstKeptEntryId: rc.firstKeptId,
+    originBranchHeadId,
     tokensBefore: rc.totalTokens,
     details: rc.details,
     metricsSnapshot,
@@ -10349,7 +11069,9 @@ function makeBase(opts) {
   };
   const pipelineStart = Date.now();
   const requestedMode = opts.mode ?? modeFromLegacyProfile(opts.profile ?? "balanced");
-  const contextPercent = opts.ctx.getContextUsage()?.percent ?? 0;
+  const usage = opts.ctx.getContextUsage();
+  const reportedPercent = usage?.percent;
+  const contextPercent = Number.isFinite(reportedPercent) && (reportedPercent ?? 0) >= 0 ? reportedPercent : safeContextPercent(usage?.tokens, opts.ctx.model?.contextWindow);
   const mode = resolveMode(requestedMode, contextPercent);
   const profile = opts.mode ? MODE_POLICIES[mode].profile : opts.profile ?? MODE_POLICIES[mode].profile;
   return {
@@ -10483,7 +11205,7 @@ async function runSmartCompact(opts) {
     stated.vlog("Pipeline complete \u2014 method=" + stated.method + " calls=" + stated.llmCalls + " chunks=" + stated.chunkCount + " tokensSaved=" + stated.tokensSaved);
     markPhase(stated, "state");
     if (stated.flags.dryRun) {
-      recordSuccessMetrics(stated, "dry-run");
+      await recordSuccessMetrics(stated, "dry-run");
       stated.ctx.ui.notify("DRY RUN (" + stated.method + ", " + stated.mode + ") \u2014 " + stated.toCompact.length + " msgs, " + stated.llmCalls + " calls", "info");
       return { kind: "dry-run", details: stated.details };
     }
@@ -10506,7 +11228,7 @@ async function runSmartCompact(opts) {
       }
       if (decision !== "apply") {
         stated.pendingRef.clear(stated.sessionId);
-        recordSuccessMetrics(stated, "cancelled");
+        await recordSuccessMetrics(stated, "cancelled");
         stated.ctx.ui.notify("Compaction cancelled \u2014 current conversation unchanged", "info");
         return { kind: "cancelled", source: "user" };
       }
@@ -10532,7 +11254,7 @@ async function runSmartCompact(opts) {
     return willApply ? { kind: "apply-requested", pending } : { kind: "staged", pending };
   } catch (err) {
     runFailed = true;
-    recordFailureMetrics(finalRc ?? base, err, failureSummaryFields);
+    await recordFailureMetrics(finalRc ?? base, err, failureSummaryFields);
     throw err;
   } finally {
     opts.abortSignal?.removeEventListener("abort", abortFromHost);
@@ -10725,55 +11447,70 @@ function parseSmartCompactTool(params) {
 function createPendingSlot(opts) {
   const ttlMs = opts.ttlMs;
   const now = opts.now ?? Date.now;
-  const maxEntries = Math.max(1, opts.maxEntries ?? 16);
+  const maxEntries = Math.max(1, opts.maxEntries ?? 64);
   const entries = new Map;
+  let newestSessionId = null;
+  const refreshNewest = () => {
+    newestSessionId = null;
+    for (const sessionId of entries.keys())
+      newestSessionId = sessionId;
+  };
+  const deleteEntry = (sessionId) => {
+    if (!entries.delete(sessionId))
+      return;
+    if (newestSessionId === sessionId)
+      refreshNewest();
+  };
   const prune = () => {
-    const timestamp = now();
+    const current = now();
+    let removedNewest = false;
     for (const [sessionId, entry] of entries) {
-      if (timestamp - entry.createdAt > ttlMs)
-        entries.delete(sessionId);
-    }
-  };
-  const newest = () => {
-    let result;
-    for (const entry of entries.values()) {
-      if (!result || entry.createdAt >= result.createdAt)
-        result = entry;
+      if (current - entry.createdAt <= ttlMs)
+        continue;
+      entries.delete(sessionId);
+      if (newestSessionId === sessionId)
+        removedNewest = true;
     }
-    return result;
+    if (removedNewest)
+      refreshNewest();
   };
   return {
     set(pending) {
       prune();
       entries.delete(pending.sessionId);
-      while (entries.size >= maxEntries) {
-        const oldestSession = entries.keys().next().value;
-        if (!oldestSession)
+      entries.set(pending.sessionId, { value: pending, createdAt: now() });
+      newestSessionId = pending.sessionId;
+      while (entries.size > maxEntries) {
+        const oldest = entries.keys().next().value;
+        if (oldest === undefined)
           break;
-        entries.delete(oldestSession);
+        deleteEntry(oldest);
       }
-      entries.set(pending.sessionId, { value: pending, createdAt: now() });
     },
     consume(ctx) {
       const currentSessionId = resolveSessionId(ctx);
       const entry = entries.get(currentSessionId);
-      if (!entry) {
-        const other = entries.values().next().value;
-        return other ? { kind: "mismatch", expected: other.value.sessionId, actual: currentSessionId } : { kind: "empty" };
-      }
-      const ageMs = now() - entry.createdAt;
-      if (ageMs > ttlMs) {
-        entries.delete(currentSessionId);
-        return { kind: "expired", ageMs };
+      if (entry) {
+        const ageMs = now() - entry.createdAt;
+        if (ageMs > ttlMs) {
+          deleteEntry(currentSessionId);
+          prune();
+          return { kind: "expired", ageMs };
+        }
+        deleteEntry(currentSessionId);
+        return { kind: "ok", pending: entry.value };
       }
-      entries.delete(currentSessionId);
-      return { kind: "ok", pending: entry.value };
+      prune();
+      const other = newestSessionId == null ? undefined : entries.get(newestSessionId);
+      return other ? { kind: "mismatch", expected: other.value.sessionId, actual: currentSessionId } : { kind: "empty" };
     },
     clear(sessionId) {
       if (sessionId)
-        entries.delete(sessionId);
-      else
+        deleteEntry(sessionId);
+      else {
         entries.clear();
+        newestSessionId = null;
+      }
     },
     isPresent(sessionId) {
       prune();
@@ -10781,7 +11518,8 @@ function createPendingSlot(opts) {
     },
     peek(sessionId) {
       prune();
-      return (sessionId ? entries.get(sessionId) : newest())?.value ?? null;
+      const entry = sessionId ? entries.get(sessionId) : newestSessionId == null ? undefined : entries.get(newestSessionId);
+      return entry?.value ?? null;
     },
     size() {
       prune();
@@ -10861,18 +11599,30 @@ function createCompactionCommitStore(options = {}) {
 // src/app/native-continuity-bridge.ts
 import crypto6 from "crypto";
 import fs10 from "fs";
-import path13 from "path";
+import path14 from "path";
 var MAX_TEXT_BYTES = 256 * 1024;
 function sameScope(a, b) {
   return a.projectId === b.projectId && a.sessionId === b.sessionId && a.branchHeadId === b.branchHeadId;
 }
+function boundedContinuityText(text) {
+  const bytes = Buffer.from(text);
+  if (bytes.length <= MAX_TEXT_BYTES)
+    return text;
+  const marker = Buffer.from(`
+\u2026 [continuity truncated from ` + bytes.length + ` bytes]
+`);
+  let end = Math.max(0, MAX_TEXT_BYTES - marker.length);
+  while (end > 0 && (bytes[end] & 192) === 128)
+    end--;
+  return Buffer.concat([bytes.subarray(0, end), marker]).toString("utf8");
+}
 function createNativeContinuityBridge(opts = {}) {
   const ttlMs = Math.max(1, opts.ttlMs ?? SEVEN_DAYS_MS);
   const maxEntries = Math.max(1, opts.maxEntries ?? 64);
   const now = opts.now ?? Date.now;
   const dir = opts.dir ?? nativeContinuityDir();
-  const lockTarget = path13.join(dir, "bridge");
-  const fileFor = (scope) => path13.join(dir, crypto6.createHash("sha256").update(scope.projectId + "\x00" + scope.sessionId + "\x00" + scope.branchHeadId).digest("hex") + ".json");
+  const lockTarget = path14.join(dir, "bridge");
+  const fileFor = (scope) => path14.join(dir, crypto6.createHash("sha256").update(scope.projectId + "\x00" + scope.sessionId + "\x00" + scope.branchHeadId).digest("hex") + ".json");
   const validScope = (scope) => Boolean(scope.projectId && scope.sessionId && scope.branchHeadId);
   const readEntry = (file) => {
     try {
@@ -10897,7 +11647,7 @@ function createNativeContinuityBridge(opts = {}) {
     for (const name of names) {
       if (!/\.tmp\.\d+\.[0-9a-f]+$/i.test(name))
         continue;
-      const file = path13.join(dir, name);
+      const file = path14.join(dir, name);
       try {
         if (now() - fs10.statSync(file).mtimeMs > ONE_HOUR_MS)
           fs10.unlinkSync(file);
@@ -10905,7 +11655,7 @@ function createNativeContinuityBridge(opts = {}) {
     }
     const files = names.filter((file) => file.endsWith(".json"));
     for (const name of files) {
-      const file = path13.join(dir, name);
+      const file = path14.join(dir, name);
       const entry = readEntry(file);
       if (!entry || now() - entry.createdAt > ttlMs || entry.createdAt - now() > ttlMs) {
         try {
@@ -10939,8 +11689,9 @@ function createNativeContinuityBridge(opts = {}) {
   };
   return {
     stage(scope, text) {
-      if (!validScope(scope) || !text.trim() || Buffer.byteLength(text) > MAX_TEXT_BYTES)
+      if (!validScope(scope) || !text.trim())
         return;
+      const boundedText = boundedContinuityText(text);
       try {
         locked(() => {
           const target = fileFor(scope);
@@ -10948,7 +11699,7 @@ function createNativeContinuityBridge(opts = {}) {
             fs10.unlinkSync(target);
           } catch {}
           prune(1);
-          const entry = { schemaVersion: 1, scope, text, createdAt: now() };
+          const entry = { schemaVersion: 1, scope, text: boundedText, createdAt: now() };
           atomicWriteFileSync(target, JSON.stringify(entry));
           try {
             fs10.chmodSync(target, 384);
@@ -11013,8 +11764,15 @@ function createNativeContinuityBridge(opts = {}) {
 // src/index.ts
 function unwrapConsumed(result, ctx) {
   switch (result.kind) {
-    case "ok":
+    case "ok": {
+      const activeEntryIds = new Set(branchEntryIds(ctx.sessionManager.getBranch()));
+      if (!activeEntryIds.has(result.pending.originBranchHeadId) || !activeEntryIds.has(result.pending.firstKeptEntryId)) {
+        warn("Discarding pending smart compaction prepared for a divergent branch");
+        ctx.ui.notify("Divergent-branch pending smart compaction discarded", "warning");
+        return null;
+      }
       return result.pending;
+    }
     case "empty":
       return null;
     case "expired":
@@ -11181,7 +11939,7 @@ function smartCompactExtension(pi) {
       const scrubber = new SecretScrubber(config.scrubSecrets, config.scrubPii);
       const title = scrubber.scrubText(params.title?.trim() || "Saved " + params.kind).value;
       const content = scrubber.scrubText(params.content).value;
-      const relatedPaths = (params.related_paths ?? []).map((path14) => scrubber.scrubText(path14).value);
+      const relatedPaths = (params.related_paths ?? []).map((path15) => scrubber.scrubText(path15).value);
       const status = params.status ?? "active";
       if (!ctx.hasUI) {
         return { content: [{ type: "text", text: "Project memory requires an interactive host confirmation; nothing changed." }], details: undefined };
@@ -11219,7 +11977,10 @@ Paths: ` + relatedPaths.join(", ") : ""));
       await ctx.waitForIdle();
       try {
         const knownProviders = new Set(ctx.modelRegistry.getAvailable().map((model) => model.provider));
-        const parsedInput = parseSmartCompactCommand(args, (token) => /^[a-z0-9_.-]+\/[a-z0-9_.:-]+$/i.test(token) && Boolean(findModelById(ctx, token) || knownProviders.has(token.split("/")[0])));
+        const parsedInput = parseSmartCompactCommand(args, (token) => {
+          const [provider, ...modelPath] = token.split("/");
+          return /^[a-z0-9_.-]+$/i.test(provider) && modelPath.length > 0 && modelPath.every((segment) => /^[a-z0-9_.:-]+$/i.test(segment)) && Boolean(findModelById(ctx, token) || knownProviders.has(provider));
+        });
         if (!parsedInput.ok) {
           ctx.ui.notify(parsedInput.error, "error");
           return;
@@ -11366,7 +12127,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
         if (!args.trim()) {
           const usage = ctx.getContextUsage();
           const totalTokens = usage?.tokens ?? 0;
-          const pct = ctx.model && totalTokens ? Math.round(totalTokens / ctx.model.contextWindow * 100) : 0;
+          const pct = Math.round(safeContextPercent(totalTokens, ctx.model?.contextWindow));
           const cur = ctx.model;
           const initialRoutes = resolveModels(ctx, cur, config);
           if (!initialRoutes.sumModel) {
@@ -11442,7 +12203,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
       const totalTokens = usage?.tokens ?? 0;
       if (!totalTokens || totalTokens < MIN_TOKEN_THRESHOLD)
         return;
-      const pct = ctx.model && totalTokens ? totalTokens / ctx.model.contextWindow * 100 : 0;
+      const pct = safeContextPercent(totalTokens, ctx.model?.contextWindow);
       if (event.reason !== "overflow" && pct < config.minContextPercent)
         return;
       const cur = ctx.model;
@@ -11475,6 +12236,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
             overflowRecovery: event.reason === "overflow",
             maxLlmCalls: Math.min(config.maxLlmCalls, AUTO_TRIGGER_MAX_LLM_CALLS),
             timeoutMs: effectiveTimeoutMs,
+            abortSignal: event.signal,
             cancellationOut
           });
         } catch (err) {
@@ -11635,12 +12397,12 @@ Dashboard: ` + fp : "") }], details: undefined };
       }
       const usage = ctx.getContextUsage?.();
       const totalTokens = usage?.tokens ?? 0;
-      const rawPct = ctx.model && totalTokens ? totalTokens / ctx.model.contextWindow * 100 : 0;
-      const pct = Math.round(rawPct);
+      const contextPercent = safeContextPercent(totalTokens, ctx.model?.contextWindow);
+      const pct = Math.round(contextPercent);
       if (!totalTokens || totalTokens < MIN_TOKEN_THRESHOLD) {
         return { content: [{ type: "text", text: "Context is not large enough for compaction (" + totalTokens.toLocaleString() + " tokens, " + pct + "%). No action needed." }], details: undefined };
       }
-      if (rawPct < config.minContextPercent) {
+      if (contextPercent < config.minContextPercent) {
         return { content: [{ type: "text", text: "Context is only " + pct + "% full (" + totalTokens.toLocaleString() + " tokens). Compaction is not needed yet. The tool=97% in status means tool output ratio, NOT context usage." }], details: undefined };
       }
       const cur = ctx.model;