pi-smart-compact 8.0.5 → 8.0.7

package/dist/index.js

@@ -9,7 +9,7 @@ import { Type as Type2 } from "typebox";
 // src/app/mode-policy.ts
 var MODE_POLICIES = {
   fast: {
-    profile: "balanced",
+    profile: "aggressive",
     maxLlmCalls: 3,
     maxInputTokens: 1e5,
     maxOutputTokens: 20000,
@@ -17,8 +17,7 @@ var MODE_POLICIES = {
     allowLlmPatch: false,
     singlePassMultiplier: 2,
     batchOutput: { min: 800, perChunk: 160, max: 2400 },
-    softLatencyMs: 30000,
-    targetContextPercent: 45
+    targetContextPercent: 30
   },
   balanced: {
     profile: "balanced",
@@ -29,21 +28,8 @@ var MODE_POLICIES = {
     allowLlmPatch: false,
     singlePassMultiplier: 1.5,
     batchOutput: { min: 1000, perChunk: 250, max: 4096 },
-    softLatencyMs: 60000,
     targetContextPercent: 40
   },
-  aggressive: {
-    profile: "aggressive",
-    maxLlmCalls: 4,
-    maxInputTokens: 120000,
-    maxOutputTokens: 25000,
-    explore: false,
-    allowLlmPatch: false,
-    singlePassMultiplier: 2,
-    batchOutput: { min: 800, perChunk: 180, max: 2400 },
-    softLatencyMs: 45000,
-    targetContextPercent: 30
-  },
   thorough: {
     profile: "light",
     maxLlmCalls: 8,
@@ -53,18 +39,17 @@ var MODE_POLICIES = {
     allowLlmPatch: true,
     singlePassMultiplier: 0.9,
     batchOutput: { min: 1500, perChunk: 400, max: 6000 },
-    softLatencyMs: 120000,
     targetContextPercent: 50
   }
 };
 function modeFromLegacyProfile(profile) {
-  return profile === "light" ? "thorough" : profile;
+  return profile === "light" ? "thorough" : profile === "aggressive" ? "fast" : "balanced";
 }
 function resolveMode(requested, contextPercent, extraction, additionalRisk = 0) {
   if (requested !== "auto")
-    return requested;
+    return requested === "aggressive" ? "fast" : requested;
   if (contextPercent >= 85)
-    return "aggressive";
+    return "fast";
   if (!extraction)
     return contextPercent < 70 ? "fast" : "balanced";
   const unresolved = extraction.errors.filter((error) => !error.resolved).length;
@@ -117,10 +102,16 @@ function effectiveBudget(configured, modeDefault) {
 }
 
 // src/constants.ts
-var VERSION = "8.0.5";
+var VERSION = "8.0.7";
 var CHARS_PER_TOKEN = 3.8;
 var MIN_COMPACTION_SAVING_RATIO = 0.1;
 var ESTIMATOR_ROUNDING_TOLERANCE_TOKENS = 1;
+var POST_SUMMARY_RESERVE_RATIO = 0.25;
+var BUDGET_LIMITS = {
+  CALLS: { min: 1, max: 100 },
+  INPUT_TOKENS: { min: 1e4, max: 1e6 },
+  LATENCY_MS: { min: 5000, max: 600000 }
+};
 var COMPACT_SYSTEM_PREFIX = "You are an expert conversation summarizer for a coding agent. " + "Produce structured markdown summaries. " + "Follow output format exactly. " + "Use EXACT names \u2014 never paraphrase code identifiers. " + "Trust deterministic extraction data over intuition.";
 var PROFILES = {
   light: {
@@ -492,13 +483,8 @@ var LOCK_STALE_MS = 5000;
 var LOCK_RETRY_MS = 25;
 var LOCK_MAX_RETRIES = 80;
 function ensureDir(dir) {
-  try {
-    fs.mkdirSync(dir, { recursive: true });
-  } catch (e) {
-    if (e?.code !== "EEXIST") {
-      warn("ensureDir failed for " + dir, e);
-    }
-  }
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs.chmodSync(dir, 448);
 }
 function tempPath(target) {
   return target + ".tmp." + process.pid + "." + crypto.randomBytes(4).toString("hex");
@@ -507,8 +493,9 @@ function atomicWriteFileSync(target, data) {
   ensureDir(path2.dirname(target));
   const tmp = tempPath(target);
   try {
-    fs.writeFileSync(tmp, data);
+    fs.writeFileSync(tmp, data, { mode: 384 });
     fs.renameSync(tmp, target);
+    fs.chmodSync(target, 384);
   } catch (e) {
     try {
       fs.unlinkSync(tmp);
@@ -520,7 +507,7 @@ function acquireLockSync(target) {
   const lockDir = target + ".lock";
   for (let attempt = 0;attempt < LOCK_MAX_RETRIES; attempt++) {
     try {
-      fs.mkdirSync(lockDir);
+      fs.mkdirSync(lockDir, { mode: 448 });
       return () => {
         try {
           fs.rmdirSync(lockDir);
@@ -562,9 +549,12 @@ function appendLineLocked(target, line) {
   ensureDir(path2.dirname(target));
   const release = acquireLockSync(target);
   try {
+    if (fs.existsSync(target))
+      fs.chmodSync(target, 384);
     fs.appendFileSync(target, line.endsWith(`
 `) ? line : line + `
-`);
+`, { mode: 384 });
+    fs.chmodSync(target, 384);
   } finally {
     release();
   }
@@ -653,6 +643,27 @@ function writeJsonSync(target, value, pretty = false) {
 // src/utils/extraction.ts
 import path3 from "path";
 
+// src/utils/lru.ts
+function lruGet(m, key) {
+  if (!m.has(key))
+    return;
+  const v = m.get(key);
+  m.delete(key);
+  m.set(key, v);
+  return v;
+}
+function lruSet(m, key, value, max) {
+  if (m.has(key))
+    m.delete(key);
+  m.set(key, value);
+  while (m.size > max) {
+    const oldest = m.keys().next().value;
+    if (oldest === undefined)
+      break;
+    m.delete(oldest);
+  }
+}
+
 // src/utils/tokens.ts
 var PROVIDER_MAP = {
   "zai-anthropic": {
@@ -850,35 +861,19 @@ class TokenCalibrationStore {
     if (!provider)
       return 1;
     const exactKey = calibrationKey(provider, model);
-    const exact = this.factors.get(exactKey);
-    if (exact !== undefined) {
-      this.factors.delete(exactKey);
-      this.factors.set(exactKey, exact);
+    const exact = lruGet(this.factors, exactKey);
+    if (exact !== undefined)
       return exact;
-    }
-    const providerKey = calibrationKey(provider);
-    const fallback = this.factors.get(providerKey);
-    if (fallback !== undefined) {
-      this.factors.delete(providerKey);
-      this.factors.set(providerKey, fallback);
-    }
-    return fallback ?? 1;
+    return lruGet(this.factors, calibrationKey(provider)) ?? 1;
   }
   calibrate(estimated, actual, provider, model) {
     if (actual <= 0 || estimated <= 0 || !provider)
       return;
     const key = calibrationKey(provider, model);
-    const prev = this.factors.get(key) ?? 1;
+    const prev = lruGet(this.factors, key) ?? 1;
     const target = prev * actual / estimated;
     const clamped = Math.max(TUNING.CALIBRATION_CLAMP_MIN, Math.min(TUNING.CALIBRATION_CLAMP_MAX, target));
-    this.factors.delete(key);
-    this.factors.set(key, prev * TUNING.EMA_PREV + clamped * TUNING.EMA_SAMPLE);
-    while (this.factors.size > Math.max(1, this.maxEntries)) {
-      const oldest = this.factors.keys().next().value;
-      if (oldest === undefined)
-        break;
-      this.factors.delete(oldest);
-    }
+    lruSet(this.factors, key, prev * TUNING.EMA_PREV + clamped * TUNING.EMA_SAMPLE, Math.max(1, this.maxEntries));
   }
   size() {
     return this.factors.size;
@@ -1218,12 +1213,192 @@ function extractFileRefs(summary) {
   return candidates.filter(isLikelyFileRef);
 }
 
+// src/domain/summary-schema.ts
+function classifyHeading(raw) {
+  const text = raw.replace(/^#+\s*/, "").replace(/[:\s]+$/, "").trim().toLowerCase();
+  if (!text)
+    return "unknown";
+  if (text === "goal" || text === "goals" || text === "objective" || text === "objectives")
+    return "goal";
+  if (text.startsWith("constraint") || text.includes("preference"))
+    return "constraints";
+  if (text === "progress" || text === "status")
+    return "progress";
+  if (text.includes("key decision") || text === "decisions")
+    return "decisions";
+  if (text.includes("file") && text.includes("modif"))
+    return "files-modified";
+  if (text.includes("file") && (text.includes("read") || text.includes("viewed")))
+    return "files-read";
+  if (text.includes("next step") || text === "next actions")
+    return "next-steps";
+  if (text.includes("critical context") || text === "important context")
+    return "critical-context";
+  if (text === "topics" || text.includes("topics covered"))
+    return "topics";
+  if (text.includes("open loop") || text.includes("unresolved"))
+    return "open-loops";
+  if (text.includes("changes since") || text === "changes")
+    return "changes";
+  if (text.includes("verification"))
+    return "verification-note";
+  return "unknown";
+}
+function canonicalHeading(kind) {
+  switch (kind) {
+    case "goal":
+      return SECTION_GOAL;
+    case "constraints":
+      return SECTION_CONSTRAINTS;
+    case "progress":
+      return SECTION_PROGRESS;
+    case "decisions":
+      return SECTION_DECISIONS;
+    case "files-modified":
+      return SECTION_FILES_MODIFIED;
+    case "files-read":
+      return SECTION_FILES_READ;
+    case "next-steps":
+      return SECTION_NEXT_STEPS;
+    case "critical-context":
+      return SECTION_CRITICAL_CONTEXT;
+    case "topics":
+      return SECTION_TOPICS;
+    case "open-loops":
+      return SECTION_OPEN_LOOPS;
+    case "changes":
+      return SECTION_CHANGES;
+    case "verification-note":
+      return "## Verification Note";
+    case "unknown":
+    default:
+      return "## Section";
+  }
+}
+
+// src/domain/summary-parse.ts
+var HEADING_RE = /^(#{1,3})\s+(.+?)\s*$/;
+function summaryEvidenceLine(value, maxLength) {
+  return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim().replace(/^(?:(?:#{1,6}|[-*+]|>)\s+)+/, "").slice(0, maxLength).trim();
+}
+function mergeBodies(first, second) {
+  const seen = new Set;
+  return [first, second].filter(Boolean).flatMap((body) => body.split(`
+`)).filter((line) => seen.has(line) ? false : (seen.add(line), true)).join(`
+`).trim();
+}
+function parseSummary(markdown) {
+  const sections = [];
+  const lines = markdown.split(`
+`);
+  let currentHeading = "";
+  let currentKind = "unknown";
+  let bodyLines = [];
+  let started = false;
+  const flush = () => {
+    if (!started)
+      return;
+    const body = bodyLines.join(`
+`).trim();
+    const existing = currentKind === "unknown" ? undefined : sections.find((s) => s.kind === currentKind);
+    if (existing)
+      existing.body = mergeBodies(existing.body, body);
+    else
+      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;
+      }
+    }
+    if (started)
+      bodyLines.push(line);
+  }
+  flush();
+  return { sections };
+}
+function findSection(summary, kind) {
+  const parsed = typeof summary === "string" ? parseSummary(summary) : summary;
+  return parsed.sections.find((s) => s.kind === kind);
+}
+function renderSummary(summary, opts = {}) {
+  return summary.sections.map((s) => {
+    const heading = opts.canonicalHeadings && s.kind !== "unknown" ? canonicalHeading(s.kind) : s.heading;
+    return heading + `
+` + s.body;
+  }).join(`
+
+`).replace(/\n{3,}/g, `
+
+`).trim() + `
+`;
+}
+function upsertSection(summary, kind, body, placement) {
+  const heading = canonicalHeading(kind);
+  const existing = summary.sections.findIndex((s) => s.kind === kind);
+  if (existing >= 0) {
+    const sections = summary.sections.slice();
+    sections[existing] = { kind, heading, body: body.trim() };
+    return { sections };
+  }
+  const hint = placement == null ? {} : typeof placement === "string" ? { before: placement } : placement;
+  const section = { kind, heading, body: body.trim() };
+  if (hint.before) {
+    const idx = summary.sections.findIndex((s) => s.kind === hint.before);
+    if (idx >= 0) {
+      const sections = summary.sections.slice();
+      sections.splice(idx, 0, section);
+      return { sections };
+    }
+  }
+  if (hint.after) {
+    let idx = -1;
+    for (let i = summary.sections.length - 1;i >= 0; i--) {
+      if (summary.sections[i].kind === hint.after) {
+        idx = i;
+        break;
+      }
+    }
+    if (idx >= 0) {
+      const sections = summary.sections.slice();
+      sections.splice(idx + 1, 0, section);
+      return { sections };
+    }
+  }
+  return { sections: [...summary.sections, section] };
+}
+function appendToSection(summary, kind, text, fallbackBody = "") {
+  const heading = canonicalHeading(kind);
+  const idx = summary.sections.findIndex((s) => s.kind === kind);
+  if (idx >= 0) {
+    const sections = summary.sections.slice();
+    const existing = sections[idx];
+    const body = /^-\s*(?:none|none recorded|no blockers?|yok)[.!]?$/i.test(existing.body.trim()) ? "" : existing.body.trim();
+    const combined = body ? body + `
+` + text.trim() : text.trim();
+    sections[idx] = { kind, heading, body: combined };
+    return { sections };
+  }
+  return upsertSection(summary, kind, (fallbackBody.trim() ? fallbackBody.trim() + `
+` : "") + text.trim());
+}
+
 // src/utils/extraction.ts
 var TRUNCATE_RE = /\u2026\u2702\d+$/;
 function isTruncated(content) {
   return TRUNCATE_RE.test(extractText(content));
 }
-var DELETE_RESULT_RE = /\b(?:deleted|removed|unlinked)\b/i;
+function nestedToolCallId(wrapperId, messageIndex, toolIndex, nestedId) {
+  return typeof nestedId === "string" ? nestedId : wrapperId ? wrapperId + "_" + toolIndex : ID_PREFIX.MULTI_TOOL_USE_SYNTHETIC + messageIndex + "_" + toolIndex;
+}
 function flattenToolCallBlock(b) {
   if (!isToolCallBlock(b))
     return [];
@@ -1304,8 +1479,8 @@ function buildToolCallIndex(msgs) {
         const nested = flattenToolCallBlock(b);
         for (let t = 0;t < nested.length; t++) {
           const tool = nested[t];
-          const syntheticId = b.id ? b.id + "_" + t : "mtu_" + i + "_" + t;
-          idx.set(tool.id || syntheticId, { name: tool.name, arguments: tool.arguments, msgIndex: i });
+          const id = nestedToolCallId(b.id, i, t, tool.id);
+          idx.set(id, { name: tool.name, arguments: tool.arguments, msgIndex: i });
         }
       }
     }
@@ -1333,14 +1508,15 @@ function trackFileOps(msgs, _tcIdx) {
       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);
       }
     } else if (operation === "delete") {
       delSet.add(filePath);
+      modMap.delete(filePath);
+      readSet.delete(filePath);
     } else if (operation === "read" || operation === "search" || operation === "list") {
-      if (DELETE_RESULT_RE.test(extractText(m.content)))
-        delSet.add(filePath);
-      else
-        readSet.add(filePath);
+      readSet.add(filePath);
+      delSet.delete(filePath);
     }
   }
   return {
@@ -1366,6 +1542,10 @@ function hasCommandFailureSignal(text) {
   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 isTransientToolDiagnostic(text) {
+  const candidate = text.trim();
+  return /\bBrave Search API error\s*\(429\)/i.test(candidate) || /\bnpm error code ENOLOCK\b/i.test(candidate) && /(?:audit|existing lockfile|loadVirtual)/i.test(candidate) || /^Found \d+ occurrences? of edits\[\d+\](?!\w)/i.test(candidate) || /^Unknown JSON field:/i.test(candidate) && /Available fields:/i.test(candidate);
+}
 function catalogErrors(msgs, _tcIdx) {
   const tcIdx = _tcIdx ?? buildToolCallIndex(msgs);
   const errors = [];
@@ -1375,7 +1555,7 @@ function catalogErrors(msgs, _tcIdx) {
       continue;
     const tc = tcIdx.get(m.toolCallId ?? "");
     const text = extractText(m.content);
-    if (tc && isBenignSearchResult(tc, text))
+    if (tc && isBenignSearchResult(tc, text) || isTransientToolDiagnostic(text))
       continue;
     if (m.isError) {
       errors.push({ index: i, tool: tc?.name ?? "unknown", message: text.slice(0, TRUNC.ERROR_DETAIL), retryAttempted: false, resolved: false });
@@ -1562,13 +1742,27 @@ function buildTimeline(msgs, errors) {
     ...timeline.filter((t) => t.event === "error")
   ].sort((a, b) => a.index - b.index) : timeline;
 }
+var HISTORY_SUMMARY_RE = /^(?:The conversation history before this point was compacted|The following is a summary of a branch that this conversation came back from)[\s\S]*<summary>/i;
+var ACK_ONLY_RE = /^(?:(?:ok(?:ay)?|tamam|evet|yes|thanks?|te\u015Fekk\u00FCrler|continue|devam(?:\s+et)?|go\s+ahead|proceed)[\s.!]*){1,3}$/iu;
+function isCompactionStatusText(text) {
+  const candidate = summaryEvidenceLine(text, TRUNC.MESSAGE).replace(/^["'`]+/, "").trim();
+  return /^(?:EESV Compact\b|Smart compact (?:skipped|prepared|run finished)\b|Auto-compacting\b)/i.test(candidate);
+}
 function extractMainGoal(msgs) {
-  for (const m of msgs) {
+  for (let i = msgs.length - 1;i >= 0; i--) {
+    const m = msgs[i];
     if (m?.role !== "user")
       continue;
-    const txt = extractText(m.content).trim();
-    if (txt && !txt.startsWith("/"))
-      return txt.slice(0, TRUNC.MESSAGE);
+    const text = extractText(m.content).trim();
+    if (!text)
+      continue;
+    if (HISTORY_SUMMARY_RE.test(text)) {
+      const carried = summaryEvidenceLine(findSection(text, "goal")?.body ?? "", TRUNC.MESSAGE);
+      return carried && !isCompactionStatusText(carried) ? carried : null;
+    }
+    if (text.startsWith("/") || ACK_ONLY_RE.test(text))
+      continue;
+    return summaryEvidenceLine(text, TRUNC.MESSAGE) || null;
   }
   return null;
 }
@@ -1687,12 +1881,16 @@ function extractStructured(msgs, pc, precomputedTcIdx) {
 
 // src/utils/helpers.ts
 var VALID_PROFILES = ["light", "balanced", "aggressive"];
-var VALID_MODES = ["auto", "balanced", "aggressive", "fast", "thorough"];
+var VALID_MODES = ["auto", "fast", "balanced", "thorough"];
 var VALID_THINKING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"];
 var PROFILE_NUMERIC_KEYS = ["summaryBudgetTokens", "keepRecentTokens", "minChunkTokens", "maxChunkTokens", "singlePassMaxTokens", "batchMaxTokens"];
 function validateSmartCompactConfig(sc) {
+  if (sc.mode === "aggressive") {
+    warn("smart-compact config: mode 'aggressive' is deprecated; using 'fast'.");
+    sc.mode = "fast";
+  }
   if ("mode" in sc && !VALID_MODES.includes(sc.mode)) {
-    warn("smart-compact config: invalid mode '" + sc.mode + "', expected auto|balanced|aggressive|fast|thorough. Using default 'auto'.");
+    warn("smart-compact config: invalid mode '" + sc.mode + "', expected auto|fast|balanced|thorough. Using default 'auto'.");
     delete sc.mode;
   }
   if ("telemetryChannel" in sc && sc.telemetryChannel !== "stable" && sc.telemetryChannel !== "canary") {
@@ -3086,12 +3284,22 @@ function mergeExtractions(base, delta, baseMsgCount, deltaMessages = [], deltaTo
     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);
   }
+  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 reconciledBaseErrors = reconcileCachedErrors(base.errors, deltaMessages, deltaToolCalls, baseMsgCount);
-  const mergedErrors = [...reconciledBaseErrors, ...offsetErrors];
+  const mergedErrors = [...reconciledBaseErrors, ...offsetErrors].filter((error2) => !isTransientToolDiagnostic(error2.message));
   return {
     modifiedFiles: [...modified.values()],
-    readFiles: [...new Set([...base.readFiles, ...delta.readFiles])],
-    deletedFiles: [...new Set([...base.deletedFiles, ...delta.deletedFiles])],
+    readFiles: [...readFiles],
+    deletedFiles: [...deletedFiles],
     referencedFiles: [...new Set([...base.referencedFiles ?? [], ...delta.referencedFiles ?? []])].slice(0, 200),
     mediaAttachments: [...base.mediaAttachments ?? [], ...offsetMedia],
     errors: mergedErrors,
@@ -3099,7 +3307,7 @@ function mergeExtractions(base, delta, baseMsgCount, deltaMessages = [], deltaTo
     constraints: [...base.constraints, ...offsetConstraints],
     topics: [...base.topics, ...offsetTopics],
     timeline: [...base.timeline, ...offsetTimeline],
-    mainGoal: base.mainGoal ?? delta.mainGoal,
+    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
@@ -3220,10 +3428,10 @@ function p95(values) {
   return sorted[Math.max(0, Math.ceil(sorted.length * 0.95) - 1)] ?? 0;
 }
 function stats(entries, damage) {
-  const successes = entries.filter((entry) => entry.status === "success" || entry.status === "dry-run");
-  const quality = successes.filter((entry) => typeof entry.verificationScore === "number");
-  const appliedRuns = entries.filter((entry) => entry.status === "success");
-  const appliedRunIds = new Set(appliedRuns.filter((entry) => typeof entry.runId === "string" && entry.runId.length >= 8).map((entry) => entry.runId));
+  const evidence = entries.filter((entry) => entry.status !== "dry-run");
+  const successfulRuns = evidence.filter((entry) => entry.status === "success");
+  const quality = successfulRuns.filter((entry) => typeof entry.verificationScore === "number");
+  const appliedRunIds = new Set(successfulRuns.filter((entry) => typeof entry.runId === "string" && entry.runId.length >= 8).map((entry) => entry.runId));
   const observedScores = new Map;
   for (const observation of damage) {
     if (!observation.runId || !appliedRunIds.has(observation.runId) || typeof observation.damageScore !== "number" || !Number.isFinite(observation.damageScore))
@@ -3233,14 +3441,15 @@ function stats(entries, damage) {
   const damaging = [...observedScores.values()].filter((score) => score > 0).length;
   return {
     runs: entries.length,
-    successRate: entries.length ? successes.length / entries.length : 0,
+    appliedRuns: evidence.length,
+    successRate: evidence.length ? successfulRuns.length / evidence.length : 1,
     avgQuality: quality.length ? quality.reduce((sum, entry) => sum + (entry.verificationScore ?? 0), 0) / quality.length : null,
-    qualityCoverage: entries.length ? quality.length / entries.length : 0,
-    p95LatencyMs: p95(entries.map((entry) => entry.durationMs ?? entry.avgLatency).filter(Number.isFinite)),
-    avgTokens: entries.length ? entries.reduce((sum, entry) => sum + entry.totalInput + entry.totalCacheHit + (entry.totalCacheWrite ?? 0) + entry.totalOutput, 0) / entries.length : 0,
-    fallbackRate: entries.length ? entries.filter((entry) => entry.method === "heuristic" || Array.isArray(entry.providerRoutes) && entry.providerRoutes.some((route) => route.successes < route.calls)).length / entries.length : 0,
+    qualityCoverage: evidence.length ? quality.length / evidence.length : 0,
+    p95LatencyMs: p95(evidence.map((entry) => entry.durationMs ?? entry.avgLatency).filter(Number.isFinite)),
+    avgTokens: evidence.length ? evidence.reduce((sum, entry) => sum + entry.totalInput + entry.totalCacheHit + (entry.totalCacheWrite ?? 0) + entry.totalOutput, 0) / evidence.length : 0,
+    fallbackRate: evidence.length ? evidence.filter((entry) => entry.method === "heuristic" || Array.isArray(entry.providerRoutes) && entry.providerRoutes.some((route) => route.successes < route.calls)).length / evidence.length : 0,
     damageRate: observedScores.size ? damaging / observedScores.size : 0,
-    damageCoverage: appliedRuns.length ? observedScores.size / appliedRuns.length : 0
+    damageCoverage: successfulRuns.length ? observedScores.size / successfulRuns.length : 0
   };
 }
 function roundStats(value) {
@@ -3265,7 +3474,7 @@ function assessCanary(entries, damageEntries, options) {
   const triggers = [];
   const failureBaseline = 1 - baseline.successRate;
   const failureCanary = 1 - canary.successRate;
-  if (canary.runs >= 3 && (failureCanary > 0.050001 || failureCanary - failureBaseline >= 0.050001)) {
+  if (canary.appliedRuns >= 3 && (failureCanary > 0.050001 || failureCanary - failureBaseline >= 0.050001)) {
     triggers.push({
       metric: "failure-rate",
       baseline: failureBaseline,
@@ -3293,15 +3502,17 @@ function assessCanary(entries, damageEntries, options) {
   if (canary.damageRate - baseline.damageRate >= 0.1) {
     triggers.push({ metric: "damage", baseline: baseline.damageRate, canary: canary.damageRate, threshold: "+10pp" });
   }
-  const dataConfidence = Math.round(100 * (Math.min(1, canary.runs / minCanaryRuns) * 0.25 + Math.min(1, baseline.runs / Math.max(20, minCanaryRuns)) * 0.15 + canary.qualityCoverage * 0.2 + canary.damageCoverage * 0.2 + baseline.damageCoverage * 0.2));
+  const canarySampleAdequacy = Math.min(1, canary.appliedRuns / minCanaryRuns);
+  const baselineSampleAdequacy = Math.min(1, baseline.appliedRuns / Math.max(20, minCanaryRuns));
+  const dataConfidence = Math.round(100 * (canarySampleAdequacy * 0.25 + baselineSampleAdequacy * 0.15 + canary.qualityCoverage * canarySampleAdequacy * 0.2 + canary.damageCoverage * canarySampleAdequacy * 0.2 + baseline.damageCoverage * baselineSampleAdequacy * 0.2));
   const reasons = [];
   let decision = "hold";
-  if (triggers.length && canary.runs >= 3) {
+  if (triggers.length && canary.appliedRuns >= 3) {
     decision = "rollback";
     reasons.push(...triggers.map((trigger) => trigger.metric + " crossed " + trigger.threshold));
-  } else if (canary.runs < minCanaryRuns) {
-    reasons.push("need " + (minCanaryRuns - canary.runs) + " more canary runs");
-  } else if (baseline.runs < Math.max(20, minCanaryRuns)) {
+  } else if (canary.appliedRuns < minCanaryRuns) {
+    reasons.push("need " + (minCanaryRuns - canary.appliedRuns) + " more canary runs with applied outcomes");
+  } else if (baseline.appliedRuns < Math.max(20, minCanaryRuns)) {
     reasons.push("stable baseline is too small");
   } else if (canary.qualityCoverage < 0.7) {
     reasons.push("schema-v2 quality coverage is below 70%");
@@ -3327,7 +3538,7 @@ function assessCanary(entries, damageEntries, options) {
     reasons
   };
 }
-var FAILURE_KINDS = new Set([
+var TELEMETRY_FAILURE_KINDS = new Set([
   "cancelled",
   "timeout",
   "rate-limit",
@@ -3341,6 +3552,9 @@ var FAILURE_KINDS = new Set([
   "yield",
   "internal"
 ]);
+function isTelemetryFailureKind(value) {
+  return typeof value === "string" && TELEMETRY_FAILURE_KINDS.has(value);
+}
 
 // src/ui/dashboard-format.ts
 var DASHBOARD_PAGE_SIZE = 24;
@@ -3636,7 +3850,7 @@ function formatDashboardCanary(insights) {
     "Canary / stable control",
     "",
     "Decision: " + c.decision.toUpperCase() + " | data confidence " + c.dataConfidence + "%",
-    "Runs: stable " + c.baseline.runs + " | canary " + c.canary.runs,
+    "Runs (total/applied): stable " + c.baseline.runs + "/" + c.baseline.appliedRuns + " | canary " + c.canary.runs + "/" + c.canary.appliedRuns,
     "Success: stable " + Math.round(c.baseline.successRate * 100) + "% | canary " + Math.round(c.canary.successRate * 100) + "%",
     "Quality: stable " + (c.baseline.avgQuality?.toFixed(1) ?? "\u2014") + " | canary " + (c.canary.avgQuality?.toFixed(1) ?? "\u2014"),
     "p95: stable " + c.baseline.p95LatencyMs + "ms | canary " + c.canary.p95LatencyMs + "ms",
@@ -3651,21 +3865,8 @@ function formatDashboardCanary(insights) {
 }
 function buildDashboardInsights(entries, damageEntries = [], options = {}) {
   const failures = {};
-  const knownFailures = new Set([
-    "cancelled",
-    "timeout",
-    "rate-limit",
-    "authentication",
-    "budget",
-    "output-limit",
-    "provider",
-    "persistence",
-    "validation",
-    "verification",
-    "internal"
-  ]);
   for (const entry of entries) {
-    if (entry.failureKind && knownFailures.has(entry.failureKind)) {
+    if (isTelemetryFailureKind(entry.failureKind)) {
       failures[entry.failureKind] = (failures[entry.failureKind] ?? 0) + 1;
     }
   }
@@ -3815,7 +4016,7 @@ function canaryRows(insights) {
   const baseline = insights.canary.baseline;
   const canary = insights.canary.canary;
   const rows = [
-    ["Runs", metricNum(baseline.runs), metricNum(canary.runs)],
+    ["Runs (total/applied)", metricNum(baseline.runs) + "/" + metricNum(baseline.appliedRuns), metricNum(canary.runs) + "/" + metricNum(canary.appliedRuns)],
     ["Success", metricPct(baseline.successRate), metricPct(canary.successRate)],
     ["Verify quality", baseline.avgQuality?.toFixed(1) ?? "\u2014", canary.avgQuality?.toFixed(1) ?? "\u2014"],
     ["p95 duration", metricMs(baseline.p95LatencyMs), metricMs(canary.p95LatencyMs)],
@@ -3921,7 +4122,7 @@ function buildMetricsReport(entries = readMetricsLog(100), damageEntries, prebui
     "- Repair: initial average " + (quality.averageInitial?.toFixed(1) ?? "\u2014") + " \xB7 average gain " + (quality.averageRepairGain?.toFixed(1) ?? "\u2014") + " \xB7 deterministic " + quality.deterministicPatchedRuns + " \xB7 LLM " + quality.llmPatchedRuns + " \xB7 quality floor " + quality.qualityFloorRuns + " \xB7 remaining gaps " + quality.remainingGaps,
     "",
     "## Canary / stable control",
-    "Decision: " + canary.decision.toUpperCase() + " \xB7 confidence " + canary.dataConfidence + "% \xB7 stable n=" + canary.baseline.runs + " \xB7 canary n=" + canary.canary.runs,
+    "Decision: " + canary.decision.toUpperCase() + " \xB7 confidence " + canary.dataConfidence + "% \xB7 stable total/applied=" + canary.baseline.runs + "/" + canary.baseline.appliedRuns + " \xB7 canary total/applied=" + canary.canary.runs + "/" + canary.canary.appliedRuns,
     ...canary.reasons.map((item) => "- " + item),
     ...canary.triggers.map((item) => "- Trigger " + item.metric + ": stable " + item.baseline + " \u2192 canary " + item.canary + " (" + item.threshold + ")"),
     "",
@@ -3963,7 +4164,7 @@ function writeMetricsDashboard(entries = readMetricsLog(200), damageEntries = re
         ${metricCard("Tokens saved", compactNumber(summary.totalSaved), `avg score ${summary.avgScore || "\u2014"}`)}
         ${metricCard("Data Confidence", insights.confidence.score + "/100", `telemetry completeness \xB7 target \u226585 ${insights.confidence.targetMet ? "met" : "not met"}`, confidenceTone)}
         ${metricCard("Quality Health", insights.quality.healthScore + "/100", `actual outcomes \xB7 target \u226585 ${insights.quality.targetMet ? "met" : "not met"}`, qualityTone)}
-        ${metricCard("Canary gate", insights.canary.decision.toUpperCase(), `${insights.canary.canary.runs} canary \xB7 ${insights.canary.dataConfidence}% confidence`, canaryTone)}
+        ${metricCard("Canary gate", insights.canary.decision.toUpperCase(), `${insights.canary.canary.runs}/${insights.canary.canary.appliedRuns} canary total/applied \xB7 ${insights.canary.dataConfidence}% confidence`, canaryTone)}
       </section>
       <section class="layout">
         <div class="panel"><h2>Duration trend <span class="muted">last ${Math.min(entries.length, 80)} runs</span></h2>${sparkline(entries.slice(-80).map(metricDuration))}</div>
@@ -4159,6 +4360,9 @@ function releaseRunLock(lock, sessionId) {
 // src/infra/session-identity.ts
 import { randomUUID as randomUUID2 } from "crypto";
 var UNRESOLVED_PREFIX = "unresolved:";
+function branchEntryIds(branch) {
+  return Array.from(branch, (entry) => entry.id).filter((id) => typeof id === "string");
+}
 function resolveSessionId(ctx) {
   const resolved = ctx.sessionManager?.getSessionId?.();
   if (typeof resolved === "string" && resolved.length > 0)
@@ -4171,7 +4375,7 @@ function isUnresolvedSessionId(id) {
 
 // src/ui/overlays.ts
 import { DynamicBorder } from "@earendil-works/pi-coding-agent";
-import { Container, Key, matchesKey, SelectList, Text, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { Container, Key, matchesKey, SelectList, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 // src/utils/fingerprint.ts
 import path7 from "path";
@@ -4187,7 +4391,12 @@ function findGitRoot(cwd) {
     return ROOT_CACHE.get(cwd) ?? null;
   let root = null;
   try {
-    const out = execSync("git rev-parse --show-toplevel", { cwd, encoding: "utf-8", timeout: 2000 });
+    const out = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 2000,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
     root = out.trim() || null;
   } catch (e) {
     debug("git rev-parse failed for " + cwd, e);
@@ -4286,7 +4495,13 @@ function deriveFromRelativePaths(paths) {
   return hashProjectId(topEntries.join(",") + "|" + stableDirs.join(","));
 }
 function deriveProjectIdFromCwd(cwd) {
-  return hashProjectId(findGitRoot2(cwd) ?? cwd);
+  if (!cwd)
+    return null;
+  const resolved = path7.resolve(cwd);
+  const home2 = process.env.HOME ? path7.resolve(process.env.HOME) : null;
+  if (resolved === path7.parse(resolved).root || resolved === home2)
+    return null;
+  return hashProjectId(findGitRoot2(resolved) ?? resolved);
 }
 function deriveProjectId(cwd, extraction, sessionId) {
   if (cwd && cwd !== "/" && cwd !== process.env.HOME) {
@@ -4359,24 +4574,35 @@ function loadProjectFingerprint(projectId) {
 }
 function saveProjectFingerprint(projectId, extraction) {
   try {
-    const existing = loadProjectFingerprint(projectId);
-    const newKnownFiles = [...new Set([
-      ...existing?.knownFiles ?? [],
-      ...extraction.modifiedFiles.map((f) => f.path),
-      ...extraction.readFiles
-    ])].slice(-50);
-    const detectedLanguage = detectLanguage(extraction);
-    const detectedFramework = detectFramework(extraction);
-    const fingerprint = {
-      id: projectId,
-      language: existing?.language && existing.language !== "unknown" ? existing.language : detectedLanguage,
-      framework: existing?.framework ?? detectedFramework,
-      keyDirectories: extractKeyDirs(extraction),
-      knownFiles: newKnownFiles,
-      sessionCount: (existing?.sessionCount ?? 0) + 1,
-      updatedAt: Date.now()
-    };
-    writeJsonSync(getFingerprintPath(projectId), fingerprint, true);
+    const fingerprintPath = getFingerprintPath(projectId);
+    ensureDir(path7.dirname(fingerprintPath));
+    const release = acquireLockSync(fingerprintPath);
+    try {
+      const existing = loadProjectFingerprint(projectId);
+      const newKnownFiles = [...new Set([
+        ...existing?.knownFiles ?? [],
+        ...extraction.modifiedFiles.map((f) => f.path),
+        ...extraction.readFiles
+      ])].slice(-50);
+      const detectedLanguage = detectLanguage(extraction);
+      const detectedFramework = detectFramework(extraction);
+      const keyDirectories = [...new Set([
+        ...existing?.keyDirectories ?? [],
+        ...extractKeyDirs(extraction)
+      ])].slice(-20);
+      const fingerprint = {
+        id: projectId,
+        language: existing?.language && existing.language !== "unknown" ? existing.language : detectedLanguage,
+        framework: existing?.framework ?? detectedFramework,
+        keyDirectories,
+        knownFiles: newKnownFiles,
+        sessionCount: (existing?.sessionCount ?? 0) + 1,
+        updatedAt: Date.now()
+      };
+      writeJsonSync(fingerprintPath, fingerprint, true);
+    } finally {
+      release();
+    }
   } catch (e) {
     warn("saveProjectFingerprint failed", e);
   }
@@ -4584,6 +4810,22 @@ function advance(rc, _stage) {
 }
 
 // src/app/steps/window.ts
+function compactionPlanReasonText(reason) {
+  switch (reason) {
+    case "viable":
+      return "safe window and useful estimated saving";
+    case "no-eligible-prefix":
+      return "no older prefix is available";
+    case "unsafe-tool-boundary":
+      return "no complete tool-call boundary is available";
+    case "retention-target-exceeded":
+      return "a complete tool pair exceeds the tail target";
+    case "mode-target-not-met":
+      return "the estimated result misses this preset's target";
+    case "insufficient-projected-saving":
+      return "estimated saving is below 10%";
+  }
+}
 function planCompactionWindow(input) {
   const {
     msgs,
@@ -4601,7 +4843,8 @@ function planCompactionWindow(input) {
   const fixedContextTokens = overflowedContext ? 0 : Math.max(0, totalTokens - allMessageTokens);
   const adaptiveKeepTokens = modelContextWindow ? Math.min(profileCfg.keepRecentTokens * 2, Math.max(profileCfg.keepRecentTokens, modelContextWindow * 0.04)) : profileCfg.keepRecentTokens;
   const targetPercent = MODE_POLICIES[mode].targetContextPercent;
-  const targetRetainedTokens = modelContextWindow ? Math.max(0, modelContextWindow * targetPercent / 100 - fixedContextTokens - profileCfg.summaryBudgetTokens) : adaptiveKeepTokens;
+  const postSummaryReserveTokens = Math.ceil(profileCfg.summaryBudgetTokens * POST_SUMMARY_RESERVE_RATIO);
+  const targetRetainedTokens = modelContextWindow ? Math.max(0, modelContextWindow * targetPercent / 100 - fixedContextTokens - profileCfg.summaryBudgetTokens - postSummaryReserveTokens) : adaptiveKeepTokens;
   const retentionCeiling = force ? adaptiveKeepTokens : Math.max(adaptiveKeepTokens, targetRetainedTokens);
   const rawMinimumTail = adaptiveKeepTokens / messageScale;
   const rawRetentionCeiling = retentionCeiling / messageScale;
@@ -4644,10 +4887,10 @@ function planCompactionWindow(input) {
   hardBoundaryAdjusted ||= keepFrom !== boundaryBeforeHardGuard;
   const compactTokens = Math.round(messageTokens.slice(0, keepFrom).reduce((sum, tokens) => sum + tokens, 0) * messageScale);
   const retainedTokens = retainedAt(keepFrom);
-  const projectedAfterTokens = fixedContextTokens + retainedTokens + profileCfg.summaryBudgetTokens;
+  const projectedAfterTokens = fixedContextTokens + retainedTokens + profileCfg.summaryBudgetTokens + postSummaryReserveTokens;
   const projectedSavedTokens = Math.max(0, totalTokens - projectedAfterTokens);
   const projectedYield = totalTokens > 0 ? projectedSavedTokens / totalTokens : 0;
-  const targetAfterTokens = !force && modelContextWindow ? modelContextWindow * targetPercent / 100 : fixedContextTokens + effectiveRetentionCeiling + profileCfg.summaryBudgetTokens;
+  const targetAfterTokens = !force && modelContextWindow ? modelContextWindow * targetPercent / 100 : fixedContextTokens + effectiveRetentionCeiling + profileCfg.summaryBudgetTokens + postSummaryReserveTokens;
   let reason = "viable";
   if (msgs[keepFrom]?.message?.role === "toolResult")
     reason = "unsafe-tool-boundary";
@@ -4701,8 +4944,7 @@ function resolveCompactionWindow(rc) {
   });
   if (!plan.viable) {
     if (rc.flags.force) {
-      const detail = plan.reason === "insufficient-projected-saving" ? "projected saving is below 10%." : plan.reason === "unsafe-tool-boundary" ? "no safe tool-call boundary is available." : plan.reason === "no-eligible-prefix" ? "no eligible prefix remains." : plan.reason === "retention-target-exceeded" ? "a complete tool pair exceeds the retention target." : "the projected context remains above the mode target.";
-      rc.notify("Manual compaction skipped: " + detail, "warning");
+      rc.notify("Manual compaction skipped: " + compactionPlanReasonText(plan.reason) + ".", "warning");
     } else {
       rc.notify("Smart compact skipped: the safe plan cannot meet its target; using native compaction instead.", "warning");
     }
@@ -4711,281 +4953,130 @@ 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;
-  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");
-  }
-  const out = rc;
-  out.sessionId = resolveSessionId(rc.ctx);
-  out.branch = branch;
-  out.msgs = msgs;
-  out.totalTokens = totalTokens;
-  out.contextPercent = contextPercent;
-  out.toolPercent = 0;
-  out.keepFrom = plan.keepFrom;
-  out.toCompact = msgs.slice(0, plan.keepFrom);
-  out.firstKeptId = msgs[plan.keepFrom].id;
-  out.compactTokens = plan.compactTokens;
-  out.accTokens = plan.retainedTokens;
-  out.compactionPlan = plan;
-  return advance(out, "_windowed");
-}
-
-// src/app/preflight.ts
-function preflightDamageMedian(cwd, config) {
-  if (!config.adaptiveDamageFeedback)
-    return 0;
-  const recent = readRecentDamageScores(deriveProjectIdFromCwd(cwd), 5).slice(-3).sort((a, b) => a - b);
-  return recent.length ? recent[Math.floor(recent.length / 2)] : 0;
-}
-function preparePreflightProfile(input) {
-  const config = input.config;
-  const profile = MODE_POLICIES[input.mode].profile;
-  let profileCfg = { ...PROFILES[profile], ...config.profiles?.[profile] ?? {} };
-  const damageMedian = input.damageMedian ?? preflightDamageMedian(input.cwd, config);
-  if (damageMedian >= 25) {
-    profileCfg = {
-      ...profileCfg,
-      keepRecentTokens: Math.round(profileCfg.keepRecentTokens * (damageMedian >= 50 ? 1.5 : 1.25)),
-      summaryBudgetTokens: Math.round(profileCfg.summaryBudgetTokens * (damageMedian >= 50 ? 1.3 : 1.2))
-    };
-  }
-  return {
-    profileCfg,
-    estimator: makeTokenEstimator(input.summaryModel.provider, input.summaryModel.id, input.tokenCalibration),
-    adapted: damageMedian >= 25,
-    damageMedian
-  };
-}
-function planManualPreflight(ctx, summaryModel, mode, tokenCalibration, config, damageMedian) {
-  const prepared = preparePreflightProfile({ cwd: ctx.cwd, summaryModel, mode, tokenCalibration, config, damageMedian });
-  const manager = ctx.sessionManager;
-  const branch = typeof manager.buildContextEntries === "function" ? manager.buildContextEntries() : manager.getBranch();
-  const msgs = branch.filter((entry) => entry.type === "message" && entry.message != null);
-  const totalTokens = ctx.getContextUsage()?.tokens ?? 0;
-  const contextWindowTokens = ctx.model?.contextWindow ?? 0;
-  const contextPercent = contextWindowTokens > 0 ? totalTokens / contextWindowTokens * 100 : 0;
-  const toolPercent = computeToolCharPercentage(branch);
-  const overflowedContext = contextWindowTokens > 0 && totalTokens > contextWindowTokens;
-  const messageTokens = msgs.map((entry) => prepared.estimator.message(entry.message));
-  const rawEstimatedMessageTokens = messageTokens.reduce((sum, tokens) => sum + tokens, 0);
-  if (msgs.length < 3) {
-    return { mode, plan: null, reason: "not-enough-messages", profileCfg: prepared.profileCfg, totalTokens, rawEstimatedMessageTokens, estimatorScale: 1, adapted: prepared.adapted, damageMedian: prepared.damageMedian, contextWindowTokens, contextPercent, toolPercent, overflowedContext };
-  }
-  const plan = planCompactionWindow({
-    msgs,
-    branch,
-    messageTokens,
-    totalTokens,
-    modelContextWindow: ctx.model?.contextWindow,
-    mode,
-    profileCfg: prepared.profileCfg,
-    force: true,
-    overflowedContext
-  });
-  const normalizedMessages = plan.compactTokens + plan.retainedTokens;
-  return {
-    mode,
-    plan,
-    reason: plan.reason,
-    profileCfg: prepared.profileCfg,
-    totalTokens,
-    rawEstimatedMessageTokens,
-    estimatorScale: rawEstimatedMessageTokens > 0 ? normalizedMessages / rawEstimatedMessageTokens : 1,
-    adapted: prepared.adapted,
-    damageMedian: prepared.damageMedian,
-    contextWindowTokens,
-    contextPercent,
-    toolPercent,
-    overflowedContext
-  };
-}
-
-// src/ui/overlays.ts
-import path8 from "path";
-
-// src/utils/state.ts
-import fs5 from "fs";
-
-// src/domain/summary-schema.ts
-function classifyHeading(raw) {
-  const text = raw.replace(/^#+\s*/, "").replace(/[:\s]+$/, "").trim().toLowerCase();
-  if (!text)
-    return "unknown";
-  if (text === "goal" || text === "goals" || text === "objective" || text === "objectives")
-    return "goal";
-  if (text.startsWith("constraint") || text.includes("preference"))
-    return "constraints";
-  if (text === "progress" || text === "status")
-    return "progress";
-  if (text.includes("key decision") || text === "decisions")
-    return "decisions";
-  if (text.includes("file") && text.includes("modif"))
-    return "files-modified";
-  if (text.includes("file") && (text.includes("read") || text.includes("viewed")))
-    return "files-read";
-  if (text.includes("next step") || text === "next actions")
-    return "next-steps";
-  if (text.includes("critical context") || text === "important context")
-    return "critical-context";
-  if (text === "topics" || text.includes("topics covered"))
-    return "topics";
-  if (text.includes("open loop") || text.includes("unresolved"))
-    return "open-loops";
-  if (text.includes("changes since") || text === "changes")
-    return "changes";
-  if (text.includes("verification"))
-    return "verification-note";
-  return "unknown";
-}
-function canonicalHeading(kind) {
-  switch (kind) {
-    case "goal":
-      return SECTION_GOAL;
-    case "constraints":
-      return SECTION_CONSTRAINTS;
-    case "progress":
-      return SECTION_PROGRESS;
-    case "decisions":
-      return SECTION_DECISIONS;
-    case "files-modified":
-      return SECTION_FILES_MODIFIED;
-    case "files-read":
-      return SECTION_FILES_READ;
-    case "next-steps":
-      return SECTION_NEXT_STEPS;
-    case "critical-context":
-      return SECTION_CRITICAL_CONTEXT;
-    case "topics":
-      return SECTION_TOPICS;
-    case "open-loops":
-      return SECTION_OPEN_LOOPS;
-    case "changes":
-      return SECTION_CHANGES;
-    case "verification-note":
-      return "## Verification Note";
-    case "unknown":
-    default:
-      return "## Section";
-  }
-}
-
-// src/domain/summary-parse.ts
-var HEADING_RE = /^(#{1,3})\s+(.+?)\s*$/;
-function summaryEvidenceLine(value, maxLength) {
-  return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim().replace(/^(?:(?:#{1,6}|[-*+]|>)\s+)+/, "").slice(0, maxLength).trim();
-}
-function mergeBodies(first, second) {
-  const seen = new Set;
-  return [first, second].filter(Boolean).flatMap((body) => body.split(`
-`)).filter((line) => seen.has(line) ? false : (seen.add(line), true)).join(`
-`).trim();
-}
-function parseSummary(markdown) {
-  const sections = [];
-  const lines = markdown.split(`
-`);
-  let currentHeading = "";
-  let currentKind = "unknown";
-  let bodyLines = [];
-  let started = false;
-  const flush = () => {
-    if (!started)
-      return;
-    const body = bodyLines.join(`
-`).trim();
-    const existing = currentKind === "unknown" ? undefined : sections.find((s) => s.kind === currentKind);
-    if (existing)
-      existing.body = mergeBodies(existing.body, body);
-    else
-      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;
-      }
-    }
-    if (started)
-      bodyLines.push(line);
-  }
-  flush();
-  return { sections };
-}
-function findSection(summary, kind) {
-  const parsed = typeof summary === "string" ? parseSummary(summary) : summary;
-  return parsed.sections.find((s) => s.kind === kind);
-}
-function renderSummary(summary, opts = {}) {
-  return summary.sections.map((s) => {
-    const heading = opts.canonicalHeadings && s.kind !== "unknown" ? canonicalHeading(s.kind) : s.heading;
-    return heading + `
-` + s.body;
-  }).join(`
-
-`).replace(/\n{3,}/g, `
-
-`).trim() + `
-`;
-}
-function upsertSection(summary, kind, body, placement) {
-  const heading = canonicalHeading(kind);
-  const existing = summary.sections.findIndex((s) => s.kind === kind);
-  if (existing >= 0) {
-    const sections = summary.sections.slice();
-    sections[existing] = { kind, heading, body: body.trim() };
-    return { sections };
-  }
-  const hint = placement == null ? {} : typeof placement === "string" ? { before: placement } : placement;
-  const section = { kind, heading, body: body.trim() };
-  if (hint.before) {
-    const idx = summary.sections.findIndex((s) => s.kind === hint.before);
-    if (idx >= 0) {
-      const sections = summary.sections.slice();
-      sections.splice(idx, 0, section);
-      return { sections };
-    }
-  }
-  if (hint.after) {
-    let idx = -1;
-    for (let i = summary.sections.length - 1;i >= 0; i--) {
-      if (summary.sections[i].kind === hint.after) {
-        idx = i;
-        break;
-      }
-    }
-    if (idx >= 0) {
-      const sections = summary.sections.slice();
-      sections.splice(idx + 1, 0, section);
-      return { sections };
-    }
-  }
-  return { sections: [...summary.sections, section] };
+  const contextPercent = rc.ctx.model && totalTokens ? totalTokens / rc.ctx.model.contextWindow * 100 : 0;
+  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");
+  }
+  const out = rc;
+  out.sessionId = resolveSessionId(rc.ctx);
+  out.branch = branch;
+  out.msgs = msgs;
+  out.totalTokens = totalTokens;
+  out.contextPercent = contextPercent;
+  out.toolPercent = 0;
+  out.keepFrom = plan.keepFrom;
+  out.toCompact = msgs.slice(0, plan.keepFrom);
+  out.firstKeptId = msgs[plan.keepFrom].id;
+  out.compactTokens = plan.compactTokens;
+  out.accTokens = plan.retainedTokens;
+  out.compactionPlan = plan;
+  return advance(out, "_windowed");
 }
-function appendToSection(summary, kind, text, fallbackBody = "") {
-  const heading = canonicalHeading(kind);
-  const idx = summary.sections.findIndex((s) => s.kind === kind);
-  if (idx >= 0) {
-    const sections = summary.sections.slice();
-    const existing = sections[idx];
-    const body = /^-\s*(?:none|none recorded|no blockers?|yok)[.!]?$/i.test(existing.body.trim()) ? "" : existing.body.trim();
-    const combined = body ? body + `
-` + text.trim() : text.trim();
-    sections[idx] = { kind, heading, body: combined };
-    return { sections };
+
+// src/app/preflight.ts
+function preflightDamageMedian(cwd, config) {
+  if (!config.adaptiveDamageFeedback)
+    return 0;
+  const projectId = deriveProjectIdFromCwd(cwd);
+  if (!projectId)
+    return 0;
+  const recent = readRecentDamageScores(projectId, 5).slice(-3).sort((a, b) => a - b);
+  return recent.length ? recent[Math.floor(recent.length / 2)] : 0;
+}
+function preparePreflightProfile(input) {
+  const config = input.config;
+  const profile = MODE_POLICIES[input.mode].profile;
+  let profileCfg = { ...PROFILES[profile], ...config.profiles?.[profile] ?? {} };
+  const damageMedian = input.damageMedian ?? preflightDamageMedian(input.cwd, config);
+  if (damageMedian >= 25) {
+    profileCfg = {
+      ...profileCfg,
+      keepRecentTokens: Math.round(profileCfg.keepRecentTokens * (damageMedian >= 50 ? 1.5 : 1.25)),
+      summaryBudgetTokens: Math.round(profileCfg.summaryBudgetTokens * (damageMedian >= 50 ? 1.3 : 1.2))
+    };
   }
-  return upsertSection(summary, kind, (fallbackBody.trim() ? fallbackBody.trim() + `
-` : "") + text.trim());
+  return {
+    profileCfg,
+    estimator: makeTokenEstimator(input.summaryModel.provider, input.summaryModel.id, input.tokenCalibration),
+    adapted: damageMedian >= 25,
+    damageMedian
+  };
+}
+function prepareManualPreflightContext(ctx, summaryModel, tokenCalibration) {
+  const branch = typeof ctx.sessionManager.buildContextEntries === "function" ? ctx.sessionManager.buildContextEntries() : ctx.sessionManager.getBranch();
+  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 toolPercent = computeToolCharPercentage(branch);
+  const overflowedContext = contextWindowTokens > 0 && totalTokens > contextWindowTokens;
+  const estimator = makeTokenEstimator(summaryModel.provider, summaryModel.id, tokenCalibration);
+  const messageTokens = msgs.map((entry) => estimator.message(entry.message));
+  return {
+    branch,
+    msgs,
+    messageTokens,
+    totalTokens,
+    rawEstimatedMessageTokens: messageTokens.reduce((sum, tokens) => sum + tokens, 0),
+    modelContextWindow,
+    contextWindowTokens,
+    contextPercent,
+    toolPercent,
+    overflowedContext
+  };
+}
+function planManualPreflight(ctx, summaryModel, mode, tokenCalibration, config, damageMedian, shared = prepareManualPreflightContext(ctx, summaryModel, tokenCalibration)) {
+  const prepared = preparePreflightProfile({ cwd: ctx.cwd, summaryModel, mode, tokenCalibration, config, damageMedian });
+  const {
+    branch,
+    msgs,
+    messageTokens,
+    totalTokens,
+    rawEstimatedMessageTokens,
+    modelContextWindow,
+    contextWindowTokens,
+    contextPercent,
+    toolPercent,
+    overflowedContext
+  } = shared;
+  if (msgs.length < 3) {
+    return { mode, plan: null, reason: "not-enough-messages", profileCfg: prepared.profileCfg, totalTokens, rawEstimatedMessageTokens, estimatorScale: 1, adapted: prepared.adapted, damageMedian: prepared.damageMedian, contextWindowTokens, contextPercent, toolPercent, overflowedContext };
+  }
+  const plan = planCompactionWindow({
+    msgs,
+    branch,
+    messageTokens,
+    totalTokens,
+    modelContextWindow,
+    mode,
+    profileCfg: prepared.profileCfg,
+    force: true,
+    overflowedContext
+  });
+  const normalizedMessages = plan.compactTokens + plan.retainedTokens;
+  return {
+    mode,
+    plan,
+    reason: plan.reason,
+    profileCfg: prepared.profileCfg,
+    totalTokens,
+    rawEstimatedMessageTokens,
+    estimatorScale: rawEstimatedMessageTokens > 0 ? normalizedMessages / rawEstimatedMessageTokens : 1,
+    adapted: prepared.adapted,
+    damageMedian: prepared.damageMedian,
+    contextWindowTokens,
+    contextPercent,
+    toolPercent,
+    overflowedContext
+  };
 }
 
+// src/ui/overlays.ts
+import path8 from "path";
+
 // src/utils/state.ts
+import fs5 from "fs";
 function getStatePath(projectId, state) {
   return state?.scope?.sessionId ? scopedCompactionStateFile(projectId, state.scope.sessionId) : compactionStateFile(projectId);
 }
@@ -4994,12 +5085,16 @@ function isLegacySearchOutput(text) {
   return /^[^\s:][^:]*:\d+(?::\d+)?:/.test(firstLine);
 }
 function sanitizeCompactionStateEvidence(state) {
+  const isNoise = (text) => isLegacySearchOutput(text) || isTransientToolDiagnostic(text.replace(/^Unresolved error:\s*/i, ""));
+  const goal = state.goal && !isCompactionStatusText(state.goal) ? state.goal : null;
   const constraints = state.constraints.filter((item) => !isDiagnosticConstraintText(item.text));
-  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)
+  const unresolvedErrors = state.unresolvedErrors.filter((item) => !isNoise(item.message));
+  const resolvedErrors = state.resolvedErrors.filter((item) => !isNoise(item.message));
+  const openLoops = state.openLoops.filter((item) => !isNoise(item.summary));
+  const criticalContext = state.criticalContext.filter((item) => !isNoise(item));
+  if (goal === state.goal && constraints.length === state.constraints.length && unresolvedErrors.length === state.unresolvedErrors.length && resolvedErrors.length === state.resolvedErrors.length && openLoops.length === state.openLoops.length && criticalContext.length === state.criticalContext.length)
     return state;
-  return { ...state, constraints, unresolvedErrors, openLoops };
+  return { ...state, goal, constraints, unresolvedErrors, resolvedErrors, openLoops, criticalContext };
 }
 function freshState(fp, data) {
   if (!data)
@@ -5022,14 +5117,14 @@ function saveCompactionState(projectId, state) {
     warn("saveCompactionState failed", e);
   }
 }
-function loadScopedCompactionState(scope, branchEntryIds = []) {
+function loadScopedCompactionState(scope, branchEntryIds2 = []) {
   const fp = scopedCompactionStateFile(scope.projectId, scope.sessionId);
   const state = freshState(fp, readJsonSync(fp));
   if (!state?.scope || state.scope.schemaVersion !== 2)
     return null;
   if (state.scope.projectId !== scope.projectId || state.scope.sessionId !== scope.sessionId)
     return null;
-  if (state.scope.branchHeadId && branchEntryIds.length > 0 && !branchEntryIds.includes(state.scope.branchHeadId))
+  if (state.scope.branchHeadId && branchEntryIds2.length > 0 && !branchEntryIds2.includes(state.scope.branchHeadId))
     return null;
   return state;
 }
@@ -5133,26 +5228,34 @@ function mergeBy(current, previous, key, limit) {
     return true;
   }).slice(0, limit);
 }
+var LOOP_PRIORITY = { critical: 0, high: 1, normal: 2, low: 3 };
+function mergeOpenLoops(current, previous) {
+  return mergeBy(current, previous, (item) => normalizeFactKey(item.summary), Number.MAX_SAFE_INTEGER).map((item, order) => ({ item, order })).sort((a, b) => Number(a.item.status === "resolved") - Number(b.item.status === "resolved") || LOOP_PRIORITY[a.item.priority] - LOOP_PRIORITY[b.item.priority] || a.order - b.order).slice(0, 25).map(({ item }, index) => ({ ...item, id: ID_PREFIX.OPEN_LOOP + (index + 1) }));
+}
 function mergeCompactionStates(previous, current) {
-  if (!previous)
-    return applyContinuityOverrides(current, current.factOverrides ?? []);
+  if (!previous) {
+    const active = applyContinuityOverrides(current, current.factOverrides ?? []);
+    return { ...active, openLoops: mergeOpenLoops(active.openLoops, []) };
+  }
   const factOverrides = mergeBy(current.factOverrides ?? [], previous.factOverrides ?? [], (item) => item.kind + ":" + item.summaryKey, 50);
   const activeCurrent = applyContinuityOverrides(current, factOverrides);
   const activePrevious = applyContinuityOverrides(previous, factOverrides);
+  const currentPresent = new Set([...activeCurrent.modifiedFiles, ...activeCurrent.readFiles].map(normalizeFactKey));
+  const currentDeleted = new Set(activeCurrent.deletedFiles.map(normalizeFactKey));
   const resolvedKeys = new Set(activeCurrent.resolvedErrors.map((error2) => normalizeFactKey(error2.message)));
   const decisions = mergeBy(activeCurrent.decisions, activePrevious.decisions, (item) => normalizeFactKey(item.summary), 30).map((item, index) => ({ ...item, id: ID_PREFIX.DECISION + (index + 1) }));
   const constraints = mergeBy(activeCurrent.constraints, activePrevious.constraints, (item) => normalizeFactKey(item.text), 30).map((item, index) => ({ ...item, id: "constraint-" + (index + 1) }));
   const unresolvedErrors = mergeBy(activeCurrent.unresolvedErrors, activePrevious.unresolvedErrors.filter((error2) => !resolvedKeys.has(normalizeFactKey(error2.message))), (item) => normalizeFactKey(item.message), 15).map((item, index) => ({ ...item, id: ID_PREFIX.ERROR + (index + 1) }));
-  const openLoops = mergeBy(activeCurrent.openLoops, activePrevious.openLoops.filter((loop) => loop.status !== "resolved"), (item) => normalizeFactKey(item.summary), 25).map((item, index) => ({ ...item, id: ID_PREFIX.OPEN_LOOP + (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] : [];
   return applyContinuityOverrides({
     ...activeCurrent,
     goal: activeCurrent.goal ?? activePrevious.goal,
     decisions,
     constraints,
-    modifiedFiles: mergeBy(activeCurrent.modifiedFiles, activePrevious.modifiedFiles, normalizeFactKey, 100),
-    readFiles: mergeBy(activeCurrent.readFiles, activePrevious.readFiles, normalizeFactKey, 100),
-    deletedFiles: mergeBy(activeCurrent.deletedFiles, activePrevious.deletedFiles, normalizeFactKey, 50),
+    modifiedFiles: mergeBy(activeCurrent.modifiedFiles, activePrevious.modifiedFiles.filter((file) => !currentDeleted.has(normalizeFactKey(file))), normalizeFactKey, 100),
+    readFiles: mergeBy(activeCurrent.readFiles, activePrevious.readFiles.filter((file) => !currentDeleted.has(normalizeFactKey(file))), normalizeFactKey, 100),
+    deletedFiles: mergeBy(activeCurrent.deletedFiles, activePrevious.deletedFiles.filter((file) => !currentPresent.has(normalizeFactKey(file))), normalizeFactKey, 50),
     unresolvedErrors,
     resolvedErrors: mergeBy(activeCurrent.resolvedErrors, activePrevious.resolvedErrors, (item) => normalizeFactKey(item.message), 20),
     openLoops,
@@ -5206,28 +5309,37 @@ function injectOpenLoopsSection(summary, openLoops) {
   return renderSummary(updated);
 }
 function computeDelta(prev, current) {
-  const key = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
-  const prevDecisionTexts = new Set(prev.decisions.map((d) => key(d.summary)));
-  const currDecisionTexts = new Set(current.decisions.map((d) => key(d.summary)));
-  const newDecisions = current.decisions.filter((d) => !prevDecisionTexts.has(key(d.summary))).map((d) => d.summary);
-  const removedDecisions = prev.decisions.filter((d) => !currDecisionTexts.has(key(d.summary))).map((d) => d.summary);
-  const prevLoopSummaries = new Map(prev.openLoops.filter((loop) => loop.status !== "resolved").map((l) => [key(l.summary), l]));
-  const currLoopKeys = new Set(current.openLoops.filter((loop) => loop.status !== "resolved").map((l) => key(l.summary)));
+  const overrides = current.factOverrides ?? [];
+  const retired = (kind) => new Set(overrides.filter((item) => item.kind === kind && item.status !== "active").map((item) => item.summaryKey));
+  const prevDecisionTexts = new Set(prev.decisions.map((d) => normalizeFactKey(d.summary)));
+  const newDecisions = current.decisions.filter((d) => !prevDecisionTexts.has(normalizeFactKey(d.summary))).map((d) => d.summary);
+  const retiredDecisions = retired("decision");
+  const removedDecisions = prev.decisions.filter((d) => retiredDecisions.has(normalizeFactKey(d.summary))).map((d) => d.summary);
+  const prevLoopSummaries = new Map(prev.openLoops.filter((loop) => loop.status !== "resolved").map((l) => [normalizeFactKey(l.summary), l]));
+  const currLoopKeys = new Set(current.openLoops.filter((loop) => loop.status !== "resolved").map((l) => normalizeFactKey(l.summary)));
+  const resolvedLoopKeys = new Set([
+    ...current.openLoops.filter((loop) => loop.status === "resolved").map((loop) => normalizeFactKey(loop.summary)),
+    ...(current.loopOverrides ?? []).filter((item) => item.status === "resolved").map((item) => item.summaryKey),
+    ...retired("loop")
+  ]);
   const resolvedLoops = [];
   const persistentLoops = [];
   for (const [k, loop] of prevLoopSummaries) {
     if (currLoopKeys.has(k))
       persistentLoops.push(loop.summary);
-    else
+    else if (resolvedLoopKeys.has(k))
       resolvedLoops.push(loop.summary);
   }
-  const newLoops = current.openLoops.filter((loop) => loop.status !== "resolved").filter((l) => !prevLoopSummaries.has(key(l.summary))).map((l) => l.summary);
+  const newLoops = current.openLoops.filter((loop) => loop.status !== "resolved").filter((l) => !prevLoopSummaries.has(normalizeFactKey(l.summary))).map((l) => l.summary);
   const prevFiles = new Set(prev.modifiedFiles);
   const newModifiedFiles = current.modifiedFiles.filter((f) => !prevFiles.has(f));
-  const prevErrorMsgs = new Set(prev.unresolvedErrors.map((e) => key(e.message)));
-  const currErrorMsgs = new Set(current.unresolvedErrors.map((e) => key(e.message)));
-  const resolvedErrors = prev.unresolvedErrors.filter((e) => !currErrorMsgs.has(key(e.message))).map((e) => e.message);
-  const newErrors = current.unresolvedErrors.filter((e) => !prevErrorMsgs.has(key(e.message))).map((e) => e.message);
+  const prevErrorMsgs = new Set(prev.unresolvedErrors.map((e) => normalizeFactKey(e.message)));
+  const resolvedErrorKeys = new Set([
+    ...current.resolvedErrors.map((error2) => normalizeFactKey(error2.message)),
+    ...retired("error")
+  ]);
+  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;
   return {
     newDecisions,
@@ -5389,36 +5501,19 @@ async function selectModel(ctx, opts) {
     return null;
   return options[parseInt(result.slice(6), 10)] ?? null;
 }
-var PRIMARY_MODES = ["thorough", "balanced", "fast"];
+var PRIMARY_MODES = ["fast", "balanced", "thorough"];
 var MODE_LABELS = {
-  thorough: "Thorough",
-  balanced: "Balanced",
   fast: "Fast",
-  aggressive: "Aggressive"
+  balanced: "Balanced",
+  thorough: "Thorough"
 };
 var MODE_COPY = {
-  thorough: "richer summary \xB7 30K base recent tail",
-  balanced: "default balance \xB7 20K base recent tail",
-  fast: "faster run \xB7 20K base recent tail \xB7 6K base summary",
-  aggressive: "maximum recovery \xB7 10K base recent tail"
+  fast: "quickest \xB7 compact 10K recent tail \xB7 3K summary",
+  balanced: "default quality/speed \xB7 20K recent tail \xB7 6K summary",
+  thorough: "deepest analysis \xB7 rich 30K recent tail \xB7 10K summary"
 };
 function explainPreflightReason(reason) {
-  switch (reason) {
-    case "viable":
-      return "safe window and useful estimated saving";
-    case "not-enough-messages":
-      return "fewer than 3 active messages";
-    case "no-eligible-prefix":
-      return "no older prefix is available";
-    case "unsafe-tool-boundary":
-      return "no complete tool-call boundary is available";
-    case "retention-target-exceeded":
-      return "a complete tool pair exceeds the tail target";
-    case "mode-target-not-met":
-      return "the estimated result misses this preset's target";
-    case "insufficient-projected-saving":
-      return "estimated saving is below 10%";
-  }
+  return reason === "not-enough-messages" ? "fewer than 3 active messages" : compactionPlanReasonText(reason);
 }
 function recommendationEvidence(preflight) {
   const yieldPercent = Math.round((preflight.plan?.projectedYield ?? 0) * 100);
@@ -5438,7 +5533,7 @@ function recommendPreflight(plans) {
   if (balanced?.plan?.viable) {
     return { mode: "balanced", reason: "normal pressure favors the default balance; " + recommendationEvidence(balanced) };
   }
-  const fallback = ["thorough", "fast"].find((mode) => plans.get(mode)?.plan?.viable);
+  const fallback = ["fast", "thorough"].find((mode) => plans.get(mode)?.plan?.viable);
   if (fallback) {
     const chosen = plans.get(fallback);
     return {
@@ -5451,12 +5546,15 @@ function recommendPreflight(plans) {
 function tokenCount(value) {
   return Math.round(value).toLocaleString() + "t";
 }
+function compactTokenCount(value) {
+  if (Math.abs(value) < 1000)
+    return Math.round(value) + "t";
+  const scaled = value / 1000;
+  return scaled.toFixed(scaled >= 10 ? 1 : 2).replace(/\.0+$|(\.\d*[1-9])0+$/, "$1") + "K";
+}
 function percent(value) {
   return Math.round(value).toLocaleString() + "%";
 }
-function windowPercent(tokens, window) {
-  return window > 0 ? percent(tokens / window * 100) : "unknown %";
-}
 var SOFT_BOUNDARY_COPY = {
   "recent-user-turn": "older user turn",
   anchor: "latest checkpoint",
@@ -5468,26 +5566,23 @@ function formatPreflightSummary(preflight, modelLabel, details = false) {
   const plan = preflight.plan;
   if (!plan) {
     const lines2 = [
-      "Before: ~" + tokenCount(preflight.totalTokens) + " (~" + percent(preflight.contextPercent) + " of active window) \xB7 Expected after: unavailable",
-      "This preset cannot run: " + explainPreflightReason(preflight.reason) + ".",
-      "Hard safeguards: complete tool-call/result pairs and zero-gap verification before apply."
+      "Plan unavailable \xB7 " + explainPreflightReason(preflight.reason),
+      "\u2713 Complete tool pairs \xB7 \u2713 zero-gap verification before apply"
     ];
     if (details)
-      lines2.push("Estimator: messages ~" + tokenCount(preflight.rawEstimatedMessageTokens) + " \xB7 fixed/scaled normalization unavailable", "Summary route: " + modelLabel + " \xB7 viability: " + preflight.reason);
+      lines2.push("Estimator  messages ~" + tokenCount(preflight.rawEstimatedMessageTokens) + " \xB7 normalization unavailable", "Route  " + modelLabel + " \xB7 viability " + preflight.reason);
     return lines2;
   }
-  const soft = plan.relaxedSoftBoundaries.length ? "Soft boundaries included in summary: " + plan.relaxedSoftBoundaries.map((kind) => SOFT_BOUNDARY_COPY[kind] ?? kind).join(", ") : "Soft boundaries kept when they fit: older user turn, latest checkpoint, adjacent topic";
+  const stateReserve = Math.ceil(plan.summaryBudgetTokens * POST_SUMMARY_RESERVE_RATIO);
   const lines = [
-    "Before ~" + tokenCount(preflight.totalTokens) + " (~" + percent(preflight.contextPercent) + " window) \u2192 expected after ~" + tokenCount(plan.projectedAfterTokens) + " (~" + windowPercent(plan.projectedAfterTokens, preflight.contextWindowTokens) + " window)",
-    "Projected net saving ~" + tokenCount(plan.projectedSavedTokens) + " (~" + percent(plan.projectedYield * 100) + ", estimator-based)",
-    "Recent raw tail ~" + tokenCount(plan.retainedTokens) + " + summary budget \u2264" + tokenCount(plan.summaryBudgetTokens),
-    soft,
-    "Hard safeguards: complete tool-call/result pairs and zero-gap verification before apply; " + (plan.hardBoundaryAdjusted ? "boundary adjusted to keep a pair intact" : "no hard-boundary adjustment needed")
+    "Plan  " + compactTokenCount(preflight.totalTokens) + " \u2192 ~" + compactTokenCount(plan.projectedAfterTokens) + " \xB7 ~" + compactTokenCount(plan.projectedSavedTokens) + " saved (" + percent(plan.projectedYield * 100) + ")",
+    "Keep  ~" + compactTokenCount(plan.retainedTokens) + " recent \xB7 summary up to " + compactTokenCount(plan.summaryBudgetTokens) + " + ~" + compactTokenCount(stateReserve) + " verified-state reserve",
+    "\u2713 Complete tool pairs \xB7 \u2713 zero-gap verification before apply"
   ];
   if (!plan.viable)
-    lines.push("Cannot run this preset: " + explainPreflightReason(plan.reason) + ". Choose a viable preset.");
+    lines.unshift("Unavailable \xB7 " + explainPreflightReason(plan.reason));
   if (details)
-    lines.push("Estimator: messages ~" + tokenCount(preflight.rawEstimatedMessageTokens) + " \xB7 normalized \xD7" + preflight.estimatorScale.toFixed(2) + " \xB7 fixed ~" + tokenCount(plan.fixedContextTokens), "Target \u2264" + tokenCount(plan.targetAfterTokens) + " \xB7 tail target \u2264" + tokenCount(plan.retentionTargetTokens), "Hard-boundary adjustment: " + (plan.hardBoundaryAdjusted ? "yes" : "no") + " \xB7 viability: " + plan.reason, "Internal soft boundaries: " + (plan.relaxedSoftBoundaries.join(", ") || "none"), "Summary route: " + modelLabel + (preflight.adapted ? " \xB7 damage feedback " + preflight.damageMedian + "/100 applied" : ""));
+    lines.push("Target  \u2264" + tokenCount(plan.targetAfterTokens) + " \xB7 tail \u2264" + tokenCount(plan.retentionTargetTokens) + " \xB7 fixed ~" + tokenCount(plan.fixedContextTokens), "Estimator  ~" + tokenCount(preflight.rawEstimatedMessageTokens) + " messages \xB7 normalized \xD7" + preflight.estimatorScale.toFixed(2), "Boundary  " + (plan.hardBoundaryAdjusted ? "tool pair kept intact" : "no hard adjustment") + " \xB7 soft summarized: " + (plan.relaxedSoftBoundaries.map((kind) => SOFT_BOUNDARY_COPY[kind] ?? kind).join(", ") || "none"), "Route  " + modelLabel + (preflight.adapted ? " \xB7 damage feedback " + preflight.damageMedian + "/100" : ""));
   return lines;
 }
 var PROGRESS_KEY = "smart-compact-progress";
@@ -5496,12 +5591,25 @@ function showProgressOverlay(ctx, state) {
   if (ctx.hasUI === false)
     return;
   const name = PROGRESS_PHASES[state.phase - 1] ?? state.phaseName;
-  const story = PROGRESS_PHASES.map((phase, index) => index === 1 && state.phase > 2 && !state.explorationRounds ? "\u2013 Explore" : index < state.phase - 1 ? "\u2713 " + phase : index === state.phase - 1 ? "\u25CF " + phase : "\u25CB " + phase).join("  ");
-  const detail = state.detail ? name + " \xB7 " + state.detail : name;
   try {
-    ctx.ui.setStatus?.(PROGRESS_KEY, "Smart Compact \xB7 " + detail);
+    ctx.ui.setStatus?.(PROGRESS_KEY, "Smart Compact " + state.phase + "/5 \xB7 " + name);
     ctx.ui.setWidget?.(PROGRESS_KEY, (_tui, theme) => ({
-      render: (width) => [truncateToWidth(theme.fg("dim", story), width)],
+      render: (width) => {
+        const story = PROGRESS_PHASES.map((phase, index) => {
+          if (index === 1 && state.phase > 2 && !state.explorationRounds)
+            return theme.fg("dim", "\u2013 Explore");
+          if (index < state.phase - 1)
+            return theme.fg("success", "\u2713 " + phase);
+          if (index === state.phase - 1)
+            return theme.fg("accent", theme.bold("\u25CF " + phase));
+          return theme.fg("dim", "\u25CB " + phase);
+        }).join(theme.fg("dim", "  "));
+        const safety = state.phase < 5 ? " \xB7 conversation unchanged" : "";
+        return [
+          truncateToWidth(story, width),
+          truncateToWidth(theme.fg("muted", "\u21B3 " + state.detail + safety), width)
+        ];
+      },
       invalidate: () => {}
     }), { placement: "belowEditor" });
   } catch {}
@@ -5517,8 +5625,11 @@ function notifyAppliedCompaction(ctx, details, concise) {
   const after = details.estimatedAfterTokens ?? Math.max(0, before - details.tokensSaved);
   const saving = Math.round((details.estimatedYield ?? (before ? details.tokensSaved / before : 0)) * 100);
   const quality = details.qualityScore ?? 0;
+  const initial = details.provenance?.initialScore ?? quality;
+  const repaired = details.provenance && (details.provenance.deterministicPatched.length > 0 || details.provenance.llmPatched || details.provenance.qualityFloorUsed);
+  const verification = "verified " + quality + "/100 coverage" + (repaired ? " (source " + initial + "/100" + (details.provenance?.qualityFloorUsed ? ", safety fallback" : "") + ")" : "") + " \xB7 0 gaps";
   const planned = details.plannedAfterTokens ?? after;
-  ctx.ui.notify(concise ? "Smart compact applied \u2713 \xB7 " + before.toLocaleString() + "t \u2192 ~" + after.toLocaleString() + "t estimate (plan ~" + planned.toLocaleString() + "t) \xB7 " + saving + "% saved \xB7 quality " + quality + " \xB7 0 gaps" : "Smart compact applied \u2713 \u2014 " + before.toLocaleString() + "t \u2192 planned ~" + planned.toLocaleString() + "t / ~" + after.toLocaleString() + "t applied estimate \xB7 saved " + saving + "% \xB7 quality " + quality + "/100 \xB7 0 gaps", "info");
+  ctx.ui.notify(concise ? "Smart compact applied \u2713 \xB7 " + before.toLocaleString() + "t \u2192 ~" + after.toLocaleString() + "t estimate (plan ~" + planned.toLocaleString() + "t) \xB7 " + saving + "% saved \xB7 " + verification : "Smart compact applied \u2713 \u2014 " + before.toLocaleString() + "t \u2192 planned ~" + planned.toLocaleString() + "t / ~" + after.toLocaleString() + "t applied estimate \xB7 saved " + saving + "% \xB7 " + verification, "info");
 }
 async function showResultScreen(ctx, details, extraction, services, opts = {}) {
   await ctx.ui.custom((tui, theme, _kb, done) => {
@@ -5540,10 +5651,13 @@ async function showResultScreen(ctx, details, extraction, services, opts = {}) {
       c.addChild(new Text(theme.fg("dim", "  Routes: Explore " + details.providerRoutes.explore + " \u2022 Synthesize " + details.providerRoutes.synthesize + " \u2022 Verify " + details.providerRoutes.verify), 0, 0));
     }
     const scoreColor = details.qualityScore >= 80 ? "success" : details.qualityScore >= 50 ? "warning" : "error";
-    c.addChild(new Text(theme.fg("text", "  Quality: ") + theme.fg(scoreColor, details.qualityScore + "/100"), 0, 0));
+    c.addChild(new Text(theme.fg("text", "  Verification coverage: ") + theme.fg(scoreColor, details.qualityScore + "/100"), 0, 0));
     if (details.provenance) {
       const provenance = details.provenance;
-      c.addChild(new Text(theme.fg("dim", "  Provenance: score " + provenance.initialScore + " \u2192 deterministic " + provenance.deterministicPatched.length + (provenance.llmPatched ? " \u2192 LLM patch" : "") + " \u2192 " + provenance.finalScore + " (" + provenance.remainingGaps.length + " remaining)"), 0, 0));
+      c.addChild(new Text(theme.fg("dim", "  Provenance: source " + provenance.initialScore + " \u2192 deterministic " + provenance.deterministicPatched.length + (provenance.llmPatched ? " \u2192 LLM patch" : "") + " \u2192 verified " + provenance.finalScore + " (" + provenance.remainingGaps.length + " remaining)"), 0, 0));
+      if (provenance.qualityFloorUsed) {
+        c.addChild(new Text(theme.fg("warning", "  Safety fallback used \xB7 verified coverage is not raw synthesis quality"), 0, 0));
+      }
     }
     if ((details.redactions ?? 0) > 0) {
       c.addChild(new Text(theme.fg("warning", "  Security: " + details.redactions + " sensitive value(s) redacted"), 0, 0));
@@ -5639,7 +5753,7 @@ async function showResultScreen(ctx, details, extraction, services, opts = {}) {
   }, { overlay: true, overlayOptions: { width: "70%", anchor: "center", maxHeight: "80%" } });
   if (!opts.approval)
     return "closed";
-  const approved = await ctx.ui.confirm("Apply Smart Compact?", "Quality " + details.qualityScore + "/100 \xB7 " + details.gaps.length + " remaining gap(s) \xB7 " + details.tokensSaved.toLocaleString() + ` estimated tokens saved.
+  const approved = await ctx.ui.confirm("Apply Smart Compact?", "Verification coverage " + details.qualityScore + "/100 \xB7 source " + (details.provenance?.initialScore ?? details.qualityScore) + "/100 \xB7 " + details.gaps.length + " remaining gap(s) \xB7 " + details.tokensSaved.toLocaleString() + ` estimated tokens saved.
 
 Cancel keeps the current conversation unchanged.`);
   return approved ? "apply" : "cancel";
@@ -5779,33 +5893,65 @@ async function showCompactUI(ctx, opts) {
   const calibration = createProductionServices().tokenCalibration;
   const damageMedian = preflightDamageMedian(ctx.cwd, opts.config);
   while (true) {
-    const plans = new Map(PRIMARY_MODES.map((mode) => [mode, planManualPreflight(ctx, selectedModel.model, mode, calibration, opts.config, damageMedian)]));
+    const shared = prepareManualPreflightContext(ctx, selectedModel.model, calibration);
+    const plans = new Map(PRIMARY_MODES.map((mode) => [
+      mode,
+      planManualPreflight(ctx, selectedModel.model, mode, calibration, opts.config, damageMedian, shared)
+    ]));
     const recommended = recommendPreflight(plans);
     const action = await ctx.ui.custom((tui, theme, keybindings, done) => {
       let selected = Math.max(0, PRIMARY_MODES.indexOf(recommended.mode));
       let details = false;
       return {
         render: (width) => {
-          const out = (text, color = "text") => truncateToWidth(theme.fg(color, text), Math.max(0, width));
-          const wrapped = (text, color = "text") => wrapTextWithAnsi(theme.fg(color, text), Math.max(1, width));
+          const inner = Math.max(1, width - 2);
+          const border = (text) => theme.fg("borderMuted", text);
+          const fit = (text, max = inner) => truncateToWidth(text, Math.max(0, max), "");
+          const fill = (text) => {
+            const clipped = fit(text);
+            return clipped + " ".repeat(Math.max(0, inner - visibleWidth(clipped)));
+          };
+          const cell = (text = "") => border("\u2502") + fill(text) + border("\u2502");
+          const divider = border("\u251C" + "\u2500".repeat(inner) + "\u2524");
+          const title = fit(" Smart Compact ", Math.max(0, inner - 1));
+          const top = border("\u256D\u2500") + theme.fg("accent", theme.bold(title)) + border("\u2500".repeat(Math.max(0, inner - 1 - visibleWidth(title))) + "\u256E");
+          const bottom = border("\u2570" + "\u2500".repeat(inner) + "\u256F");
+          const selectedMode = PRIMARY_MODES[selected];
+          const current = plans.get(selectedMode);
+          const contextWindow = current.contextWindowTokens;
+          const contextPct = Math.round(current.contextPercent);
+          const barLength = width >= 72 ? 14 : 8;
+          const barFilled = Math.min(barLength, Math.round(Math.min(100, contextPct) / 100 * barLength));
+          const contextBar = theme.fg(contextPct >= 90 ? "error" : contextPct >= 70 ? "warning" : "success", "\u2588".repeat(barFilled)) + theme.fg("dim", "\u2591".repeat(barLength - barFilled));
+          const modelPrefix = "  Summary model  ";
+          const modelAction = theme.fg("accent", "  [M] Change");
+          const modelWidth = Math.max(1, inner - visibleWidth(modelPrefix) - visibleWidth(modelAction));
           const lines = [
-            out("Smart Compact preflight", "accent"),
-            ...wrapped("Recommended: " + MODE_LABELS[recommended.mode] + " \u2014 " + recommended.reason, "text"),
-            out("Active context: " + opts.activeModelLabel + " \xB7 " + tokenCount(plans.get(recommended.mode)?.contextWindowTokens ?? 0) + " window", "dim"),
-            out("Summary model: " + selectedModel.label, "dim"),
-            out("\u2500".repeat(Math.max(0, width)), "borderMuted")
+            top,
+            cell("  Context  " + compactTokenCount(opts.contextTokens) + " / " + compactTokenCount(contextWindow) + "  " + contextBar + "  " + contextPct + "%"),
+            cell(theme.fg("dim", modelPrefix) + fit(selectedModel.label, modelWidth) + modelAction),
+            divider
           ];
           for (let index = 0;index < PRIMARY_MODES.length; index++) {
             const mode = PRIMARY_MODES[index];
             const preview = plans.get(mode);
-            const viable = preview.plan?.viable ?? false;
-            lines.push(out((index === selected ? "> " : "  ") + MODE_LABELS[mode] + (mode === recommended.mode ? " [recommended]" : "") + (viable ? " [viable]" : " [unavailable: " + explainPreflightReason(preview.reason) + "]"), index === selected ? "accent" : viable ? "text" : "muted"));
-            lines.push(out("    " + MODE_COPY[mode], "dim"));
+            const plan = preview.plan;
+            const viable = plan?.viable ?? false;
+            const marker = index === selected ? "\u203A " : "  ";
+            const recommendedMark = mode === recommended.mode ? "  recommended" : "             ";
+            const trait = mode === "fast" ? "quickest" : mode === "balanced" ? "default" : "deepest";
+            const stats2 = (viable && plan ? "~" + compactTokenCount(plan.projectedAfterTokens) + " after \xB7 " + percent(plan.projectedYield * 100) + " saved" : "unavailable \xB7 " + explainPreflightReason(preview.reason)) + " \xB7 " + trait;
+            const line = " " + marker + MODE_LABELS[mode].padEnd(9) + recommendedMark + "  " + stats2;
+            lines.push(cell(index === selected ? theme.fg("accent", theme.bold(line)) : theme.fg(viable ? mode === recommended.mode ? "success" : "text" : "muted", line)));
           }
-          lines.push(out("\u2500".repeat(Math.max(0, width)), "borderMuted"));
-          const current = plans.get(PRIMARY_MODES[selected]);
-          lines.push(...formatPreflightSummary(current, selectedModel.value, details).flatMap((line) => wrapped(line, line.startsWith("Cannot") || line.startsWith("This preset") ? "warning" : "text")));
-          lines.push("", out("\u2191\u2193 mode \xB7 Enter compact \xB7 D details \xB7 M model \xB7 Esc cancel", "dim"));
+          lines.push(divider);
+          for (const line of formatPreflightSummary(current, selectedModel.value, details)) {
+            const color = line.startsWith("Unavailable") || line.startsWith("Plan unavailable") ? "warning" : line.startsWith("\u2713") ? "success" : "text";
+            lines.push(cell("  " + theme.fg(color, line)));
+          }
+          if (details)
+            lines.push(cell("  " + theme.fg("dim", MODE_LABELS[selectedMode] + " \xB7 " + MODE_COPY[selectedMode])));
+          lines.push(divider, cell(theme.fg("dim", "  \u2191\u2193 choose \xB7 Enter run \xB7 D details \xB7 M model \xB7 Esc cancel")), bottom);
           return lines;
         },
         invalidate: () => {},
@@ -5815,9 +5961,9 @@ async function showCompactUI(ctx, opts) {
             return;
           }
           if (keybindings.matches(data, "tui.select.up"))
-            selected = Math.max(0, selected - 1);
+            selected = (selected + PRIMARY_MODES.length - 1) % PRIMARY_MODES.length;
           else if (keybindings.matches(data, "tui.select.down"))
-            selected = Math.min(PRIMARY_MODES.length - 1, selected + 1);
+            selected = (selected + 1) % PRIMARY_MODES.length;
           else if (keybindings.matches(data, "tui.select.confirm")) {
             const mode = PRIMARY_MODES[selected];
             if (plans.get(mode)?.plan?.viable) {
@@ -5833,7 +5979,7 @@ async function showCompactUI(ctx, opts) {
           tui.requestRender();
         }
       };
-    }, { overlay: true, overlayOptions: { width: "70%", minWidth: 36, anchor: "center", maxHeight: "85%" } });
+    }, { overlay: true, overlayOptions: { width: "68%", minWidth: 52, anchor: "center", maxHeight: "85%" } });
     if (!action)
       return null;
     if (action === "model") {
@@ -6058,29 +6204,6 @@ function asSerializableMessages(msgs) {
 import * as fs6 from "fs";
 import * as path9 from "path";
 import { StringDecoder } from "string_decoder";
-
-// src/utils/lru.ts
-function lruGet(m, key) {
-  if (!m.has(key))
-    return;
-  const v = m.get(key);
-  m.delete(key);
-  m.set(key, v);
-  return v;
-}
-function lruSet(m, key, value, max) {
-  if (m.has(key))
-    m.delete(key);
-  m.set(key, value);
-  while (m.size > max) {
-    const oldest = m.keys().next().value;
-    if (oldest === undefined)
-      break;
-    m.delete(oldest);
-  }
-}
-
-// src/utils/session-log.ts
 function getSessionsDir() {
   return sessionsDir();
 }
@@ -6412,7 +6535,7 @@ function pruneRedundant(msgs, precomputedTcIdx) {
         if (block.name === "multi_tool_use.parallel" && Array.isArray(block.arguments?.tool_uses)) {
           const tools = block.arguments.tool_uses;
           const retained = tools.filter((tool, toolIndex) => {
-            const id = typeof tool.id === "string" ? tool.id : block.id ? block.id + "_" + toolIndex : "mtu_" + idx + "_" + toolIndex;
+            const id = nestedToolCallId(block.id, idx, toolIndex, tool.id);
             return !removedToolCallIds.has(id);
           });
           if (retained.length !== tools.length)
@@ -6467,7 +6590,8 @@ import { serializeConversation } from "@earendil-works/pi-coding-agent";
 function extractWithCache(rc) {
   const extractStepStart = Date.now();
   const currentEntryIds = rc.toCompact.map((e) => e.id);
-  const pruning = pruneRedundant(rc.llmMessages);
+  const selectedMessages = rc.llmMessages;
+  const pruning = pruneRedundant(selectedMessages);
   const currentKeptEntryIds = pruning.keptIndices.map((i) => currentEntryIds[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");
@@ -6478,7 +6602,12 @@ function extractWithCache(rc) {
   const extractionStart = pruneEnd;
   const convText = serializeConversation(asSerializableMessages(rc.llmMessages));
   const convTokens = rc.estimator.text(convText);
-  const backupPath = backupConversation(rc.services.scrubber.scrubText(convText).value, rc.sessionId);
+  let backupPath = null;
+  if (rc.config.backupEnabled) {
+    const unchanged = pruning.messages.length === selectedMessages.length && pruning.messages.every((message, index) => message === selectedMessages[index]);
+    const backupText = unchanged ? convText : serializeConversation(asSerializableMessages(selectedMessages));
+    backupPath = backupConversation(rc.services.scrubber.scrubText(backupText).value, rc.sessionId);
+  }
   const prevContext = getPreviousCompactionContext(rc.branch);
   const cachedExt = loadCachedExtraction(rc.sessionId);
   let extraction;
@@ -6528,18 +6657,18 @@ function extractWithCache(rc) {
   }
   const projectCtx = buildProjectContext(fingerprint);
   const manager = rc.ctx.sessionManager;
-  const fullBranch = manager?.getBranch ? Array.from(manager.getBranch()) : rc.branch;
-  const branchEntryIds = fullBranch.map((entry) => entry.id).filter((id) => typeof id === "string");
+  const fullBranch = manager?.getBranch ? manager.getBranch() : rc.branch;
+  const ancestryIds = branchEntryIds(fullBranch);
   const continuityScope = {
     schemaVersion: 2,
     projectId,
     sessionId: rc.sessionId,
-    ...branchEntryIds.length ? {
-      branchHeadId: branchEntryIds[branchEntryIds.length - 1],
-      branchAncestryIds: branchEntryIds.slice(-256)
+    ...ancestryIds.length ? {
+      branchHeadId: ancestryIds[ancestryIds.length - 1],
+      branchAncestryIds: ancestryIds
     } : {}
   };
-  const previousState = loadScopedCompactionState(continuityScope, branchEntryIds);
+  const previousState = loadScopedCompactionState(continuityScope, ancestryIds);
   const continuity = previousState ? renderContinuityCapsule(previousState) : "";
   const out = rc;
   out.pruning = pruning;
@@ -6855,7 +6984,7 @@ async function exploreConversation(llmMessages, extraction, model, auth, prevSum
             tools: EXPLORATION_TOOLS
           }, { apiKey: auth.apiKey, headers: auth.headers, signal, maxTokens: Math.min(4096, model.maxTokens || 4096) }, svc);
         } catch (err) {
-          warn("Explore loop error", err);
+          debugError("Explore loop stopped", err);
           break;
         }
         const nextToolCalls = response.content.filter((c) => c.type === "toolCall");
@@ -6976,6 +7105,7 @@ Output ONLY JSON: {"mainGoal":"...","sessionType":"implementation|review|debuggi
     return fallbackExplorationReport(llmMessages);
   }
 }
+
 // src/infra/synthesis-cache.ts
 import { createHash as createHash2 } from "crypto";
 var cache = new Map;
@@ -7004,7 +7134,7 @@ function synthesisCacheKey(rc) {
       codexCallMs: rc.config.codexMaxCallMs,
       latencyMs: rc.config.maxLatencyMs
     },
-    focus: rc.config.focusWeighting ? rc.focus : undefined,
+    focus: rc.focus?.trim() || undefined,
     zeroCall: rc.config.zeroCallEnabled !== false,
     note: rc.userNote
   });
@@ -7422,17 +7552,10 @@ async function summarizeConversation(rc) {
   if (rc.requestedMode === "auto") {
     const refined = resolveMode("auto", rc.contextPercent, extraction, continuityRisk(rc.previousState) + (rc.adapted ? 12 : 0));
     if (refined !== rc.mode) {
-      const oldBase = { ...PROFILES[rc.profile], ...rc.config.profiles?.[rc.profile] ?? {} };
-      const keepScale = rc.profileCfg.keepRecentTokens / oldBase.keepRecentTokens;
-      const summaryScale = rc.profileCfg.summaryBudgetTokens / oldBase.summaryBudgetTokens;
       rc.mode = refined;
-      rc.profile = MODE_POLICIES[refined].profile;
-      rc.profileCfg = { ...PROFILES[rc.profile], ...rc.config.profiles?.[rc.profile] ?? {} };
-      rc.profileCfg.keepRecentTokens = Math.round(rc.profileCfg.keepRecentTokens * keepScale);
-      rc.profileCfg.summaryBudgetTokens = Math.round(rc.profileCfg.summaryBudgetTokens * summaryScale);
       const policy2 = MODE_POLICIES[refined];
       rc.services.budget.setLimits(rc.maxLlmCalls ?? effectiveBudget(rc.config.maxLlmCalls, policy2.maxLlmCalls), rc.maxLlmInputTokens ?? effectiveBudget(rc.config.maxLlmInputTokens, policy2.maxInputTokens), policy2.maxOutputTokens);
-      rc.notify("Auto mode selected " + refined + " from deterministic session risk", "info");
+      rc.notify("Auto strategy refined to " + refined + " within the planned " + rc.profile + " window", "info");
     }
   }
   const pc = rc.profileCfg;
@@ -7441,7 +7564,13 @@ async function summarizeConversation(rc) {
   const cached = getCachedSynthesis(cacheKey);
   if (cached) {
     rc.notify("Synthesis cache hit \u2014 no LLM calls", "info");
-    const hit = rc;
+    if (!rc.flags.autoTriggered)
+      showProgressOverlay(rc.ctx, {
+        phase: 3,
+        phaseName: "Synthesize",
+        detail: "Reusing the cached continuation summary \xB7 no LLM call"
+      });
+    const hit = advance(rc, "_synthesized");
     hit.finalSummary = cached.finalSummary;
     hit.method = cached.method;
     hit.methodForMetrics = cached.method + "-cache";
@@ -7451,13 +7580,19 @@ async function summarizeConversation(rc) {
     hit.explorationRounds = cached.explorationRounds;
     hit.chunkCount = cached.chunkCount;
     markMeasuredPhase(hit, "synthesize", synthPhaseStart);
-    return advance(hit, "_synthesized");
+    return hit;
   }
-  const zeroCall = rc.config.zeroCallEnabled !== false && (rc.mode === "fast" || rc.mode === "aggressive") && !rc.focus && !rc.userNote && deterministicExtractionConfidence(extraction, {
+  const zeroCall = rc.config.zeroCallEnabled !== false && rc.mode === "fast" && !rc.focus && !rc.userNote && deterministicExtractionConfidence(extraction, {
     conversationTokens: rc.convTokens,
     toolPercent: rc.toolPercent
   }) >= 0.85;
   if (zeroCall) {
+    if (!rc.flags.autoTriggered)
+      showProgressOverlay(rc.ctx, {
+        phase: 3,
+        phaseName: "Synthesize",
+        detail: "Building a deterministic continuation summary \xB7 no LLM call"
+      });
     const finalSummary2 = assembleFallback([], extraction);
     setCachedSynthesis(cacheKey, {
       finalSummary: finalSummary2,
@@ -7468,7 +7603,7 @@ async function summarizeConversation(rc) {
       chunkCount: 0
     });
     rc.notify("Zero-call deterministic compaction (high-confidence extraction)", "info");
-    const deterministic = rc;
+    const deterministic = advance(rc, "_synthesized");
     deterministic.finalSummary = finalSummary2;
     deterministic.method = "heuristic";
     deterministic.methodForMetrics = "zero-call";
@@ -7478,7 +7613,7 @@ async function summarizeConversation(rc) {
     deterministic.explorationRounds = 0;
     deterministic.chunkCount = 0;
     markMeasuredPhase(deterministic, "synthesize", synthPhaseStart);
-    return advance(deterministic, "_synthesized");
+    return deterministic;
   }
   const shouldSkipExplore = !policy.explore;
   const convText = rc.convText;
@@ -7494,9 +7629,16 @@ async function summarizeConversation(rc) {
   try {
     summaryAuth = await resolveStageAuth(rc, "summary");
   } catch (error2) {
-    rc.notify("Summary route unavailable; using deterministic fallback: " + (error2 instanceof Error ? error2.message : String(error2)), "warning");
+    debugError("Summary route unavailable", error2);
+    rc.notify("Summary route unavailable \xB7 using deterministic fallback", "info");
   }
   if (!summaryAuth) {
+    if (!rc.flags.autoTriggered)
+      showProgressOverlay(rc.ctx, {
+        phase: 3,
+        phaseName: "Synthesize",
+        detail: "Summary route unavailable \xB7 building a deterministic summary"
+      });
     finalSummary = assembleFallback([], extraction);
     method = "heuristic";
   } else if (rc.convTokens < singlePassMaxTokens) {
@@ -7504,7 +7646,7 @@ async function summarizeConversation(rc) {
       showProgressOverlay(rc.ctx, {
         phase: 3,
         phaseName: "Synthesize",
-        detail: "Single-pass (" + rc.convTokens.toLocaleString() + "t)",
+        detail: "Writing one continuation summary from " + rc.convTokens.toLocaleString() + " tokens",
         model: rc.modelLabel,
         profile: rc.profile,
         extraction
@@ -7515,7 +7657,8 @@ async function summarizeConversation(rc) {
       finalSummary = r.summary;
       method = "single-pass";
     } catch (err) {
-      rc.notify("Single-pass failed: " + (err instanceof Error ? err.message : String(err)), "warning");
+      debugError("Single-pass synthesis used deterministic fallback", err);
+      rc.notify("Single-pass generation stopped \xB7 using deterministic fallback", "info");
       finalSummary = assembleFallback([], extraction);
       method = "heuristic";
     }
@@ -7527,7 +7670,7 @@ async function summarizeConversation(rc) {
         showProgressOverlay(rc.ctx, {
           phase: 2,
           phaseName: "Explore",
-          detail: "Exploring...",
+          detail: "Mapping topic shifts and continuity risks",
           model: rc.modelLabel,
           profile: rc.profile,
           extraction
@@ -7542,7 +7685,8 @@ async function summarizeConversation(rc) {
         rc.notify("Phase 2 Explore: " + expResult.rounds + " rounds, " + explorationReport.boundaries.length + " boundaries" + (expResult.toolSupported ? "" : " (no tool support)"), "info");
         rc.vlog("Explore boundaries: " + explorationReport.boundaries.map((b) => b.afterIndex + "(" + b.confidence.toFixed(2) + ")").join(", "));
       } catch (err) {
-        rc.notify("Phase 2 Explore: failed - " + (err instanceof Error ? err.message : String(err)), "warning");
+        debugError("Explore used deterministic topic boundaries", err);
+        rc.notify("Explore unavailable \xB7 using deterministic topic boundaries", "info");
       } finally {
         const exploreEnd = Date.now();
         markMeasuredPhase(rc, "explore", exploreStart, exploreEnd);
@@ -7589,7 +7733,7 @@ async function summarizeConversation(rc) {
       showProgressOverlay(rc.ctx, {
         phase: 3,
         phaseName: "Synthesize",
-        detail: "0/" + totalBatches + " batches",
+        detail: "Compressing older history \xB7 batch 0/" + totalBatches,
         model: rc.modelLabel,
         profile: rc.profile,
         extraction,
@@ -7629,7 +7773,7 @@ async function summarizeConversation(rc) {
           for (let index = wave;index < totalBatches; index++) {
             results[index] = batches[index].map((chunk) => failedChunkSummary(chunk));
           }
-          rc.notify("Synthesis budget exhausted \u2014 remaining batches use deterministic fallback", "warning");
+          rc.notify("Synthesis budget reached \xB7 remaining batches use deterministic fallback", "info");
           break;
         }
         const waveBatches = batches.slice(wave, Math.min(wave + concurrency, batchCallLimit));
@@ -7646,7 +7790,7 @@ async function summarizeConversation(rc) {
             showProgressOverlay(rc.ctx, {
               phase: 3,
               phaseName: "Synthesize",
-              detail: completed + "/" + totalBatches + " batches",
+              detail: "Compressing older history \xB7 batch " + completed + "/" + totalBatches,
               model: rc.modelLabel,
               profile: rc.profile,
               extraction,
@@ -7661,15 +7805,25 @@ async function summarizeConversation(rc) {
       for (const r of results)
         if (r)
           summaries.push(...r);
-      for (let i = 0;i < errors.length; i++)
-        if (errors[i])
-          rc.notify("Batch " + (i + 1) + " failed: " + errors[i].message, "warning");
+      const failedBatches = errors.filter(Boolean);
+      for (const error2 of failedBatches)
+        debugError("Synthesis batch used deterministic fallback", error2);
+      if (failedBatches.length) {
+        rc.notify(failedBatches.length + " synthesis batch(es) stopped \xB7 deterministic evidence fallback preserved coverage", "info");
+        if (!rc.flags.autoTriggered)
+          showProgressOverlay(rc.ctx, {
+            phase: 3,
+            phaseName: "Synthesize",
+            detail: failedBatches.length + " batch fallback(s) \xB7 preserving coverage from deterministic evidence",
+            explorationRounds
+          });
+      }
     }
     if (!rc.flags.autoTriggered) {
       showProgressOverlay(rc.ctx, {
         phase: 3,
         phaseName: "Synthesize",
-        detail: "Assembling...",
+        detail: "Merging summaries with project continuity",
         model: rc.modelLabel,
         profile: rc.profile,
         extraction,
@@ -7684,12 +7838,12 @@ async function summarizeConversation(rc) {
       else
         throw new Error("bad");
     } catch (err) {
-      warn("Assembly failed", err);
+      debugError("Assembly used deterministic fallback", err);
       finalSummary = assembleFallback(summaries, extraction);
     }
     method = "eesv";
   }
-  const out = rc;
+  const out = advance(rc, "_synthesized");
   out.finalSummary = finalSummary;
   out.method = method;
   out.methodForMetrics = method;
@@ -7707,7 +7861,7 @@ async function summarizeConversation(rc) {
     chunkCount
   });
   markMeasuredPhase(out, "synthesize", synthPhaseStart);
-  return advance(out, "_synthesized");
+  return out;
 }
 
 // src/phases/verify.ts
@@ -7781,6 +7935,17 @@ var CONDITION_MARKERS = new Set([
   "gerekli",
   "gerektirir"
 ]);
+var POLARITY_INVERTING_GUARDS = new Set([
+  "skip",
+  "skipp",
+  "forget",
+  "forgett",
+  "omit",
+  "omitt",
+  "neglect",
+  "fail",
+  "avoid"
+]);
 var SEMANTIC_STOP = new Set([
   "the",
   "and",
@@ -7830,6 +7995,24 @@ function evidenceFragments(text) {
 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 hasEffectiveTargetNegation(tokens, anchor) {
+  return tokens.some((token, anchorIndex) => {
+    if (token !== anchor)
+      return false;
+    const nearbyStart = Math.max(0, anchorIndex - 2);
+    const nearbyNegations = tokens.slice(nearbyStart, anchorIndex + 3).map((near, offset) => NEGATION_MARKERS.has(near) ? nearbyStart + offset : -1).filter((index) => index >= 0);
+    const governingStart = Math.max(0, anchorIndex - 3);
+    const preceding = tokens.slice(governingStart, anchorIndex);
+    const nearbyGuards = preceding.map((near, offset) => POLARITY_INVERTING_GUARDS.has(near) ? governingStart + offset : -1).filter((index) => index >= 0);
+    const governingIndex = preceding.findIndex((near, offset) => NEGATION_MARKERS.has(near) && POLARITY_INVERTING_GUARDS.has(preceding[offset + 1] ?? ""));
+    if (governingIndex < 0)
+      return nearbyNegations.length > 0 || nearbyGuards.length > 0;
+    const absoluteGoverningIndex = governingStart + governingIndex;
+    const guardIndex = absoluteGoverningIndex + 1;
+    const nested = tokens.slice(guardIndex + 1, anchorIndex).some((inner) => NEGATION_MARKERS.has(inner) || POLARITY_INVERTING_GUARDS.has(inner));
+    return nested || nearbyNegations.some((index) => index !== absoluteGoverningIndex && index !== guardIndex) || nearbyGuards.some((index) => index !== guardIndex);
+  });
+}
 function semanticShape(source) {
   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))));
@@ -7848,11 +8031,14 @@ function hasSemanticEvidence(source, target) {
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
     if (overlap < required)
       return false;
-    if (negative && !hasNearbyMarker(tokens, anchor, NEGATION_MARKERS)) {
+    const targetNegative = hasEffectiveTargetNegation(tokens, anchor);
+    if (negative && !targetNegative) {
       const conditionalRestatement = sourceTokens.includes("without") && tokens.some((token) => CONDITION_MARKERS.has(token)) && overlap >= Math.min(2, concepts.length);
       if (!conditionalRestatement)
         return false;
     }
+    if (!negative && targetNegative)
+      return false;
     if (conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token)))
       return false;
     return true;
@@ -7870,10 +8056,13 @@ function hasSemanticContradiction(source, target) {
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
     if (overlap < required)
       return false;
-    if (negative && !hasNearbyMarker(tokens, anchor, NEGATION_MARKERS)) {
+    const targetNegative = hasEffectiveTargetNegation(tokens, anchor);
+    if (negative && !targetNegative) {
       const validConditional = sourceTokens.includes("without") && tokens.some((token) => CONDITION_MARKERS.has(token)) && overlap >= Math.min(2, concepts.length);
       return !validConditional;
     }
+    if (!negative && targetNegative)
+      return true;
     return conditional && !negative && !tokens.some((token) => CONDITION_MARKERS.has(token));
   });
 }
@@ -7955,7 +8144,7 @@ function verifySummary(summary, extraction, continuity = null) {
     }
   }
   for (const error2 of unresolvedEvidence) {
-    const snippet = error2.message.trim().replace(/\s+/g, " ").slice(0, TRUNC.ERROR_SNIPPET).toLowerCase();
+    const snippet = summaryEvidenceLine(error2.message, TRUNC.ERROR_SNIPPET).toLowerCase();
     if (snippet.length > 5 && !normalizedSummary.includes(snippet)) {
       gaps.push({ kind: "missing-error", message: error2.message });
       score -= 5;
@@ -8182,7 +8371,7 @@ async function verifyAndPatch(rc) {
     showProgressOverlay(rc.ctx, {
       phase: 4,
       phaseName: "Verify",
-      detail: "Checking...",
+      detail: "Checking facts, files, constraints, errors, and open loops",
       model: rc.modelLabel,
       profile: rc.profile,
       extraction,
@@ -8197,7 +8386,14 @@ async function verifyAndPatch(rc) {
   rc.vlog("Verification score=" + verification.score + " ok=" + verification.ok + " gaps=" + verification.gaps.length);
   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");
+    rc.notify("Phase 4 Verify: " + initialPatchable.length + " deterministic gap(s), score=" + verification.score + ", applying repair", "info");
+    if (!rc.flags.autoTriggered)
+      showProgressOverlay(rc.ctx, {
+        phase: 4,
+        phaseName: "Verify",
+        detail: "Repairing " + initialPatchable.length + " deterministic finding(s)",
+        explorationRounds: rc.explorationRounds
+      });
     const repaired = repairSummaryDeterministically(summary, verification, extraction, rc.previousState);
     summary = repaired.summary;
     verification = repaired.result;
@@ -8205,13 +8401,20 @@ async function verifyAndPatch(rc) {
   }
   const mode = rc.mode ?? (rc.profile ? modeFromLegacyProfile(rc.profile) : "balanced");
   if (MODE_POLICIES[mode].allowLlmPatch && !verification.ok) {
-    rc.notify("Phase 4 Verify: deterministic repair insufficient (score=" + verification.score + "), requesting LLM patch", "warning");
+    rc.notify("Phase 4 Verify: deterministic repair insufficient (score=" + verification.score + "), requesting LLM patch", "info");
+    if (!rc.flags.autoTriggered)
+      showProgressOverlay(rc.ctx, {
+        phase: 4,
+        phaseName: "Verify",
+        detail: "Requesting a semantic repair for unresolved findings",
+        explorationRounds: rc.explorationRounds
+      });
     const beforePatch = summary;
     try {
       const verifyAuth = await resolveStageAuth(rc, "verify");
       summary = await patchSummary(summary, verification.gaps, rc.verifyModel ?? rc.summaryModel, verifyAuth, rc.cancellation.signal, rc.services);
     } catch (error2) {
-      warn("LLM patch failed", error2);
+      debugError("LLM verification patch used deterministic fallback", error2);
     }
     if (summary !== beforePatch) {
       llmPatched = true;
@@ -8223,6 +8426,13 @@ async function verifyAndPatch(rc) {
     }
   }
   if (!verification.ok) {
+    if (!rc.flags.autoTriggered)
+      showProgressOverlay(rc.ctx, {
+        phase: 4,
+        phaseName: "Verify",
+        detail: "Trying the deterministic safety summary",
+        explorationRounds: rc.explorationRounds
+      });
     let deterministic = assembleFallback(rc.summaries, extraction);
     let deterministicVerification = verifySummary(deterministic, extraction, rc.previousState);
     const repaired = repairSummaryDeterministically(deterministic, deterministicVerification, extraction, rc.previousState);
@@ -8233,12 +8443,19 @@ async function verifyAndPatch(rc) {
       verification = deterministicVerification;
       deterministicPatched.push(...repaired.patched);
       qualityFloorUsed = true;
-      rc.notify("Quality floor replaced unsafe or unverifiable model output", "warning");
+      rc.notify("Quality floor replaced unsafe or unverifiable model output", "info");
     }
   }
   const failure = verificationFailureMessage(verification);
   if (failure)
     throw new VerificationGateError(verification, initialScore);
+  if (!rc.flags.autoTriggered)
+    showProgressOverlay(rc.ctx, {
+      phase: 4,
+      phaseName: "Verify",
+      detail: "Passed " + verification.score + "/100 \xB7 0 unresolved gaps",
+      explorationRounds: rc.explorationRounds
+    });
   const out = rc;
   out.finalSummary = summary;
   out.verified = verification.ok;
@@ -8255,6 +8472,10 @@ async function verifyAndPatch(rc) {
   return advance(out, "_verified");
 }
 
+// src/app/steps/state.ts
+import fs7 from "fs";
+import path10 from "path";
+
 // src/domain/yield-gate.ts
 class YieldGateError extends Error {
   reason;
@@ -8335,9 +8556,14 @@ function buildState(rc) {
   const nextActions = extractNextActions(summary);
   const criticalContextItems = extractCriticalContext(summary);
   const currentState = buildCompactionState(extraction, managedLoops, rc.explorationReport, nextActions, criticalContextItems, loopOverrides);
+  const summarizedGoal = summaryEvidenceLine(findSection(summary, "goal")?.body ?? "", TRUNC.MESSAGE);
   currentState.scope = rc.continuityScope;
   currentState.factOverrides = prevState?.factOverrides ?? [];
   let compactionState = mergeCompactionStates(prevState, currentState);
+  compactionState.deletedFiles = compactionState.deletedFiles.filter((file) => {
+    const candidate = path10.isAbsolute(file) ? file : path10.resolve(rc.ctx.cwd, file);
+    return !fs7.existsSync(candidate);
+  });
   if (preserve.length > 0) {
     compactionState.readFiles = Array.from(new Set([...preserve, ...compactionState.readFiles])).slice(0, 100);
   }
@@ -8350,6 +8576,8 @@ function buildState(rc) {
       rc.notify("Delta: " + delta.newLoops.length + " new loops, " + delta.resolvedLoops.length + " resolved, " + delta.newModifiedFiles.length + " new files", "info");
     }
   }
+  if (summarizedGoal && currentState.goal)
+    compactionState.goal = summarizedGoal;
   const continuity = renderContinuityCapsule(compactionState, undefined, summary);
   if (continuity)
     summary = summary.trimEnd() + `
@@ -8423,8 +8651,8 @@ function buildState(rc) {
 
 // src/infra/context-graph.ts
 import { createHash as createHash3 } from "crypto";
-import fs7 from "fs";
-import path10 from "path";
+import fs8 from "fs";
+import path11 from "path";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var MAX_PROJECT_NODES = 2000;
@@ -8432,6 +8660,7 @@ 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;
 function nodeSqliteAdapter(db) {
   return {
     exec: (sql) => db.exec(sql),
@@ -8454,7 +8683,7 @@ function nodeSqliteAdapter(db) {
 }
 function openDatabase() {
   const fp = contextGraphFile();
-  fs7.mkdirSync(path10.dirname(fp), { recursive: true });
+  fs8.mkdirSync(path11.dirname(fp), { recursive: true });
   let db;
   if ("bun" in process.versions) {
     const { Database } = require2("bun:sqlite");
@@ -8464,7 +8693,7 @@ function openDatabase() {
     db = nodeSqliteAdapter(new DatabaseSync(fp));
   }
   try {
-    fs7.chmodSync(fp, 384);
+    fs8.chmodSync(fp, 384);
   } catch {}
   db.exec("PRAGMA busy_timeout=1000; PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;");
   db.exec(`
@@ -8484,8 +8713,6 @@ function openDatabase() {
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     );
-    CREATE UNIQUE INDEX IF NOT EXISTS context_nodes_fact
-      ON context_nodes(project_id, session_id, kind, fact_key);
     CREATE INDEX IF NOT EXISTS context_nodes_project_status
       ON context_nodes(project_id, status, updated_at DESC);
     CREATE TABLE IF NOT EXISTS context_edges (
@@ -8503,6 +8730,20 @@ function openDatabase() {
       tokenize='unicode61 remove_diacritics 2'
     );
   `);
+  const version = db.query("PRAGMA user_version").get();
+  if (Number(version?.user_version ?? 0) < CONTEXT_GRAPH_SCHEMA_VERSION) {
+    db.transaction(() => {
+      db.exec(`
+        DROP INDEX IF EXISTS context_nodes_fact;
+        DELETE FROM context_nodes_fts
+          WHERE node_id IN (SELECT id FROM context_nodes WHERE source = 'compaction');
+        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 = ${CONTEXT_GRAPH_SCHEMA_VERSION};
+      `);
+    })();
+  }
   return db;
 }
 function stableId(...parts) {
@@ -8552,7 +8793,7 @@ function makeNode(scope, kind, title, content, options = {}) {
   const key = factKey(content);
   const now = Date.now();
   return {
-    id: stableId(scope.projectId, scope.sessionId, kind, key),
+    id: stableId(scope.projectId, scope.sessionId, kind, key, scope.branchHeadId ?? ""),
     projectId: scope.projectId,
     sessionId: scope.sessionId,
     branchHeadId: scope.branchHeadId ?? null,
@@ -8579,27 +8820,55 @@ function ensureFileNode(db, scope, file, now, content = file) {
   upsertNode(db, node);
   return node;
 }
-function markFactStatus(db, scope, kind, key, status) {
+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(`
-    SELECT id FROM context_nodes
-    WHERE project_id = ? AND session_id = ? AND kind = ? AND fact_key = ? AND source = 'compaction'
-  `).all(scope.projectId, scope.sessionId, kind, key);
-  if (!rows.length)
+    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);
+}
+function latestLineageFact(db, scope, kind, key) {
+  const rank = new Map(branchLineage(scope).map((id, index) => [id, index]));
+  return lineageFactRows(db, scope, kind, key).sort((a, b) => (rank.get(b.branch_head_id ?? "") ?? -1) - (rank.get(a.branch_head_id ?? "") ?? -1) || b.updated_at - a.updated_at)[0] ?? null;
+}
+function markFactStatus(db, scope, kind, key, status) {
+  const previous = latestLineageFact(db, scope, kind, key);
+  if (!previous || previous.status === status)
     return;
-  db.query(`
-    UPDATE context_nodes SET status = ?, updated_at = ?
-    WHERE project_id = ? AND session_id = ? AND kind = ? AND fact_key = ? AND source = 'compaction'
-  `).run(status, Date.now(), scope.projectId, scope.sessionId, kind, key);
-  const remove = db.query("DELETE FROM context_nodes_fts WHERE node_id = ?");
-  for (const row of rows)
-    remove.run(row.id);
+  const now = Date.now();
+  upsertNode(db, {
+    id: stableId(scope.projectId, scope.sessionId, kind, key, scope.branchHeadId ?? ""),
+    projectId: scope.projectId,
+    sessionId: scope.sessionId,
+    branchHeadId: scope.branchHeadId ?? null,
+    kind,
+    factKey: key,
+    title: previous.title,
+    content: previous.content,
+    status,
+    source: "compaction",
+    confidence: previous.confidence,
+    relatedPaths: parsePaths(previous.related_paths),
+    createdAt: now,
+    updatedAt: now
+  }, true);
+}
+function sameActiveFact(row, node) {
+  return Boolean(row && row.status === "active" && node.status === "active" && row.title === node.title && row.content === node.content && row.confidence === node.confidence && JSON.stringify(parsePaths(row.related_paths)) === JSON.stringify(node.relatedPaths));
 }
 function addFact(db, scope, sessionNodeId, kind, title, content, relatedPaths = [], confidence = 0.85, keyText = content) {
   if (!content.trim())
     return;
   const node = makeNode(scope, kind, title, content, { relatedPaths, confidence });
   node.factKey = factKey(keyText);
-  node.id = stableId(scope.projectId, scope.sessionId, kind, node.factKey);
+  node.id = stableId(scope.projectId, scope.sessionId, kind, node.factKey, scope.branchHeadId ?? "");
+  if (sameActiveFact(latestLineageFact(db, scope, kind, node.factKey), node))
+    return;
   upsertNode(db, node);
   linkNodes(db, scope.projectId, sessionNodeId, node.id, "contains", 1, node.updatedAt);
   for (const file of relatedPaths) {
@@ -8640,7 +8909,8 @@ function indexCompactionState(projectId, state) {
   const scope = {
     projectId,
     sessionId,
-    branchHeadId: state.scope.branchHeadId
+    branchHeadId: state.scope.branchHeadId,
+    branchEntryIds: state.scope.branchAncestryIds
   };
   let db = null;
   try {
@@ -8656,17 +8926,15 @@ function indexCompactionState(projectId, state) {
       upsertNode(db, projectNode);
       upsertNode(db, sessionNode);
       linkNodes(db, projectId, projectNode.id, sessionNode.id, "contains", 1, now);
-      db.query(`
-        UPDATE context_nodes SET status = 'superseded', updated_at = ?
-        WHERE project_id = ? AND session_id = ? AND kind = 'goal' AND source = 'compaction' AND status = 'active'
-      `).run(now, projectId, sessionId);
-      db.query(`
-        DELETE FROM context_nodes_fts WHERE node_id IN (
-          SELECT id FROM context_nodes WHERE project_id = ? AND session_id = ? AND kind = 'goal' AND status <> 'active'
-        )
-      `).run(projectId, sessionId);
-      if (state.goal)
+      if (state.goal) {
+        const currentGoalKey = factKey(state.goal);
+        const priorGoalKeys = new Set(lineageFactRows(db, scope, "goal").map((row) => row.fact_key));
+        for (const key of priorGoalKeys) {
+          if (key !== currentGoalKey)
+            markFactStatus(db, scope, "goal", key, "superseded");
+        }
         addFact(db, scope, sessionNode.id, "goal", "Current goal", state.goal, [], 0.98);
+      }
       for (const item of state.decisions) {
         addFact(db, scope, sessionNode.id, "decision", "Decision", item.summary + (item.userResponse ? " \u2192 " + item.userResponse : ""), [], item.type === "explicit" ? 0.98 : 0.82, item.summary);
       }
@@ -8685,6 +8953,8 @@ function indexCompactionState(projectId, state) {
           relatedPaths: item.files,
           confidence: item.priority === "critical" || item.priority === "high" ? 0.98 : 0.88
         });
+        if (sameActiveFact(latestLineageFact(db, scope, "loop", node.factKey), node))
+          continue;
         upsertNode(db, node);
         linkNodes(db, projectId, sessionNode.id, node.id, "contains", 1, now);
         for (const file of item.files) {
@@ -8805,13 +9075,17 @@ function saveContextMemory(scope, memory) {
     node.sessionId = "*";
     node.branchHeadId = null;
     const transaction = db.transaction(() => {
-      const exists = db.query("SELECT 1 AS found FROM context_nodes WHERE id = ?").get(node.id);
+      const existing = db.query("SELECT status FROM context_nodes WHERE id = ?").get(node.id);
       const duplicates = db.query(`
-        SELECT id, related_paths FROM context_nodes
+        SELECT id, related_paths, status FROM context_nodes
         WHERE project_id = ? AND kind = ? AND fact_key = ? AND source = 'manual' AND id <> ?
       `).all(scope.projectId, memory.kind, node.factKey, node.id);
-      const count = db.query("SELECT count(*) AS count FROM context_nodes WHERE project_id = ? AND source = 'manual'").get(scope.projectId);
-      if (!exists && !duplicates.length && Number(count?.count ?? 0) >= MAX_MANUAL_NODES) {
+      const count = db.query(`
+        SELECT count(*) AS count FROM context_nodes
+        WHERE project_id = ? AND source = 'manual' AND status = 'active'
+      `).get(scope.projectId);
+      const alreadyActive = existing?.status === "active" || duplicates.some((item) => item.status === "active");
+      if (!alreadyActive && Number(count?.count ?? 0) >= MAX_MANUAL_NODES) {
         throw new Error("Project memory limit reached; resolve an existing memory before saving another");
       }
       node.relatedPaths = Array.from(new Set([
@@ -8898,6 +9172,19 @@ function parsePaths(value) {
     return [];
   }
 }
+function latestLineageVersions(db, scope) {
+  const rank = new Map(branchLineage(scope).map((id, index) => [id, index]));
+  const latest = new Map;
+  for (const row of lineageFactRows(db, scope)) {
+    const key = row.kind + ":" + row.fact_key;
+    const rowRank = rank.get(row.branch_head_id ?? "") ?? -1;
+    const previous = latest.get(key);
+    if (!previous || rowRank > previous.rank || rowRank === previous.rank && row.updated_at > previous.updatedAt) {
+      latest.set(key, { id: row.id, status: row.status, rank: rowRank, updatedAt: row.updated_at });
+    }
+  }
+  return new Map([...latest].map(([key, value]) => [key, { id: value.id, status: value.status }]));
+}
 function recallContext(scope, query, options = {}) {
   const terms = searchTerms(query.slice(0, 500));
   if (!terms.length)
@@ -8920,7 +9207,8 @@ function recallContext(scope, query, options = {}) {
         candidates.set(neighbor.row.id, { row: neighbor.row, lexical: 0, graph: neighbor.weight });
     }
     const allowedKinds = options.kinds?.length ? new Set(options.kinds) : null;
-    const branchIds = new Set(scope.branchEntryIds ?? []);
+    const branchIds = new Set(branchLineage(scope));
+    const latestVersions = latestLineageVersions(db, scope);
     const kindBoost = {
       decision: 0.1,
       constraint: 0.1,
@@ -8939,6 +9227,11 @@ function recallContext(scope, query, options = {}) {
         return [];
       if (allowedKinds && !allowedKinds.has(row.kind))
         return [];
+      if (row.source === "compaction" && sameSession && sameBranch) {
+        const latest = latestVersions.get(row.kind + ":" + row.fact_key);
+        if (latest && (latest.status !== "active" || latest.id !== row.id))
+          return [];
+      }
       const recency = Math.max(0, 1 - (now - row.updated_at) / NINETY_DAYS_MS);
       const score = Math.min(1, 0.05 + lexical * 0.3 + graph * 0.15 + (sameBranch ? 0.4 : sameSession ? 0.05 : 0) + (kindBoost[row.kind] ?? 0.03) + Math.max(0, Math.min(1, row.confidence)) * 0.08 + recency * 0.05 + (row.source === "manual" ? 0.04 : 0));
       return [{ row, score, sameSession, sameBranch }];
@@ -9266,7 +9559,7 @@ function runDamageDetection(rc) {
       writeRemediationHints(rc.projectId, damage.reReadFiles);
     }
   } catch (err) {
-    warn("Damage detection error", err);
+    debugError("Damage detection skipped", err);
   }
 }
 function stagePendingCompaction(rc, metricsSnapshot) {
@@ -9319,6 +9612,8 @@ function makeBase(opts) {
   const notify = (msg, type = "info") => {
     if (opts.autoTriggered && (type === "info" || type === "success"))
       return;
+    if (type === "info" && !opts.verbose)
+      return;
     opts.ctx.ui.notify(msg, type === "success" ? "info" : type);
   };
   const vlog = (msg) => {
@@ -9391,6 +9686,7 @@ async function runSmartCompact(opts) {
   }
   let finalRc = null;
   let keepApplyProgress = false;
+  let runFailed = false;
   let failureSummaryFields = { profile: base.profile, mode: base.mode };
   if (opts.cancellationOut) {
     opts.cancellationOut.value = {
@@ -9412,7 +9708,7 @@ async function runSmartCompact(opts) {
     const prepared = await prepareRun(base);
     if (!prepared)
       return;
-    base.notify("EESV Compact (" + base.modelLabel + ", " + base.profile + ") \u2014 " + (base.ctx.getContextUsage()?.tokens ?? 0).toLocaleString() + "t", "info");
+    base.notify("EESV Compact (" + base.modelLabel + ", " + base.mode + ") \u2014 " + (base.ctx.getContextUsage()?.tokens ?? 0).toLocaleString() + "t", "info");
     const windowed = resolveCompactionWindow(prepared);
     if (!windowed)
       return;
@@ -9424,7 +9720,13 @@ async function runSmartCompact(opts) {
     };
     markPhase(windowed, "prepare");
     if (!windowed.flags.autoTriggered) {
-      showProgressOverlay(windowed.ctx, { phase: 1, phaseName: "Extract", detail: "Preparing...", model: windowed.modelLabel, profile: windowed.profile });
+      showProgressOverlay(windowed.ctx, {
+        phase: 1,
+        phaseName: "Extract",
+        detail: "Indexing goals, files, decisions, errors, and open loops",
+        model: windowed.modelLabel,
+        profile: windowed.profile
+      });
     }
     const recovered = recoverSessionLog(windowed);
     markPhase(recovered, "recover");
@@ -9448,7 +9750,7 @@ async function runSmartCompact(opts) {
     markPhase(stated, "state");
     if (stated.flags.dryRun) {
       recordSuccessMetrics(stated, "dry-run");
-      stated.notify("DRY RUN (" + stated.method + ", " + stated.profile + ") \u2014 " + stated.toCompact.length + " msgs, " + stated.llmCalls + " calls", "info");
+      stated.ctx.ui.notify("DRY RUN (" + stated.method + ", " + stated.mode + ") \u2014 " + stated.toCompact.length + " msgs, " + stated.llmCalls + " calls", "info");
       return;
     }
     if (stated.cancellation.timedOut)
@@ -9461,20 +9763,24 @@ async function runSmartCompact(opts) {
       try {
         decision = stated.ctx.hasUI ? await showResultScreen(stated.ctx, stated.details, stated.extraction, stated.services, { approval: true }) : "cancel";
       } catch (err) {
-        warn("Approval UI error", err);
+        debugError("Approval UI stopped", err);
         stated.notify("Approval UI failed \u2014 compaction cancelled", "warning");
       }
       if (decision !== "apply") {
         stated.pendingRef.clear(stated.sessionId);
         recordSuccessMetrics(stated, "cancelled");
-        stated.notify("Compaction cancelled \u2014 current conversation unchanged", "info");
+        stated.ctx.ui.notify("Compaction cancelled \u2014 current conversation unchanged", "info");
         return;
       }
     }
     if (stated.cancellation.timedOut)
       return;
     if (willApply) {
-      showProgressOverlay(stated.ctx, { phase: 5, phaseName: "Apply", detail: "Awaiting Pi confirmation..." });
+      showProgressOverlay(stated.ctx, {
+        phase: 5,
+        phaseName: "Apply",
+        detail: "Verified " + stated.verificationScore + "/100 \xB7 staging this run \xB7 awaiting Pi confirmation"
+      });
     }
     stagePendingCompaction(stated, buildSuccessMetrics(stated, "success"));
     if (stated.cancellation.timedOut) {
@@ -9486,6 +9792,7 @@ async function runSmartCompact(opts) {
       keepApplyProgress = true;
     }
   } catch (err) {
+    runFailed = true;
     recordFailureMetrics(finalRc ?? base, err, failureSummaryFields);
     throw err;
   } finally {
@@ -9502,7 +9809,8 @@ async function runSmartCompact(opts) {
     if (base.flags.autoTriggered && !base.cancellation.timedOut) {
       const dur = pipelineMs < 1000 ? pipelineMs + "ms" : (pipelineMs / 1000).toFixed(1) + "s";
       const hasPending = base.pendingRef.isPresent(runSessionId);
-      base.ctx.ui.notify(hasPending ? "Smart compact prepared in " + dur + " \u2014 awaiting native /compact" : "Smart compact run finished in " + dur, "info");
+      if (hasPending || runFailed || finalRc)
+        base.ctx.ui.notify(hasPending ? "Smart compact prepared in " + dur + " \u2014 awaiting native /compact" : runFailed ? "Smart compact stopped safely in " + dur + " \xB7 no summary applied \xB7 Pi fallback continues" : "Smart compact run finished in " + dur, runFailed ? "warning" : "info");
     }
   }
 }
@@ -9646,8 +9954,8 @@ function createCompactionCommitStore(options = {}) {
 
 // src/app/native-continuity-bridge.ts
 import crypto6 from "crypto";
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 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;
@@ -9657,14 +9965,14 @@ function createNativeContinuityBridge(opts = {}) {
   const maxEntries = Math.max(1, opts.maxEntries ?? 64);
   const now = opts.now ?? Date.now;
   const dir = opts.dir ?? nativeContinuityDir();
-  const lockTarget = path11.join(dir, "bridge");
-  const fileFor = (scope) => path11.join(dir, crypto6.createHash("sha256").update(scope.projectId + "\x00" + scope.sessionId + "\x00" + scope.branchHeadId).digest("hex") + ".json");
+  const lockTarget = path12.join(dir, "bridge");
+  const fileFor = (scope) => path12.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 {
-      if (fs8.statSync(file).size > MAX_TEXT_BYTES * 2)
+      if (fs9.statSync(file).size > MAX_TEXT_BYTES * 2)
         return null;
-      const value = JSON.parse(fs8.readFileSync(file, "utf8"));
+      const value = JSON.parse(fs9.readFileSync(file, "utf8"));
       if (value.schemaVersion !== 1 || typeof value.text !== "string" || Buffer.byteLength(value.text) > MAX_TEXT_BYTES || typeof value.createdAt !== "number" || !Number.isFinite(value.createdAt) || !value.scope || !validScope(value.scope))
         return null;
       return value;
@@ -9676,16 +9984,16 @@ function createNativeContinuityBridge(opts = {}) {
     const fresh = [];
     let files = [];
     try {
-      files = fs8.readdirSync(dir).filter((file) => file.endsWith(".json"));
+      files = fs9.readdirSync(dir).filter((file) => file.endsWith(".json"));
     } catch {
       return fresh;
     }
     for (const name of files) {
-      const file = path11.join(dir, name);
+      const file = path12.join(dir, name);
       const entry = readEntry(file);
       if (!entry || now() - entry.createdAt > ttlMs || entry.createdAt - now() > ttlMs) {
         try {
-          fs8.unlinkSync(file);
+          fs9.unlinkSync(file);
         } catch {}
       } else {
         fresh.push({ file, entry });
@@ -9696,7 +10004,7 @@ function createNativeContinuityBridge(opts = {}) {
       const oldest = fresh.shift();
       if (oldest)
         try {
-          fs8.unlinkSync(oldest.file);
+          fs9.unlinkSync(oldest.file);
         } catch {}
     }
     return fresh;
@@ -9704,7 +10012,7 @@ function createNativeContinuityBridge(opts = {}) {
   const locked = (work) => {
     ensureDir(dir);
     try {
-      fs8.chmodSync(dir, 448);
+      fs9.chmodSync(dir, 448);
     } catch {}
     const release = acquireLockSync(lockTarget);
     try {
@@ -9721,13 +10029,13 @@ function createNativeContinuityBridge(opts = {}) {
         locked(() => {
           const target = fileFor(scope);
           try {
-            fs8.unlinkSync(target);
+            fs9.unlinkSync(target);
           } catch {}
           prune(1);
           const entry = { schemaVersion: 1, scope, text, createdAt: now() };
           atomicWriteFileSync(target, JSON.stringify(entry));
           try {
-            fs8.chmodSync(target, 384);
+            fs9.chmodSync(target, 384);
           } catch {}
         });
       } catch (error2) {
@@ -9745,7 +10053,7 @@ function createNativeContinuityBridge(opts = {}) {
           if (!entry)
             return null;
           try {
-            fs8.unlinkSync(target);
+            fs9.unlinkSync(target);
           } catch {
             return null;
           }
@@ -9761,13 +10069,13 @@ function createNativeContinuityBridge(opts = {}) {
         locked(() => {
           if (scope) {
             try {
-              fs8.unlinkSync(fileFor(scope));
+              fs9.unlinkSync(fileFor(scope));
             } catch {}
             return;
           }
           for (const item of prune(0)) {
             try {
-              fs8.unlinkSync(item.file);
+              fs9.unlinkSync(item.file);
             } catch {}
           }
         });
@@ -9828,15 +10136,16 @@ function resolveModels(ctx, primary, config, explicit = false) {
   return { segModel, sumModel, verifyModel };
 }
 function resolveGraphScope(ctx) {
+  const projectId = deriveProjectIdFromCwd(ctx.cwd);
   const sessionId = resolveSessionId(ctx);
-  if (isUnresolvedSessionId(sessionId))
+  if (!projectId || isUnresolvedSessionId(sessionId))
     return null;
-  const branchEntryIds = ctx.sessionManager.getBranch().map((entry) => entry.id).filter((id) => typeof id === "string");
+  const ancestryIds = branchEntryIds(ctx.sessionManager.getBranch());
   return {
-    projectId: deriveProjectIdFromCwd(ctx.cwd),
+    projectId,
     sessionId,
-    branchHeadId: branchEntryIds.at(-1),
-    branchEntryIds
+    branchHeadId: ancestryIds.at(-1),
+    branchEntryIds: ancestryIds
   };
 }
 function smartCompactExtension(pi) {
@@ -9918,7 +10227,7 @@ function smartCompactExtension(pi) {
       }
       const scope = resolveGraphScope(ctx);
       if (!scope)
-        return { content: [{ type: "text", text: "Smart Recall needs a persisted session id." }], details: undefined };
+        return { content: [{ type: "text", text: "Smart Recall must run from a project directory and needs a persisted session id." }], details: undefined };
       const results = recallContext(scope, params.query, {
         limit: params.limit,
         sessionOnly: params.scope === "session",
@@ -9952,11 +10261,11 @@ function smartCompactExtension(pi) {
       }
       const scope = resolveGraphScope(ctx);
       if (!scope)
-        return { content: [{ type: "text", text: "Saving memory needs a persisted session id." }], details: undefined };
+        return { content: [{ type: "text", text: "Saving project memory must run from a project directory and needs a persisted session id." }], details: undefined };
       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((path12) => scrubber.scrubText(path12).value);
+      const relatedPaths = (params.related_paths ?? []).map((path13) => scrubber.scrubText(path13).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 };
@@ -9964,7 +10273,7 @@ function smartCompactExtension(pi) {
       const approved = await ctx.ui.confirm(status === "resolved" ? "Resolve Project Memory" : "Save Project Memory", "Kind: " + params.kind + `
 Title: ` + title + `
 
-` + content.slice(0, 800) + (relatedPaths.length ? `
+` + content + (relatedPaths.length ? `
 
 Paths: ` + relatedPaths.join(", ") : ""));
       if (!approved || signal?.aborted) {
@@ -9987,7 +10296,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
   pi.registerCommand("smart-compact", {
     description: "EESV smart compaction v" + VERSION + ". Usage: /smart-compact [model] [mode] [flags] [--focus=topic] [--max-calls=N] [--max-input-tokens=N] [note]",
     getArgumentCompletions: (prefix) => {
-      const m = ["verbose", "debug", "dry-run", "metrics", "dashboard", "restore", "loops", "auto", "balanced", "aggressive", "fast", "thorough", "slow", "light", "--focus=", "--max-calls=", "--max-input-tokens=", "--max-latency="].filter((o) => o.startsWith(prefix)).map((o) => ({ value: o, label: o }));
+      const m = ["verbose", "debug", "dry-run", "metrics", "dashboard", "restore", "loops", "fast", "balanced", "thorough", "--focus=", "--max-calls=", "--max-input-tokens=", "--max-latency="].filter((o) => o.startsWith(prefix)).map((o) => ({ value: o, label: o }));
       return m.length ? m : null;
     },
     handler: async (args, ctx) => {
@@ -10005,16 +10314,16 @@ Paths: ` + relatedPaths.join(", ") : ""));
         const maxLlmCalls = maxCallsRaw == null ? undefined : Number(maxCallsRaw);
         const maxLlmInputTokens = maxInputRaw == null ? undefined : Number(maxInputRaw);
         const maxLatencyMs = maxLatencyRaw == null ? undefined : Number(maxLatencyRaw);
-        if (maxLlmCalls !== undefined && (!Number.isInteger(maxLlmCalls) || maxLlmCalls < 1 || maxLlmCalls > 100)) {
-          ctx.ui.notify("--max-calls must be an integer from 1 to 100", "error");
+        if (maxLlmCalls !== undefined && (!Number.isInteger(maxLlmCalls) || maxLlmCalls < BUDGET_LIMITS.CALLS.min || maxLlmCalls > BUDGET_LIMITS.CALLS.max)) {
+          ctx.ui.notify("--max-calls must be an integer from " + BUDGET_LIMITS.CALLS.min + " to " + BUDGET_LIMITS.CALLS.max, "error");
           return;
         }
-        if (maxLlmInputTokens !== undefined && (!Number.isInteger(maxLlmInputTokens) || maxLlmInputTokens < 1e4 || maxLlmInputTokens > 1e6)) {
-          ctx.ui.notify("--max-input-tokens must be an integer from 10000 to 1000000", "error");
+        if (maxLlmInputTokens !== undefined && (!Number.isInteger(maxLlmInputTokens) || maxLlmInputTokens < BUDGET_LIMITS.INPUT_TOKENS.min || maxLlmInputTokens > BUDGET_LIMITS.INPUT_TOKENS.max)) {
+          ctx.ui.notify("--max-input-tokens must be an integer from " + BUDGET_LIMITS.INPUT_TOKENS.min + " to " + BUDGET_LIMITS.INPUT_TOKENS.max, "error");
           return;
         }
-        if (maxLatencyMs !== undefined && (!Number.isFinite(maxLatencyMs) || maxLatencyMs < 5000 || maxLatencyMs > 600000)) {
-          ctx.ui.notify("--max-latency must be 5000\u2013600000 ms", "error");
+        if (maxLatencyMs !== undefined && (!Number.isFinite(maxLatencyMs) || maxLatencyMs < BUDGET_LIMITS.LATENCY_MS.min || maxLatencyMs > BUDGET_LIMITS.LATENCY_MS.max)) {
+          ctx.ui.notify("--max-latency must be " + BUDGET_LIMITS.LATENCY_MS.min + "\u2013" + BUDGET_LIMITS.LATENCY_MS.max + " ms", "error");
           return;
         }
         if (flags.includes("metrics") || flags.includes("dashboard")) {
@@ -10082,8 +10391,12 @@ Paths: ` + relatedPaths.join(", ") : ""));
         }
         if (flags.includes("loops")) {
           const projectId = deriveProjectIdFromCwd(ctx.cwd);
+          if (!projectId) {
+            ctx.ui.notify("Project loops must be managed from a project directory", "warning");
+            return;
+          }
           const sessionId = resolveSessionId(ctx);
-          const branchIds = ctx.sessionManager.getBranch().map((entry) => entry.id).filter((id) => typeof id === "string");
+          const branchIds = branchEntryIds(ctx.sessionManager.getBranch());
           const state = isUnresolvedSessionId(sessionId) ? null : loadScopedCompactionState({ projectId, sessionId }, branchIds);
           if (!state || state.openLoops.length === 0) {
             ctx.ui.notify("No persisted open loops for this project", "info");
@@ -10104,8 +10417,10 @@ Paths: ` + relatedPaths.join(", ") : ""));
         const knownProviders = new Set(ctx.modelRegistry.getAvailable().map((m) => m.provider));
         const modelArg = tokens.find((t) => /^[a-z0-9_.-]+\/[a-z0-9_.:-]+$/i.test(t) && (findModelById(ctx, t) || knownProviders.has(t.split("/")[0])));
         const config = loadConfig();
-        const rawMode = tokens.find((t) => ["auto", "balanced", "aggressive", "fast", "thorough", "slow"].includes(t));
-        const modeArg = rawMode === "slow" ? "thorough" : rawMode;
+        const rawMode = tokens.find((t) => ["auto", "fast", "balanced", "thorough", "aggressive", "slow"].includes(t));
+        const modeArg = rawMode === "slow" ? "thorough" : rawMode === "aggressive" ? "fast" : rawMode;
+        if (rawMode === "aggressive")
+          ctx.ui.notify("Aggressive mode is now Fast; using Fast.", "warning");
         const profileArg = tokens.includes("light") ? "light" : undefined;
         const mode = modeArg ?? (profileArg ? modeFromLegacyProfile(profileArg) : config.mode);
         if (!tokens.length) {
@@ -10222,7 +10537,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
             cancellationOut
           });
         } catch (err) {
-          warn("Smart compact auto-trigger threw", err);
+          debugError("Smart compact auto-trigger stopped", err);
         } finally {
           clearTimeout(timeoutId);
         }
@@ -10232,7 +10547,7 @@ Paths: ` + relatedPaths.join(", ") : ""));
         }
       }
     } catch (e) {
-      warn("session_before_compact error", e);
+      debugError("session_before_compact stopped", e);
     }
   });
   pi.on("session_compact", async (event, ctx) => {
@@ -10262,7 +10577,9 @@ Paths: ` + relatedPaths.join(", ") : ""));
     if (isUnresolvedSessionId(sessionId))
       return;
     const projectId = deriveProjectIdFromCwd(ctx.cwd);
-    const branchIds = ctx.sessionManager.getBranch().map((entry) => entry.id).filter((id) => typeof id === "string");
+    if (!projectId)
+      return;
+    const branchIds = branchEntryIds(ctx.sessionManager.getBranch());
     const branchHeadId = typeof event.compactionEntry.id === "string" ? event.compactionEntry.id : branchIds.at(-1);
     if (!branchHeadId)
       return;
@@ -10331,27 +10648,27 @@ Paths: ` + relatedPaths.join(", ") : ""));
     parameters: {
       type: "object",
       properties: {
-        mode: { type: "string", description: "auto, balanced, aggressive, fast, or thorough (slow alias). Default: auto." },
+        mode: { type: "string", description: "fast, balanced, thorough, or auto. Default: auto." },
         profile: { type: "string", description: "Deprecated alias: light, balanced, or aggressive." },
         verbose: { type: "boolean", description: "Show detailed pipeline output." },
         dry_run: { type: "boolean", description: "Run the pipeline but skip applying the compaction." },
         report: { type: "boolean", description: "Return recent performance metrics instead of compacting." },
         dashboard: { type: "boolean", description: "Write a local HTML metrics dashboard and return its path." },
         focus: { type: "string", description: "Topic or path that should receive extra preservation budget." },
-        max_calls: { type: "number", description: "Maximum LLM calls for this run (1-100)." },
-        max_input_tokens: { type: "number", description: "Aggregate prompt-token budget for this run (10000-1000000)." },
-        max_latency_ms: { type: "number", description: "Optional hard pipeline latency budget in milliseconds (5000-600000). Modes use soft latency targets by default." }
+        max_calls: { type: "number", description: "Maximum LLM calls for this run (" + BUDGET_LIMITS.CALLS.min + "-" + BUDGET_LIMITS.CALLS.max + ")." },
+        max_input_tokens: { type: "number", description: "Aggregate prompt-token budget for this run (" + BUDGET_LIMITS.INPUT_TOKENS.min + "-" + BUDGET_LIMITS.INPUT_TOKENS.max + ")." },
+        max_latency_ms: { type: "number", description: "Optional pipeline cancellation budget in milliseconds (" + BUDGET_LIMITS.LATENCY_MS.min + "-" + BUDGET_LIMITS.LATENCY_MS.max + ")." }
       }
     },
     async execute(_id, params, signal, _onUp, ctx) {
       const profile = params.profile === "light" || params.profile === "balanced" || params.profile === "aggressive" ? params.profile : undefined;
-      const mode = params.mode === "slow" ? "thorough" : ["auto", "balanced", "aggressive", "fast", "thorough"].find((value) => value === params.mode);
+      const mode = params.mode === "slow" ? "thorough" : params.mode === "aggressive" ? "fast" : ["auto", "fast", "balanced", "thorough"].find((value) => value === params.mode);
       const verbose = !!params.verbose;
       const dryRun = !!params.dry_run;
       const focus = typeof params.focus === "string" ? params.focus.trim() || undefined : undefined;
-      const maxLlmCalls = typeof params.max_calls === "number" && Number.isInteger(params.max_calls) && params.max_calls >= 1 && params.max_calls <= 100 ? params.max_calls : undefined;
-      const maxLlmInputTokens = typeof params.max_input_tokens === "number" && Number.isInteger(params.max_input_tokens) && params.max_input_tokens >= 1e4 && params.max_input_tokens <= 1e6 ? params.max_input_tokens : undefined;
-      const maxLatencyMs = typeof params.max_latency_ms === "number" && params.max_latency_ms >= 5000 && params.max_latency_ms <= 600000 ? params.max_latency_ms : undefined;
+      const maxLlmCalls = typeof params.max_calls === "number" && Number.isInteger(params.max_calls) && params.max_calls >= BUDGET_LIMITS.CALLS.min && params.max_calls <= BUDGET_LIMITS.CALLS.max ? params.max_calls : undefined;
+      const maxLlmInputTokens = typeof params.max_input_tokens === "number" && Number.isInteger(params.max_input_tokens) && params.max_input_tokens >= BUDGET_LIMITS.INPUT_TOKENS.min && params.max_input_tokens <= BUDGET_LIMITS.INPUT_TOKENS.max ? params.max_input_tokens : undefined;
+      const maxLatencyMs = typeof params.max_latency_ms === "number" && params.max_latency_ms >= BUDGET_LIMITS.LATENCY_MS.min && params.max_latency_ms <= BUDGET_LIMITS.LATENCY_MS.max ? params.max_latency_ms : undefined;
       if (params.report || params.dashboard) {
         const report = buildMetricsReport();
         const fp = params.dashboard ? writeMetricsDashboard() : null;