pi-smart-compact 8.0.1 → 8.0.3

package/dist/index.js

@@ -130,7 +130,7 @@ var init_mode_policy = __esm(() => {
 });
 
 // src/constants.ts
-var VERSION = "8.0.1", CHARS_PER_TOKEN = 3.8, COMPACT_SYSTEM_PREFIX, PROFILES, DEFAULT_CONFIG, NO_OP_RE, SHIFT_RE, CHOICE_RE, SINGLE_PASS_PREFIX, SINGLE_PASS_SUFFIX = `
+var VERSION = "8.0.3", CHARS_PER_TOKEN = 3.8, COMPACT_SYSTEM_PREFIX, PROFILES, DEFAULT_CONFIG, NO_OP_RE, SHIFT_RE, CHOICE_RE, SINGLE_PASS_PREFIX, SINGLE_PASS_SUFFIX = `
 {PREV_CONTEXT}
 
 {EXTRACTION_CONTEXT}
@@ -1314,6 +1314,12 @@ function isBenignSearchResult(tc, result) {
   const exit = result.match(/Command exited with code (\d+)\s*$/i)?.[1];
   return exit === undefined || exit === "1";
 }
+function hasCommandFailureSignal(text) {
+  if (/Command exited with code [1-9]\d*\s*$/i.test(text))
+    return true;
+  const firstLine = text.split(/\r?\n/).find((line) => line.trim())?.trim() ?? "";
+  return LIKELY_ERROR_RE.test(firstLine) || /^(?:npm\s+error|fatal:|traceback\b)/i.test(firstLine);
+}
 function catalogErrors(msgs, _tcIdx) {
   const tcIdx = _tcIdx ?? buildToolCallIndex(msgs);
   const errors = [];
@@ -1330,7 +1336,7 @@ function catalogErrors(msgs, _tcIdx) {
       continue;
     }
     if (tc && classifyToolOperation(tc.arguments, tc.name) === "execute") {
-      if (LIKELY_ERROR_RE.test(text) && text.length < ERROR_SCAN_MAX_LEN) {
+      if (hasCommandFailureSignal(text) && text.length < ERROR_SCAN_MAX_LEN) {
         errors.push({ index: i, tool: tc.name, message: text.slice(0, TRUNC.MESSAGE), retryAttempted: false, resolved: false });
       }
     }
@@ -3148,6 +3154,8 @@ function classifyTelemetryFailure(error, timedOut = false) {
   const text = (fields.name + " " + fields.code + " " + fields.message).toLowerCase();
   if (timedOut || /timeout|timed out|watchdog|deadline/.test(text))
     return "timeout";
+  if (fields.name.toLowerCase() === "verificationgateerror")
+    return "verification";
   if (/budgetexceeded|token budget|call budget|latency budget/.test(text))
     return "budget";
   if (fields.status === 429 || /rate.?limit|too many requests|quota/.test(text))
@@ -3160,6 +3168,8 @@ function classifyTelemetryFailure(error, timedOut = false) {
     return "cancelled";
   if (/native compaction|persist|write|rename|filesystem|sqlite|database/.test(text))
     return "persistence";
+  if (/verificationgateerror|verification gate|verification.*(?:gap|summary)/.test(text))
+    return "verification";
   if (/invalid|validation|schema|malformed|required/.test(text))
     return "validation";
   if (fields.status != null && fields.status >= 500 || /provider|api error|stream|network|fetch failed|socket/.test(text))
@@ -3292,6 +3302,7 @@ var init_telemetry = __esm(() => {
     "provider",
     "persistence",
     "validation",
+    "verification",
     "internal"
   ]);
 });
@@ -3614,6 +3625,7 @@ function buildDashboardInsights(entries, damageEntries = [], options = {}) {
     "provider",
     "persistence",
     "validation",
+    "verification",
     "internal"
   ]);
   for (const entry of entries) {
@@ -3704,6 +3716,9 @@ var init_summary_schema = __esm(() => {
 });
 
 // src/domain/summary-parse.ts
+function summaryEvidenceLine(value, maxLength) {
+  return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim().replace(/^(?:(?:#{1,6}|[-*+]|>)\s+)+/, "").slice(0, maxLength).trim();
+}
 function mergeBodies(first, second) {
   const seen = new Set;
   return [first, second].filter(Boolean).flatMap((body) => body.split(`
@@ -3824,9 +3839,17 @@ import fs5 from "fs";
 function getStatePath(projectId, state) {
   return state?.scope?.sessionId ? scopedCompactionStateFile(projectId, state.scope.sessionId) : compactionStateFile(projectId);
 }
+function isLegacySearchOutput(text) {
+  const firstLine = text.trim().split(/\r?\n/, 1)[0] ?? "";
+  return /^[^\s:][^:]*:\d+(?::\d+)?:/.test(firstLine);
+}
 function sanitizeCompactionStateEvidence(state) {
   const constraints = state.constraints.filter((item) => !isDiagnosticConstraintText(item.text));
-  return constraints.length === state.constraints.length ? state : { ...state, constraints };
+  const unresolvedErrors = state.unresolvedErrors.filter((item) => !isLegacySearchOutput(item.message));
+  const openLoops = state.openLoops.filter((item) => !isLegacySearchOutput(item.summary));
+  if (constraints.length === state.constraints.length && unresolvedErrors.length === state.unresolvedErrors.length && openLoops.length === state.openLoops.length)
+    return state;
+  return { ...state, constraints, unresolvedErrors, openLoops };
 }
 function freshState(fp, data) {
   if (!data)
@@ -3995,7 +4018,7 @@ function renderContinuityCapsule(state, maxChars = TRUNC.CONTINUITY_CAPSULE, exi
   const haystack = normalizeFactKey(existing);
   const lines = ["## Continuity Ledger"];
   const add = (label, value) => {
-    const text = value.trim();
+    const text = summaryEvidenceLine(value, TRUNC.MESSAGE);
     if (!text || haystack.includes(normalizeFactKey(text)))
       return;
     const line = "- " + label + ": " + text;
@@ -4023,8 +4046,9 @@ function injectOpenLoopsSection(summary, openLoops) {
     return summary;
   const body = openLoops.map((l) => {
     const prio = l.priority === "critical" || l.priority === "high" ? "[" + l.priority + "] " : "";
-    const files = l.files.length ? " \u2014 " + l.files.join(", ") : "";
-    return "- " + prio + l.summary + files;
+    const files = l.files.map((file) => summaryEvidenceLine(file, TRUNC.MESSAGE)).filter(Boolean);
+    const suffix = files.length ? " \u2014 " + files.join(", ") : "";
+    return "- " + prio + summaryEvidenceLine(l.summary, TRUNC.OPEN_LOOP_SUMMARY) + suffix;
   }).join(`
 `);
   const parsed = parseSummary(summary);
@@ -4073,32 +4097,33 @@ function hasDeltaChanges(delta) {
 }
 function formatDeltaSection(delta) {
   const lines = ["## Changes Since Last Compaction", ""];
+  const safe = (value, max) => summaryEvidenceLine(value, max);
   if (delta.goalChanged) {
-    lines.push("- **Goal shifted**: " + (delta.previousGoal ?? "?") + " \u2192 see current goal above");
+    lines.push("- **Goal shifted**: " + safe(delta.previousGoal ?? "?", TRUNC.MESSAGE) + " \u2192 see current goal above");
   }
   if (delta.resolvedLoops.length) {
-    lines.push("- **Resolved loops**: " + delta.resolvedLoops.map((s) => "~~" + s.slice(0, TRUNC.DECISION_DETAIL) + "~~").join(", "));
+    lines.push("- **Resolved loops**: " + delta.resolvedLoops.map((s) => "~~" + safe(s, TRUNC.DECISION_DETAIL) + "~~").join(", "));
   }
   if (delta.persistentLoops.length) {
-    lines.push("- **Still open**: " + delta.persistentLoops.map((s) => s.slice(0, TRUNC.DECISION_DETAIL)).join("; "));
+    lines.push("- **Still open**: " + delta.persistentLoops.map((s) => safe(s, TRUNC.DECISION_DETAIL)).join("; "));
   }
   if (delta.newLoops.length) {
-    lines.push("- **New loops**: " + delta.newLoops.map((s) => s.slice(0, TRUNC.DECISION_DETAIL)).join("; "));
+    lines.push("- **New loops**: " + delta.newLoops.map((s) => safe(s, TRUNC.DECISION_DETAIL)).join("; "));
   }
   if (delta.newDecisions.length) {
-    lines.push("- **New decisions**: " + delta.newDecisions.map((s) => s.slice(0, TRUNC.SNIPPET)).join("; "));
+    lines.push("- **New decisions**: " + delta.newDecisions.map((s) => safe(s, TRUNC.SNIPPET)).join("; "));
   }
   if (delta.removedDecisions.length) {
-    lines.push("- **Removed decisions**: " + delta.removedDecisions.map((s) => "~~" + s.slice(0, TRUNC.SNIPPET) + "~~").join("; "));
+    lines.push("- **Removed decisions**: " + delta.removedDecisions.map((s) => "~~" + safe(s, TRUNC.SNIPPET) + "~~").join("; "));
   }
   if (delta.resolvedErrors.length) {
-    lines.push("- **Resolved errors**: " + delta.resolvedErrors.map((s) => s.slice(0, TRUNC.DECISION_DETAIL)).join("; "));
+    lines.push("- **Resolved errors**: " + delta.resolvedErrors.map((s) => safe(s, TRUNC.DECISION_DETAIL)).join("; "));
   }
   if (delta.newErrors.length) {
-    lines.push("- **New errors**: " + delta.newErrors.map((s) => s.slice(0, TRUNC.DECISION_DETAIL)).join("; "));
+    lines.push("- **New errors**: " + delta.newErrors.map((s) => safe(s, TRUNC.DECISION_DETAIL)).join("; "));
   }
   if (delta.newModifiedFiles.length) {
-    lines.push("- **New files touched**: " + delta.newModifiedFiles.join(", "));
+    lines.push("- **New files touched**: " + delta.newModifiedFiles.map((file) => safe(file, TRUNC.MESSAGE)).join(", "));
   }
   lines.push("");
   return lines.join(`
@@ -4120,7 +4145,7 @@ function ensurePinnedPaths(summary, pinned) {
   if (!pinned.length)
     return summary;
   const lower = summary.toLowerCase();
-  const missing = pinned.filter((p) => p && p.trim().length > 0 && !lower.includes(p.toLowerCase()));
+  const missing = pinned.map((path7) => summaryEvidenceLine(path7, TRUNC.MESSAGE)).filter((path7) => path7 && !lower.includes(path7.toLowerCase()));
   if (!missing.length)
     return summary;
   const parsed = parseSummary(summary);
@@ -5717,33 +5742,42 @@ async function prepareRun(rc) {
 // src/app/steps/window.ts
 init_mode_policy();
 init_helpers();
+init_constants();
 function resolveCompactionWindow(rc) {
   const usage = rc.ctx.getContextUsage();
   const totalTokens = usage?.tokens ?? 0;
   const manager = rc.ctx.sessionManager;
   const branch = typeof manager.buildContextEntries === "function" ? manager.buildContextEntries() : manager.getBranch();
   const msgs = branch.filter((e) => e.type === "message" && e.message != null);
-  if (msgs.length < 3)
+  if (msgs.length < 3) {
+    if (rc.flags.force)
+      rc.notify("Manual compaction skipped: fewer than 3 active messages are available.", "warning");
     return null;
+  }
   const adaptiveKeepTokens = rc.ctx.model ? Math.min(rc.profileCfg.keepRecentTokens * 2, Math.max(rc.profileCfg.keepRecentTokens, rc.ctx.model.contextWindow * 0.04)) : rc.profileCfg.keepRecentTokens;
   const mode = rc.mode ?? (rc.profile ? modeFromLegacyProfile(rc.profile) : "balanced");
   const targetPercent = MODE_POLICIES[mode].targetContextPercent;
   const messageTokens = msgs.map((entry) => rc.estimator.message(entry.message));
   const allMessageTokens = messageTokens.reduce((sum, tokens) => sum + tokens, 0);
-  const fixedContextTokens = Math.max(0, totalTokens - allMessageTokens);
+  const overflowedContext = !!rc.flags.overflowRecovery || !!rc.ctx.model && totalTokens > rc.ctx.model.contextWindow;
+  const messageScale = totalTokens > 0 && allMessageTokens > 0 && (allMessageTokens > totalTokens || overflowedContext) ? totalTokens / allMessageTokens : 1;
+  const fixedContextTokens = overflowedContext ? 0 : Math.max(0, totalTokens - allMessageTokens);
   const targetRetainedTokens = rc.ctx.model ? Math.max(0, rc.ctx.model.contextWindow * targetPercent / 100 - fixedContextTokens - rc.profileCfg.summaryBudgetTokens) : adaptiveKeepTokens;
-  const retentionBudget = Math.max(adaptiveKeepTokens, targetRetainedTokens);
+  const retentionBudget = rc.flags.force ? adaptiveKeepTokens : Math.max(adaptiveKeepTokens, targetRetainedTokens);
+  const rawAdaptiveKeepTokens = adaptiveKeepTokens / messageScale;
+  const rawRetentionBudget = retentionBudget / messageScale;
   let accTokens = 0;
   let keepFrom = msgs.length - 1;
   for (let i = msgs.length - 1;i >= 0; i--) {
     const next = messageTokens[i];
-    if (accTokens >= adaptiveKeepTokens && accTokens + next > retentionBudget) {
+    if (accTokens >= rawAdaptiveKeepTokens && accTokens + next > rawRetentionBudget) {
       keepFrom = i + 1;
       break;
     }
     accTokens += next;
     keepFrom = i;
   }
+  const plannedKeepFrom = keepFrom;
   const recentUsers = msgs.map((entry, index) => ({ index, role: entry.message?.role })).filter((entry) => entry.role === "user");
   if (recentUsers.length) {
     const protectedUser = recentUsers[recentUsers.length >= 2 ? recentUsers.length - 2 : recentUsers.length - 1];
@@ -5751,19 +5785,42 @@ function resolveCompactionWindow(rc) {
   }
   keepFrom = smartKeepBoundary(msgs, keepFrom, branch);
   keepFrom = guardToolCallBoundary(msgs, keepFrom);
-  const rawCompactTokens = messageTokens.slice(0, keepFrom).reduce((sum, tokens) => sum + tokens, 0);
-  const rawRetainedTokens = messageTokens.slice(keepFrom).reduce((sum, tokens) => sum + tokens, 0);
-  const messageScale = totalTokens > 0 && allMessageTokens > totalTokens ? totalTokens / allMessageTokens : 1;
-  const compactTokens = Math.round(rawCompactTokens * messageScale);
-  accTokens = Math.round(rawRetainedTokens * messageScale);
+  const recount = (from) => ({
+    compact: Math.round(messageTokens.slice(0, from).reduce((sum, tokens) => sum + tokens, 0) * messageScale),
+    retained: Math.round(messageTokens.slice(from).reduce((sum, tokens) => sum + tokens, 0) * messageScale)
+  });
+  let counts = recount(keepFrom);
+  const softProtectionBudget = rc.flags.force ? Math.max(retentionBudget, adaptiveKeepTokens * 2) : retentionBudget;
+  const protectionCeiling = fixedContextTokens + softProtectionBudget + rc.profileCfg.summaryBudgetTokens;
+  if (overflowedContext && keepFrom < plannedKeepFrom && fixedContextTokens + counts.retained + rc.profileCfg.summaryBudgetTokens > protectionCeiling) {
+    keepFrom = guardToolCallBoundary(msgs, plannedKeepFrom);
+    counts = recount(keepFrom);
+    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 compactTokens = counts.compact;
+  accTokens = counts.retained;
   if (msgs[keepFrom]?.message?.role === "toolResult") {
+    if (rc.flags.force)
+      rc.notify("Manual compaction skipped: no safe boundary can separate the retained tool result from its tool call.", "warning");
     return null;
   }
   const toCompact = msgs.slice(0, keepFrom);
-  if (!toCompact.length)
+  if (!toCompact.length) {
+    if (rc.flags.force) {
+      rc.notify("Manual compaction skipped: no eligible prefix remains after protecting recent user turns and tool-call boundaries. It may have been run again too soon.", "warning");
+    }
     return null;
+  }
   const contextPercent = rc.ctx.model && totalTokens ? totalTokens / rc.ctx.model.contextWindow * 100 : 0;
-  if (!rc.flags.force && rc.ctx.model && totalTokens > 0 && rc.config.minContextPercent > 0) {
+  if (rc.flags.force) {
+    const lowYield = compactTokens <= rc.profileCfg.summaryBudgetTokens + MIN_TOKEN_THRESHOLD || totalTokens > 0 && compactTokens / totalTokens < 0.1;
+    if (lowYield) {
+      rc.notify("Low-yield manual compaction: only " + compactTokens.toLocaleString() + "t are eligible after preserving " + accTokens.toLocaleString() + "t of recent context. Continuing because you requested it; repeated compaction may lose nuance.", "warning");
+    } else if (rc.config.minContextPercent > 0 && contextPercent < rc.config.minContextPercent) {
+      rc.notify("Manual compaction override at " + Math.round(contextPercent) + "% (" + totalTokens.toLocaleString() + "t): compacting about " + compactTokens.toLocaleString() + "t while preserving " + accTokens.toLocaleString() + "t of recent context. Early compaction is lossy; verification remains fail-closed.", "warning");
+    }
+  }
+  if (!rc.flags.force && !overflowedContext && rc.ctx.model && totalTokens > 0 && rc.config.minContextPercent > 0) {
     const projectedTokens = fixedContextTokens + accTokens + rc.profileCfg.summaryBudgetTokens;
     const targetTokens = rc.ctx.model.contextWindow * targetPercent / 100;
     if (projectedTokens > targetTokens) {
@@ -6024,7 +6081,7 @@ init_constants();
 init_helpers();
 function selectTier(rc) {
   const toolPercent = computeToolCharPercentage(rc.branch);
-  const tier = rc.flags.force ? rc.contextPercent >= 80 ? "full" : "light" : selectCompactionTier(rc.contextPercent, toolPercent, rc.totalTokens, MIN_TOKEN_THRESHOLD, rc.config.minContextPercent);
+  const tier = rc.flags.overflowRecovery ? "full" : rc.flags.force ? rc.contextPercent >= 80 ? "full" : "light" : selectCompactionTier(rc.contextPercent, toolPercent, rc.totalTokens, MIN_TOKEN_THRESHOLD, rc.config.minContextPercent);
   if (tier === "none") {
     if (!rc.flags.autoTriggered) {
       rc.ctx.ui.notify("Context OK (" + Math.round(rc.contextPercent) + "%). pi-toolkit manages context well.", "info");
@@ -6845,6 +6902,7 @@ function getCachedBatchClone(value) {
 }
 
 // src/phases/synthesize.ts
+init_summary_parse();
 function boundedToolArgs(value, depth = 0) {
   if (typeof value === "string")
     return value.length > TRUNC.DETAIL ? value.slice(0, TRUNC.DETAIL) + "\u2026" : value;
@@ -7091,21 +7149,29 @@ async function assembleLLM(summaries, extraction, report, model, auth, budget, p
 `).trim();
 }
 function assembleFallback(summaries, extraction) {
-  const detModified = extraction.modifiedFiles.map((f) => f.path);
-  const detRead = extraction.readFiles;
-  const unresolved = extraction.errors.filter((error) => !error.resolved);
-  const inProgress = summaries.filter((item) => item.priority === "critical" || item.priority === "high").map((item) => "- [ ] " + item.summary.slice(0, TRUNC.PREVIEW));
+  const safe = (value, max = TRUNC.PREVIEW_MID) => summaryEvidenceLine(value, max);
+  const detModified = extraction.modifiedFiles.map((f) => safe(f.path)).filter(Boolean);
+  const detRead = extraction.readFiles.map((file) => safe(file)).filter(Boolean);
+  const unresolved = extraction.errors.filter((error) => !error.resolved).map((error) => safe(error.message, TRUNC.PREVIEW)).filter(Boolean);
+  const constraints = extraction.constraints.map((item) => "- [" + item.category + "] " + safe(item.text)).filter((line) => !line.endsWith("] "));
+  const decisions = extraction.decisions.map((item) => {
+    const summary = safe(item.summary, TRUNC.DECISION_SUMMARY);
+    const response = item.userResponse ? safe(item.userResponse, TRUNC.USER_RESPONSE) : "";
+    return summary ? "- **" + summary + "**" + (response ? " \u2192 " + response : "") : "";
+  }).filter(Boolean);
+  const inProgress = summaries.filter((item) => item.priority === "critical" || item.priority === "high").map((item) => safe(item.summary, TRUNC.PREVIEW)).filter(Boolean).map((item) => "- [ ] " + item);
   if (!inProgress.length) {
-    inProgress.push(...extraction.lastUserMessages.slice(-3).map((message) => "- [ ] " + message.slice(0, TRUNC.PREVIEW)));
+    inProgress.push(...extraction.lastUserMessages.slice(-3).map((message) => safe(message, TRUNC.PREVIEW)).filter(Boolean).map((message) => "- [ ] " + message));
   }
   inProgress.push(...detModified.map((file) => "- [ ] Continue work in " + file));
-  const next = extraction.lastUserMessages.at(-1)?.slice(0, TRUNC.PREVIEW) ?? extraction.timeline.at(-1)?.summary.slice(0, TRUNC.PREVIEW) ?? "Continue from the latest preserved context.";
+  const next = safe(extraction.lastUserMessages.at(-1) ?? extraction.timeline.at(-1)?.summary ?? "", TRUNC.PREVIEW) || "Continue from the latest preserved context.";
+  const goal = safe(extraction.mainGoal ?? "", TRUNC.DETAIL) || "Continue the current task.";
   return [
     "## Goal",
-    extraction.mainGoal ?? "Continue the current task.",
+    goal,
     "",
     "## Constraints & Preferences",
-    ...extraction.constraints.length ? extraction.constraints.map((c) => "- [" + c.category + "] " + c.text.slice(0, TRUNC.PREVIEW_MID)) : ["- None recorded."],
+    ...constraints.length ? constraints : ["- None recorded."],
     "",
     "## Progress",
     "### Done",
@@ -7113,25 +7179,28 @@ function assembleFallback(summaries, extraction) {
     "### In Progress",
     ...inProgress.length ? inProgress : ["- Continue current work."],
     "### Blocked",
-    ...unresolved.length ? unresolved.map((error) => "- " + error.message.slice(0, TRUNC.PREVIEW)) : ["- None recorded."],
+    ...unresolved.length ? unresolved.map((error) => "- " + error) : ["- None recorded."],
     "",
     "## Key Decisions",
-    ...extraction.decisions.length ? extraction.decisions.map((d) => "- **" + d.summary.slice(0, TRUNC.TOPIC_LABEL) + "**" + (d.userResponse ? " \u2192 " + d.userResponse : "")) : ["- None recorded."],
+    ...decisions.length ? decisions : ["- None recorded."],
     "",
     "## Files Modified",
-    ...detModified.length ? detModified.map((f) => "- " + f) : ["- None recorded."],
+    ...detModified.length ? detModified.map((file) => "- " + file) : ["- None recorded."],
     "",
     "## Files Read",
-    ...detRead.length ? detRead.map((f) => "- " + f) : ["- None recorded."],
+    ...detRead.length ? detRead.map((file) => "- " + file) : ["- None recorded."],
     "",
     "## Next Steps",
     "1. " + next,
     "",
     "## Critical Context",
-    ...unresolved.length ? unresolved.map((e) => "- Unresolved error: " + e.message.slice(0, TRUNC.TOPIC_LABEL)) : ["- None recorded."],
+    ...unresolved.length ? unresolved.map((error) => "- Unresolved error: " + safe(error, TRUNC.TOPIC_LABEL)) : ["- None recorded."],
     "",
     "## Topics Covered",
-    ...summaries.length ? summaries.map((s) => "- **" + s.topic + "** [" + s.priority + "]: " + s.summary.slice(0, TRUNC.PREVIEW_MID)) : extraction.topics.map((topic, index) => "- Topic " + (index + 1) + ": " + (topic.primaryFile ?? topic.type))
+    ...summaries.length ? summaries.map((item) => {
+      const topic = safe(item.topic, TRUNC.TOPIC_LABEL) || "Segment";
+      return "- **" + topic + "** [" + item.priority + "]: " + safe(item.summary);
+    }) : extraction.topics.map((topic, index) => "- Topic " + (index + 1) + ": " + safe(topic.primaryFile ?? topic.type))
   ].join(`
 `);
 }
@@ -7140,8 +7209,8 @@ function failedChunkSummary(ch) {
     topic: ch.topic,
     startIndex: ch.startIndex,
     endIndex: ch.endIndex,
-    summary: "[Failed] " + ch.messages.map((m) => extractText(m.content)).join(`
-`).slice(0, TRUNC.DETAIL),
+    summary: "[Failed] " + summaryEvidenceLine(ch.messages.map((m) => extractText(m.content)).join(`
+`), TRUNC.DETAIL),
     keyDecisions: [],
     filesModified: [],
     filesRead: [],
@@ -7522,6 +7591,21 @@ function verificationFailureMessage(result) {
   const findings = result.gaps.slice(0, 3).map((gap) => formatVerificationGap(gap).replace(/\s+/g, " ").slice(0, 160)).join("; ");
   return "Verification gate rejected summary (" + result.score + "/100, " + result.gaps.length + " unresolved gap(s))" + (findings ? ": " + findings : "");
 }
+
+class VerificationGateError extends Error {
+  score;
+  initialScore;
+  gapKinds;
+  gapCount;
+  constructor(result, initialScore) {
+    super(verificationFailureMessage(result) ?? "Verification gate rejected summary");
+    this.name = "VerificationGateError";
+    this.score = result.score;
+    this.initialScore = initialScore;
+    this.gapKinds = Array.from(new Set(result.gaps.map((gap) => gap.kind)));
+    this.gapCount = result.gaps.length;
+  }
+}
 var NEGATION_MARKERS = new Set([
   "no",
   "not",
@@ -7592,14 +7676,15 @@ function semanticTokens(text) {
   return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2);
 }
 function evidenceFragments(text) {
-  return text.split(/(?:\r?\n|[.;])/).map((part) => part.replace(/^\s*[-*\d.)]+\s*/, "").trim()).filter(Boolean);
+  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));
 }
 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)));
 }
 function semanticShape(source) {
   const sourceTokens = semanticTokens(source);
-  const concepts = Array.from(new Set(sourceTokens.filter((token) => !SEMANTIC_STOP.has(token) && !NEGATION_MARKERS.has(token) && !CONDITION_MARKERS.has(token))));
+  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] ?? "";
@@ -7629,12 +7714,15 @@ function hasSemanticContradiction(source, target) {
   const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
   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);
     if (!tokens.includes(anchor))
       return false;
+    const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
+    if (overlap < required)
+      return false;
     if (negative && !hasNearbyMarker(tokens, anchor, NEGATION_MARKERS)) {
-      const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
       const validConditional = sourceTokens.includes("without") && tokens.some((token) => CONDITION_MARKERS.has(token)) && overlap >= Math.min(2, concepts.length);
       return !validConditional;
     }
@@ -7648,6 +7736,28 @@ function isDeterministicallyPatchable(gap) {
     return gap.detail.startsWith("blocked-none:");
   return true;
 }
+function repairSummaryDeterministically(summary, result, extraction, continuity = null, maxRounds = 3) {
+  const patched = [];
+  const seen = new Set;
+  for (let round = 0;round < maxRounds; round++) {
+    const patchable = result.gaps.filter(isDeterministicallyPatchable);
+    if (!patchable.length)
+      break;
+    const next = patchDeterministic(summary, patchable, extraction, continuity);
+    if (next === summary)
+      break;
+    for (const gap of patchable) {
+      const key = formatVerificationGap(gap);
+      if (!seen.has(key)) {
+        seen.add(key);
+        patched.push(gap);
+      }
+    }
+    summary = next;
+    result = verifySummary(summary, extraction, continuity);
+  }
+  return { summary, result, patched };
+}
 function verifySummary(summary, extraction, continuity = null) {
   const parsed = parseSummary(summary);
   const gaps = [];
@@ -7767,7 +7877,10 @@ function verifySummary(summary, extraction, continuity = null) {
       const basename = file.path.split("/").pop() ?? "";
       if (!doneSection.toLowerCase().includes(basename.toLowerCase()))
         continue;
-      const unresolved = unresolvedEvidence.find((error) => error.message.toLowerCase().includes(basename.toLowerCase()));
+      const unresolved = unresolvedEvidence.find((error) => {
+        const firstLine = error.message.split(/\r?\n/, 1)[0] ?? "";
+        return extractFileRefs(firstLine).some((ref) => isKnownPathReference(ref, [file.path]));
+      });
       if (unresolved) {
         gaps.push({ kind: "inconsistency", detail: basename + " marked Done but has unresolved error" });
         score -= 5;
@@ -7795,15 +7908,15 @@ function verifySummary(summary, extraction, continuity = null) {
 }
 function patchDeterministic(summary, gaps, extraction, continuity = null) {
   let canonical = parseSummary(summary);
-  const verificationNotes = [];
+  const safe = (value, max = TRUNC.MESSAGE) => summaryEvidenceLine(value, max);
   const unresolvedMessages = Array.from(new Set([
     ...extraction.errors.filter((error) => !error.resolved).map((error) => error.message),
     ...(continuity?.unresolvedErrors ?? []).map((error) => error.message)
   ]));
   const unresolvedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved");
   const blockedItems = [
-    ...unresolvedMessages.map((message) => "- " + message.slice(0, TRUNC.MESSAGE)),
-    ...unresolvedLoops.map((loop) => "- " + loop.summary.slice(0, TRUNC.MESSAGE))
+    ...unresolvedMessages.map((message) => safe(message)).filter(Boolean).map((message) => "- " + message),
+    ...unresolvedLoops.map((loop) => safe(loop.summary)).filter(Boolean).map((summary2) => "- " + summary2)
   ];
   const patchBlockedNone = () => {
     const progress = findSection(canonical, "progress");
@@ -7817,7 +7930,7 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
     switch (gap.kind) {
       case "missing-section": {
         if (gap.section === "goal") {
-          canonical = upsertSection(canonical, "goal", extraction.mainGoal ?? "Continue the current coding task.");
+          canonical = upsertSection(canonical, "goal", safe(extraction.mainGoal ?? "", TRUNC.DETAIL) || "Continue the current coding task.");
         } else if (gap.section === "progress") {
           canonical = upsertSection(canonical, "progress", `### Done
 - No explicit completion recorded.
@@ -7827,36 +7940,36 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
 ` + (blockedItems.join(`
 `) || "- None recorded."));
         } else if (gap.section === "critical-context") {
-          const critical = unresolvedMessages.map((message) => "- Unresolved error: " + message.slice(0, TRUNC.MESSAGE));
+          const critical = unresolvedMessages.map((message) => safe(message)).filter(Boolean).map((message) => "- Unresolved error: " + message);
           canonical = upsertSection(canonical, "critical-context", critical.join(`
 `) || "- None recorded.");
         }
         break;
       }
       case "missing-file":
-        canonical = appendToSection(canonical, "files-modified", "- " + gap.path);
+        canonical = appendToSection(canonical, "files-modified", "- " + safe(gap.path));
         break;
       case "missing-error": {
         const existing = findSection(canonical, "critical-context")?.body.toLowerCase() ?? "";
-        const message = gap.message.slice(0, TRUNC.MESSAGE);
+        const message = safe(gap.message);
         if (!existing.includes(message.toLowerCase())) {
           canonical = appendToSection(canonical, "critical-context", "- Unresolved error: " + message);
         }
         break;
       }
       case "missing-constraint":
-        canonical = appendToSection(canonical, "constraints", "- " + gap.text.slice(0, TRUNC.CONSTRAINT_TEXT));
+        canonical = appendToSection(canonical, "constraints", "- " + safe(gap.text, TRUNC.CONSTRAINT_TEXT));
         break;
       case "missing-decision":
-        canonical = appendToSection(canonical, "decisions", "- **" + gap.summary.slice(0, TRUNC.DECISION_DETAIL) + "**");
+        canonical = appendToSection(canonical, "decisions", "- **" + safe(gap.summary, TRUNC.DECISION_SUMMARY) + "**");
         break;
       case "missing-goal":
-        canonical = upsertSection(canonical, "goal", gap.goal);
+        canonical = upsertSection(canonical, "goal", safe(gap.goal, TRUNC.DETAIL) || "Continue the current task.");
         break;
       case "missing-open-loops": {
-        const current = extraction.errors.filter((error) => !error.resolved).map((error) => "- [high] Resolve " + error.message.slice(0, TRUNC.SNIPPET));
-        const carriedErrors = (continuity?.unresolvedErrors ?? []).map((error) => "- [high] Resolve " + error.message.slice(0, TRUNC.SNIPPET));
-        const carriedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved").map((loop) => "- [" + loop.priority + "] " + loop.summary.slice(0, TRUNC.SNIPPET));
+        const current = extraction.errors.filter((error) => !error.resolved).map((error) => safe(error.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
+        const carriedErrors = (continuity?.unresolvedErrors ?? []).map((error) => safe(error.message, TRUNC.SNIPPET)).filter(Boolean).map((message) => "- [high] Resolve " + message);
+        const carriedLoops = (continuity?.openLoops ?? []).filter((loop) => loop.status !== "resolved").map((loop) => ({ priority: loop.priority, summary: safe(loop.summary, TRUNC.SNIPPET) })).filter((item) => item.summary).map((item) => "- [" + item.priority + "] " + item.summary);
         const body = Array.from(new Set([...current, ...carriedErrors, ...carriedLoops])).slice(0, gap.unresolvedCount).join(`
 `);
         canonical = upsertSection(canonical, "open-loops", body || "- Review unresolved errors.", "next-steps");
@@ -7864,7 +7977,6 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
       }
       case "fabricated-file": {
         const normalizedRef = gap.ref.replace(/\\/g, "/").toLowerCase();
-        let removed = false;
         canonical = {
           sections: canonical.sections.map((section) => ({
             ...section,
@@ -7873,42 +7985,32 @@ function patchDeterministic(summary, gaps, extraction, continuity = null) {
               if (!/^\s*[-*]\s+/.test(line))
                 return true;
               const matches = extractFileRefs(line).some((ref) => ref.replace(/\\/g, "/").toLowerCase() === normalizedRef);
-              if (matches)
-                removed = true;
               return !matches;
             }).join(`
 `).trim()
           }))
         };
-        if (!removed)
-          verificationNotes.push(formatVerificationGap(gap));
         break;
       }
       case "inconsistency":
         if (gap.detail.startsWith("blocked-none:"))
           patchBlockedNone();
-        else
-          verificationNotes.push(formatVerificationGap(gap));
         break;
     }
   }
-  if (verificationNotes.length > 0) {
-    canonical = upsertSection(canonical, "verification-note", verificationNotes.map((note) => "- " + note).join(`
-`));
-  }
   return renderSummary(canonical, { canonicalHeadings: true });
 }
 async function patchSummary(summary, gaps, model, auth, signal, services) {
-  const patchPrompt = `The summary below is missing some critical information. Add the missing items WITHOUT restructuring the summary.
+  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.
 
-Missing items:
+Findings:
 ` + gaps.map((gap, index) => index + 1 + ". " + formatVerificationGap(gap)).join(`
 `) + `
 
 Current summary:
 ` + summary + `
 
-Return the COMPLETE updated summary with missing items integrated. Keep the same format.`;
+Return the COMPLETE corrected summary in the same format.`;
   try {
     const maxTokens = Math.min(8192, getProviderCaps(model.provider).maxOutputTokens);
     const response = await trackedComplete("patch", model, {
@@ -7928,10 +8030,6 @@ Return the COMPLETE updated summary with missing items integrated. Keep the same
 init_overlays();
 init_logger();
 init_mode_policy();
-function informationTokenCount(summary) {
-  const ignored = new Set(["none", "recorded", "continue", "current", "work", "explicit", "completion"]);
-  return new Set((summary.normalize("NFKC").toLowerCase().match(/[\p{L}\p{N}_-]{4,}/gu) ?? []).filter((token) => !ignored.has(token))).size;
-}
 async function verifyAndPatch(rc) {
   const extraction = rc.extraction;
   let summary = rc.finalSummary;
@@ -7948,17 +8046,20 @@ async function verifyAndPatch(rc) {
   }
   let verification = verifySummary(summary, extraction, rc.previousState);
   const initialScore = verification.score;
-  const deterministicPatched = verification.gaps.filter(isDeterministicallyPatchable);
+  const deterministicPatched = [];
   let llmPatched = false;
   let qualityFloorUsed = false;
   rc.vlog("Verification score=" + verification.score + " ok=" + verification.ok + " gaps=" + verification.gaps.length);
-  if (deterministicPatched.length > 0) {
-    rc.notify("Phase 4 Verify: " + deterministicPatched.length + " deterministic gap(s), score=" + verification.score + ", applying repair", "warning");
-    summary = patchDeterministic(summary, verification.gaps, extraction, rc.previousState);
-    verification = verifySummary(summary, extraction, rc.previousState);
+  const initialPatchable = verification.gaps.filter(isDeterministicallyPatchable);
+  if (initialPatchable.length > 0) {
+    rc.notify("Phase 4 Verify: " + initialPatchable.length + " deterministic gap(s), score=" + verification.score + ", applying repair", "warning");
+    const repaired = repairSummaryDeterministically(summary, verification, extraction, rc.previousState);
+    summary = repaired.summary;
+    verification = repaired.result;
+    deterministicPatched.push(...repaired.patched);
   }
   const mode = rc.mode ?? (rc.profile ? modeFromLegacyProfile(rc.profile) : "balanced");
-  if (MODE_POLICIES[mode].allowLlmPatch && !verification.ok && verification.score < 75) {
+  if (MODE_POLICIES[mode].allowLlmPatch && !verification.ok) {
     rc.notify("Phase 4 Verify: deterministic repair insufficient (score=" + verification.score + "), requesting LLM patch", "warning");
     const beforePatch = summary;
     try {
@@ -7970,34 +8071,30 @@ async function verifyAndPatch(rc) {
     if (summary !== beforePatch) {
       llmPatched = true;
       verification = verifySummary(summary, extraction, rc.previousState);
+      const repaired = repairSummaryDeterministically(summary, verification, extraction, rc.previousState);
+      summary = repaired.summary;
+      verification = repaired.result;
+      deterministicPatched.push(...repaired.patched);
     }
   }
   if (!verification.ok) {
     let deterministic = assembleFallback(rc.summaries, extraction);
     let deterministicVerification = verifySummary(deterministic, extraction, rc.previousState);
-    const patchable = deterministicVerification.gaps.filter(isDeterministicallyPatchable);
-    if (patchable.length > 0) {
-      deterministic = patchDeterministic(deterministic, deterministicVerification.gaps, extraction, rc.previousState);
-      deterministicVerification = verifySummary(deterministic, extraction, rc.previousState);
-    }
-    const gain = deterministicVerification.score - verification.score;
-    const currentInformation = Math.max(1, informationTokenCount(summary));
-    const fallbackCoverage = informationTokenCount(deterministic) / currentInformation;
-    const semanticSafetyFailure = verification.gaps.some((gap) => gap.kind === "inconsistency" && gap.detail.startsWith("semantic-contradiction:"));
-    const catastrophic = verification.score < 50;
-    const materiallyBetter = gain >= 15 && fallbackCoverage >= 0.65;
-    if (deterministicVerification.ok && (semanticSafetyFailure || catastrophic || materiallyBetter)) {
+    const repaired = repairSummaryDeterministically(deterministic, deterministicVerification, extraction, rc.previousState);
+    deterministic = repaired.summary;
+    deterministicVerification = repaired.result;
+    if (deterministicVerification.ok) {
       summary = deterministic;
       verification = deterministicVerification;
-      deterministicPatched.push(...patchable);
+      deterministicPatched.push(...repaired.patched);
       qualityFloorUsed = true;
-      rc.notify("Quality floor replaced unsafe or materially lower-coverage model output", "warning");
+      rc.notify("Quality floor replaced unsafe or unverifiable model output", "warning");
     }
   }
   const failure = verificationFailureMessage(verification);
   if (failure) {
     rc.notify(failure + " \u2014 current conversation left unchanged", "error");
-    throw new Error(failure);
+    throw new VerificationGateError(verification, initialScore);
   }
   const out = rc;
   out.finalSummary = summary;
@@ -8072,24 +8169,23 @@ function buildState(rc) {
   summary = rc.services.scrubber.scrubText(summary).value;
   compactionState = rc.services.scrubber.scrubValue(compactionState).value;
   let postVerification = verifySummary(summary, extraction, compactionState);
-  const postPatchable = postVerification.gaps.filter(isDeterministicallyPatchable);
-  if (postPatchable.length > 0) {
-    summary = patchDeterministic(summary, postVerification.gaps, extraction, compactionState);
-    postVerification = verifySummary(summary, extraction, compactionState);
-  }
+  const postInitialScore = postVerification.score;
+  const postRepair = repairSummaryDeterministically(summary, postVerification, extraction, compactionState);
+  summary = postRepair.summary;
+  postVerification = postRepair.result;
   rc.verified = postVerification.ok;
   rc.verificationScore = postVerification.score;
   rc.verificationGaps = postVerification.gaps.map(formatVerificationGap);
   rc.verificationProvenance = {
     ...rc.verificationProvenance,
-    deterministicPatched: [...rc.verificationProvenance.deterministicPatched, ...postPatchable],
+    deterministicPatched: [...rc.verificationProvenance.deterministicPatched, ...postRepair.patched],
     finalScore: postVerification.score,
     remainingGaps: postVerification.gaps
   };
   const failure = verificationFailureMessage(postVerification);
   if (failure) {
     rc.notify(failure + " after continuity injection \u2014 current conversation left unchanged", "error");
-    throw new Error(failure);
+    throw new VerificationGateError(postVerification, postInitialScore);
   }
   const detModified = extraction.modifiedFiles.map((f) => f.path);
   const detRead = extraction.readFiles;
@@ -8153,11 +8249,37 @@ var MAX_MANUAL_NODES = 500;
 var MAX_SESSION_NODES = 256;
 var MAX_QUERY_CANDIDATES = 80;
 var NINETY_DAYS_MS = 90 * 24 * 60 * 60 * 1000;
+function nodeSqliteAdapter(db) {
+  return {
+    exec: (sql) => db.exec(sql),
+    query: (sql) => db.prepare(sql),
+    transaction: (fn) => (...args) => {
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = fn(...args);
+        db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        try {
+          db.exec("ROLLBACK");
+        } catch {}
+        throw error;
+      }
+    },
+    close: () => db.close()
+  };
+}
 function openDatabase() {
   const fp = contextGraphFile();
   fs7.mkdirSync(path10.dirname(fp), { recursive: true });
-  const { Database } = require2("bun:sqlite");
-  const db = new Database(fp);
+  let db;
+  if ("bun" in process.versions) {
+    const { Database } = require2("bun:sqlite");
+    db = new Database(fp);
+  } else {
+    const { DatabaseSync } = require2("node:sqlite");
+    db = nodeSqliteAdapter(new DatabaseSync(fp));
+  }
   try {
     fs7.chmodSync(fp, 384);
   } catch {}
@@ -8824,6 +8946,22 @@ function recordSuccessMetrics(rc, status) {
 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;
+  const knownGapKinds = new Set([
+    "missing-section",
+    "missing-file",
+    "missing-error",
+    "missing-constraint",
+    "missing-decision",
+    "missing-goal",
+    "fabricated-file",
+    "inconsistency",
+    "missing-open-loops"
+  ]);
+  const gapKinds = Array.isArray(gate?.gapKinds) ? gate.gapKinds.filter((kind) => typeof kind === "string" && knownGapKinds.has(kind)) : undefined;
+  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", {
     runId: rc.runId,
     metricsSchemaVersion: 2,
@@ -8843,6 +8981,11 @@ function recordFailureMetrics(rc, err, fields) {
     runType: runType(rc),
     status: rc.cancellation.timedOut ? "timeout" : "error",
     fallbackReason: "failure:" + failureKind,
+    verificationScore,
+    initialVerificationScore,
+    verificationGaps,
+    remainingVerificationGaps: verificationGaps,
+    verificationGapKinds: gapKinds,
     phaseTimings: rc.phaseTimings,
     durationMs: Date.now() - rc.pipelineStart
   }, rc.services);
@@ -8978,7 +9121,8 @@ function makeBase(opts) {
       dryRun: !!opts.dryRun,
       autoTriggered: !!opts.autoTriggered,
       skipCompact: !!opts.skipCompact,
-      force: !!opts.force
+      force: !!opts.force,
+      overflowRecovery: !!opts.overflowRecovery
     },
     userNote: opts.userNote,
     focus: opts.focus,
@@ -9004,8 +9148,11 @@ async function runSmartCompact(opts) {
     return;
   }
   const runSessionId = resolveSessionId(opts.ctx);
-  if (!acquireRunLock(opts.isRunning, runSessionId))
+  if (!acquireRunLock(opts.isRunning, runSessionId)) {
+    if (!opts.autoTriggered)
+      opts.ctx.ui.notify("Smart compact is already running for this session.", "warning");
     return;
+  }
   const base = makeBase(opts);
   const abortFromHost = () => {
     base.cancellation.timedOut = true;
@@ -9775,8 +9922,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
           const totalTokens = usage?.tokens ?? 0;
           const pct = ctx.model && totalTokens ? Math.round(totalTokens / ctx.model.contextWindow * 100) : 0;
           if (!totalTokens || totalTokens < MIN_TOKEN_THRESHOLD) {
-            ctx.ui.notify("Context OK or unknown", "info");
-            return;
+            ctx.ui.notify("Context usage is low or unknown (" + totalTokens.toLocaleString() + "t). Manual compaction may save little and can lose nuance; continuing because you requested it.", "warning");
           }
           const cur = ctx.model;
           const avail = ctx.modelRegistry.getAvailable();
@@ -9845,7 +9991,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
       if (!totalTokens || totalTokens < MIN_TOKEN_THRESHOLD)
         return;
       const pct = ctx.model && totalTokens ? totalTokens / ctx.model.contextWindow * 100 : 0;
-      if (pct < config.minContextPercent)
+      if (event.reason !== "overflow" && pct < config.minContextPercent)
         return;
       const cur = ctx.model;
       if (!cur)
@@ -9874,6 +10020,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
             isRunning,
             onNativeApplyError,
             autoTriggered: true,
+            overflowRecovery: event.reason === "overflow",
             timeoutMs: effectiveTimeoutMs,
             cancellationOut
           });