pi-smart-compact 7.5.2 → 7.7.0

package/dist/index.js

@@ -0,0 +1,2979 @@
+// @bun
+// src/constants.ts
+var VERSION = "7.7.0";
+var CHARS_PER_TOKEN = 3.8;
+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: {
+    summaryBudgetTokens: 1e4,
+    keepRecentTokens: 30000,
+    minChunkTokens: 800,
+    maxChunkTokens: 12000,
+    singlePassMaxTokens: 40000,
+    batchMaxTokens: 30000
+  },
+  balanced: {
+    summaryBudgetTokens: 6000,
+    keepRecentTokens: 20000,
+    minChunkTokens: 500,
+    maxChunkTokens: 8000,
+    singlePassMaxTokens: 30000,
+    batchMaxTokens: 24000
+  },
+  aggressive: {
+    summaryBudgetTokens: 3000,
+    keepRecentTokens: 1e4,
+    minChunkTokens: 300,
+    maxChunkTokens: 6000,
+    singlePassMaxTokens: 20000,
+    batchMaxTokens: 18000
+  }
+};
+var DEFAULT_CONFIG = {
+  profile: "balanced",
+  profiles: PROFILES,
+  summaryModel: null,
+  segmentationModel: null,
+  autoTrigger: true,
+  backupEnabled: true,
+  backupDir: ""
+};
+var NO_OP_RE = /applied:\s*0|no changes applied|nothing to (?:do|change)|0 edits? applied/i;
+var SHIFT_RE = /simdi|peki|bide|bi de|gecelim|bakalim|yapalim|baska|sonra|tamam simdi|now let|also|next|let's|moving on|switch to/i;
+var CHOICE_RE = /use\s+\S+\s+(?:instead|not|rather)|don't\s+use|avoid\s+|switch\s+to\s+|go\s+with\s+|prefer\s+/i;
+var SINGLE_PASS_PREFIX = `Summarize this coding agent conversation. Produce ONE structured summary.
+` + `
+Rules for Accuracy:
+` + `1. Session Type: read-only tool calls = REVIEW, not implementation
+` + `2. Status: Check for user complaints before marking "Done"
+` + `3. Exact Names: Quote specific variable/function/parameter names, don't paraphrase
+` + `4. Files: Use the VERIFIED file lists above (deterministically extracted, zero hallucination risk)
+` + `
+Output EXACTLY this format:
+
+` + `## Goal
+[What the user is trying to accomplish]
+` + `## Constraints & Preferences
+- [CRITICAL: user requirements, preferences, constraints]
+` + `## Progress
+### Done
+- [x] [Completed tasks with file references]
+### In Progress
+- [ ] [Current work state]
+### Blocked
+- [Issues]
+` + `## Key Decisions
+- **[Decision]**: [Rationale]
+` + `## Files Modified
+- [Verified list from deterministic extraction]
+` + `## Files Read
+- [Verified list from deterministic extraction]
+` + `## Next Steps
+1. [What should happen next]
+` + `## Critical Context
+- [Specific data, patterns, info needed to continue]
+- [Error patterns or gotchas]
+` + `## Topics Covered
+[Chronological bullet list with priority in brackets]
+`;
+var SINGLE_PASS_SUFFIX = `
+{PREV_CONTEXT}
+
+{EXTRACTION_CONTEXT}
+
+{EXPLORATION_CONTEXT}
+
+<conversation>
+{CONVERSATION}
+</conversation>`;
+var BATCH_PROMPT_PREFIX = `Summarize these conversation segments.
+
+Rules for Accuracy:
+` + `1. Use EXACT file paths from extraction data
+` + `2. Status: only mark "done" if there's clear evidence (successful test run, user confirmation)
+` + `3. Quote specific values, don't paraphrase code
+
+` + `For EACH segment produce:
+` + `### {TOPIC_NAME}
+` + `**Priority**: [critical|high|normal|low]
+` + `**Summary**: [2-4 sentences: what happened, errors, code changes with paths]
+` + `**Decisions**: [comma-separated, or "None"]
+` + `**Modified**: [comma-separated paths, or "None"]
+` + `**Read**: [comma-separated paths, or "None"]
+`;
+var BATCH_PROMPT_SUFFIX = `
+{EXTRACTION_CONTEXT}
+
+<segments>
+{TEXT}
+</segments>`;
+var ASSEMBLY_PROMPT_PREFIX = `Merge these topic summaries into ONE coherent summary.
+
+` + `## IMMUTABLE CONTEXT (do not modify or contradict these facts)
+` + `These are deterministically verified from the original conversation. They take priority over ANY summary content below.
+
+` + `Rules:
+` + `1. Preserve ALL critical/high info. Condense normal, minimize low.
+` + `2. Chronological order.
+` + `3. The pre-processed data below is GROUND TRUTH \u2014 trust it over individual summaries.
+` + `4. Files Modified list is deterministically verified \u2014 if a summary says a file was modified but it's NOT in the list above, omit it.
+` + `5. Key Decisions below are verified \u2014 preserve them exactly, do not paraphrase the decision text.
+` + `6. Do NOT fabricate file paths, function names, or error messages not present in the verified data.
+
+` + `Format:
+` + `## Goal
+[Overall objective]
+` + `## Constraints & Preferences
+- [CRITICAL requirements, preferences, constraints]
+` + `## Progress
+### Done
+- [x] [Completed tasks with file refs]
+### In Progress
+- [ ] [Current work state]
+### Blocked
+- [Issues]
+` + `## Key Decisions
+- **[Decision]**: [Rationale]
+` + `## Files Modified
+- [Verified deterministic list]
+` + `## Files Read
+- [Verified deterministic list]
+` + `## Next Steps
+1. [What should happen next]
+` + `## Critical Context
+- [Data, patterns, info needed]
+` + `## Topics Covered
+[Chronological bullets with priority]
+`;
+var ASSEMBLY_PROMPT_SUFFIX = `
+IMMUTABLE CONTEXT (verified deterministic data):
+- Key Decisions: {DECISIONS}
+- Files Modified (VERIFIED): {MODIFIED}
+- Files Read (VERIFIED): {READ}
+
+{EXPLORATION_CONTEXT}
+{PREV_CONTEXT}
+
+<summaries>{SUMMARIES}</summaries>`;
+var SESSION_TYPE_INSTRUCTIONS = {
+  debugging: "Focus on: error chains, root cause analysis, attempted fixes, resolution status. Prioritize error messages and stack traces. Mark files as Done only if all errors resolved.",
+  implementation: "Focus on: files created/modified, architectural decisions, feature completeness, test coverage. Prioritize code changes with exact paths.",
+  review: "Focus on: files read, issues found, recommendations, approval status. Prioritize findings over changes. Read-only tool calls = REVIEW, not implementation.",
+  discussion: "Focus on: decisions made, trade-offs discussed, consensus reached. Prioritize rationale over implementation details."
+};
+var EXPLORER_SYSTEM_PROMPT = `You are a conversation analyst. You have deterministic extraction data and can query the raw conversation using tools.
+
+` + `Your job:
+` + `1. Verify/enrich the extracted boundaries (merge, split, or add as needed)
+` + `2. Identify cross-topic relationships
+` + `3. Find implicit constraints (user tone, frustration, urgency)
+` + `4. Assess completion status accurately
+` + `5. Extract the narrative arc
+
+` + `Use tools BEFORE forming conclusions. You may make up to 8 tool calls.
+
+` + `After exploration, output ONLY a JSON object (no markdown):
+` + '{"boundaries":[{"afterIndex":N,"topic":"...","priority":"critical|high|normal|low","confidence":0.0-1.0}],"mainGoal":"...","sessionType":"implementation|review|debugging|discussion","enrichedConstraints":[...],"crossReferences":[...],"statusAssessment":{"done":[...],"inProgress":[...],"blocked":[...]},"criticalContext":[...],"keyDecisions":[...]}';
+
+// src/utils/helpers.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+var _cfg = null;
+var _cfgMtime = 0;
+function loadConfig() {
+  try {
+    const p = path.join(process.env.HOME ?? "/tmp", ".pi/agent/settings.json");
+    const stat = fs.statSync(p);
+    if (_cfg && stat.mtimeMs === _cfgMtime)
+      return _cfg;
+    const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
+    const sc = raw.smartCompact ?? raw.semanticCompact ?? {};
+    const merged = { ...DEFAULT_CONFIG, ...sc };
+    if (sc.profiles)
+      merged.profiles = { ...PROFILES, ...sc.profiles };
+    if (!merged.backupDir)
+      merged.backupDir = path.join(process.env.HOME ?? "/tmp", ".pi/agent/compact-backups");
+    _cfg = merged;
+    _cfgMtime = stat.mtimeMs;
+    return _cfg;
+  } catch {
+    return { ...DEFAULT_CONFIG, backupDir: path.join(process.env.HOME ?? "/tmp", ".pi/agent/compact-backups") };
+  }
+}
+function backupConversation(convText, sessionId) {
+  try {
+    const cfg = loadConfig();
+    if (!cfg.backupEnabled)
+      return null;
+    const dir = cfg.backupDir;
+    fs.mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const hash = crypto.createHash("sha256").update(convText).digest("hex").slice(0, 8);
+    const fp = path.join(dir, sessionId + "-" + ts + "-" + hash + ".md");
+    fs.writeFileSync(fp, `# Smart Compact Backup
+# Date: ` + new Date().toISOString() + `
+# Session: ` + sessionId + `
+
+` + convText);
+    return fp;
+  } catch {
+    return null;
+  }
+}
+function getPreviousCompactionContext(branch) {
+  const compactions = branch.filter((e) => e.type === "compaction");
+  if (!compactions.length)
+    return "";
+  const last = compactions[compactions.length - 1];
+  const topics = last.details?.topics ?? [];
+  if (!topics.length)
+    return "";
+  return `
+[IMPORTANT: Previous compaction exists (` + (last.details?.method ?? "unknown") + "). Already summarized topics: " + topics.join(", ") + ". Build upon this, don't re-summarize the same content.]";
+}
+function smartKeepBoundary(msgs, keepFromIndex) {
+  if (keepFromIndex <= 0 || keepFromIndex >= msgs.length)
+    return keepFromIndex;
+  const last = msgs[keepFromIndex - 1];
+  const first = msgs[keepFromIndex];
+  if (last && first) {
+    const lastText = JSON.stringify(last.message).toLowerCase();
+    const keptText = JSON.stringify(first.message).toLowerCase();
+    const fileRe = /(?:path|file)=["']([^"']+)["']/g;
+    const lastFiles = new Set([...lastText.matchAll(fileRe)].map((m) => m[1].split("/").pop()));
+    fileRe.lastIndex = 0;
+    const keptFiles = new Set([...keptText.matchAll(fileRe)].map((m) => m[1].split("/").pop()));
+    if ([...lastFiles].filter((f) => keptFiles.has(f)).length > 0)
+      return keepFromIndex - 1;
+  }
+  return keepFromIndex;
+}
+function createBatches(chunks, maxTokens) {
+  const batches = [];
+  let batch = [], bt = 0;
+  for (const ch of chunks) {
+    if (batch.length && bt + ch.tokenEstimate > maxTokens) {
+      batches.push(batch);
+      batch = [];
+      bt = 0;
+    }
+    batch.push(ch);
+    bt += ch.tokenEstimate;
+  }
+  if (batch.length)
+    batches.push(batch);
+  return batches;
+}
+function allocateTopicBudgets(summaries, totalBudget) {
+  const n = summaries.length;
+  if (n === 0)
+    return new Map;
+  const weights = summaries.map((s, i) => {
+    let w = 1;
+    if (s.priority === "critical")
+      w *= 2;
+    else if (s.priority === "high")
+      w *= 1.5;
+    else if (s.priority === "low")
+      w *= 0.6;
+    const errorKeywords = (s.summary.match(/error|fail|bug|fix|crash|exception/gi) ?? []).length;
+    w *= 1 + errorKeywords * 0.2;
+    const recency = (i + 1) / n;
+    w *= 0.6 + recency * 0.4;
+    if (s.keyDecisions.length > 0)
+      w *= 1.3;
+    return w;
+  });
+  const totalWeight = weights.reduce((a, b) => a + b, 0);
+  const baseTokensPerTopic = Math.floor(totalBudget / n);
+  const budgetMap = new Map;
+  for (let i = 0;i < summaries.length; i++) {
+    const allocated = Math.round(baseTokensPerTopic * (weights[i] / (totalWeight / n)));
+    budgetMap.set(summaries[i].topic, Math.max(200, allocated));
+  }
+  return budgetMap;
+}
+function preProcessSummaries(summaries, budgetTokens) {
+  const topicBudgets = budgetTokens ? allocateTopicBudgets(summaries, budgetTokens) : null;
+  return {
+    decisions: [...new Set(summaries.flatMap((s) => s.keyDecisions))],
+    modified: [...new Set(summaries.flatMap((s) => s.filesModified))].sort(),
+    read: [...new Set(summaries.flatMap((s) => s.filesRead))].sort(),
+    text: summaries.map((cs, i) => {
+      const budgetHint = topicBudgets?.get(cs.topic);
+      const budgetLine = budgetHint ? `
+Budget: ~` + budgetHint + " tokens" : "";
+      return "### Segment " + (i + 1) + ": " + cs.topic + `
+Priority: ` + cs.priority + " | msgs " + cs.startIndex + "-" + cs.endIndex + budgetLine + `
+
+` + cs.summary + `
+
+Decisions: ` + (cs.keyDecisions.join("; ") || "None") + `
+Modified: ` + (cs.filesModified.join(", ") || "None") + `
+Read: ` + (cs.filesRead.join(", ") || "None");
+    }).join(`
+---
+`)
+  };
+}
+function buildExtractionContext(extraction, forRange) {
+  const files = forRange ? extraction.modifiedFiles.filter((f) => f.lastModifiedIndex >= forRange.start && f.lastModifiedIndex <= forRange.end) : extraction.modifiedFiles;
+  const errors = forRange ? extraction.errors.filter((e) => e.index >= forRange.start && e.index <= forRange.end) : extraction.errors;
+  return [
+    "## Deterministic Extraction (verified facts)",
+    "Files modified: " + (files.map((f) => f.path).join(", ") || "none"),
+    "Errors: " + (errors.map((e) => "[" + e.tool + "] " + e.message.slice(0, 80) + (e.resolved ? " \u2713" : "")).join("; ") || "none"),
+    "Decisions: " + (extraction.decisions.map((d) => d.type + ": " + d.summary.slice(0, 60)).join("; ") || "none"),
+    "Constraints: " + (extraction.constraints.map((c) => "[" + c.category + "] " + c.text.slice(0, 60)).join("; ") || "none")
+  ].join(`
+`);
+}
+function buildExplorationContext(report) {
+  if (!report.mainGoal && !report.crossReferences.length && !report.enrichedConstraints.length)
+    return "";
+  return [
+    "## Exploration Report",
+    "Main goal: " + report.mainGoal,
+    "Session type: " + report.sessionType,
+    report.crossReferences.length ? "Cross-references: " + report.crossReferences.join("; ") : "",
+    report.enrichedConstraints.length ? "Enriched constraints: " + report.enrichedConstraints.join("; ") : "",
+    report.statusAssessment.done.length ? "Assessed done: " + report.statusAssessment.done.join("; ") : "",
+    report.statusAssessment.inProgress.length ? "Assessed in-progress: " + report.statusAssessment.inProgress.join("; ") : "",
+    report.criticalContext.length ? "Critical context: " + report.criticalContext.join("; ") : ""
+  ].filter(Boolean).join(`
+`);
+}
+
+// src/core.ts
+import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
+
+// src/utils/tokens.ts
+var PROVIDER_MAP = {
+  "zai-anthropic": {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 3.5,
+    concurrencyLimit: 3,
+    cacheStrategy: "anthropic"
+  },
+  minimax: {
+    maxOutputTokens: 4096,
+    supportsTools: "probe",
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.8,
+    concurrencyLimit: 2,
+    cacheStrategy: "anthropic"
+  },
+  "xiaomi-token-plan": {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.3,
+    concurrencyLimit: 2,
+    cacheStrategy: "openai"
+  },
+  openai: {
+    maxOutputTokens: 16384,
+    supportsTools: true,
+    jsonReliability: "high",
+    instructionFollowing: "high",
+    tokenRatioEstimate: 4,
+    concurrencyLimit: 5,
+    cacheStrategy: "openai"
+  }
+};
+function getProviderCaps(provider) {
+  return PROVIDER_MAP[provider] ?? {
+    maxOutputTokens: 8192,
+    supportsTools: "probe",
+    jsonReliability: "medium",
+    instructionFollowing: "medium",
+    tokenRatioEstimate: 3.8,
+    concurrencyLimit: 2,
+    cacheStrategy: "none"
+  };
+}
+var _calibrationFactors = new Map;
+function getCalibrationFactor(provider) {
+  if (!provider)
+    return 1;
+  return _calibrationFactors.get(provider) ?? 1;
+}
+function estimateTokens(text, provider) {
+  const baseRatio = provider ? getProviderCaps(provider).tokenRatioEstimate : CHARS_PER_TOKEN;
+  const jsonPenalty = text.startsWith("[") || text.startsWith("{") ? 0.85 : 1;
+  const langPenalty = /[\u00E7\u011F\u0131\u00F6\u015F\u00FC\u00C7\u011E\u0130\u00D6\u015E\u00DC]/.test(text) ? 0.9 : 1;
+  const calibration = getCalibrationFactor(provider);
+  return Math.ceil(text.length / baseRatio * jsonPenalty * langPenalty * calibration);
+}
+function calibrateFromResponse(estimated, actual, provider) {
+  if (actual > 0 && estimated > 0 && provider) {
+    const prev = _calibrationFactors.get(provider) ?? 1;
+    const sample = actual / estimated;
+    _calibrationFactors.set(provider, prev * 0.7 + sample * 0.3);
+  }
+}
+
+// src/utils/cache.ts
+import fs2 from "fs";
+import path2 from "path";
+import crypto2 from "crypto";
+import { complete } from "@earendil-works/pi-ai";
+var CACHE_DIR = path2.join(process.env.HOME ?? "/tmp", ".pi", "agent", ".cache");
+var _compactSessionId = null;
+function getCompactSessionId() {
+  if (!_compactSessionId) {
+    _compactSessionId = "sc-" + Date.now().toString(36) + "-" + crypto2.randomBytes(4).toString("hex");
+  }
+  return _compactSessionId;
+}
+function resetCompactSessionId() {
+  _compactSessionId = null;
+}
+function cacheOpts(opts) {
+  const retention = opts.cacheRetention ?? "short";
+  if (retention === "none") {
+    return { ...opts, cacheRetention: "none" };
+  }
+  return { ...opts, sessionId: getCompactSessionId(), cacheRetention: "short" };
+}
+var _metrics = [];
+function resetMetrics() {
+  _metrics.length = 0;
+}
+function recordMetric(m) {
+  _metrics.push(m);
+  if (_metrics.length > 200)
+    _metrics.splice(0, _metrics.length - 100);
+}
+function getMetricsSummary() {
+  const n = _metrics.length;
+  if (!n)
+    return { totalCalls: 0, totalInput: 0, totalOutput: 0, totalCacheHit: 0, avgLatency: 0, cacheHitRate: 0 };
+  const totalInput = _metrics.reduce((s, m) => s + m.inputTokens, 0);
+  const totalOutput = _metrics.reduce((s, m) => s + m.outputTokens, 0);
+  const totalCacheHit = _metrics.reduce((s, m) => s + m.cacheHitTokens, 0);
+  const avgLatency = _metrics.reduce((s, m) => s + m.latencyMs, 0) / n;
+  return {
+    totalCalls: n,
+    totalInput,
+    totalOutput,
+    totalCacheHit,
+    avgLatency: Math.round(avgLatency),
+    cacheHitRate: totalInput > 0 ? totalCacheHit / totalInput : 0
+  };
+}
+async function trackedComplete(phase, model, reqBody, opts) {
+  const start = Date.now();
+  try {
+    const resp = await complete(model, reqBody, opts);
+    const latency = Date.now() - start;
+    const usage = resp.usage;
+    const inputT = usage?.input ?? 0;
+    const outputT = usage?.output ?? 0;
+    const cacheT = usage?.cacheRead ?? 0;
+    recordMetric({
+      phase,
+      model: model.id,
+      inputTokens: inputT,
+      outputTokens: outputT,
+      cacheHitTokens: cacheT,
+      latencyMs: latency,
+      success: true
+    });
+    if (inputT > 0 && "messages" in reqBody) {
+      const rawText = JSON.stringify(reqBody.messages);
+      calibrateFromResponse(estimateTokens(rawText), inputT, model.provider);
+    }
+    return resp;
+  } catch (err) {
+    recordMetric({
+      phase,
+      model: model.id,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheHitTokens: 0,
+      latencyMs: Date.now() - start,
+      success: false
+    });
+    throw err;
+  }
+}
+function getCachePath(sessionId) {
+  return path2.join(CACHE_DIR, "compact-extraction-" + sessionId.replace(/[^a-zA-Z0-9-]/g, "_") + ".json");
+}
+function saveCachedExtraction(sessionId, extraction, msgCount) {
+  try {
+    if (!fs2.existsSync(CACHE_DIR))
+      fs2.mkdirSync(CACHE_DIR, { recursive: true });
+    const cached = {
+      lastMessageIndex: msgCount - 1,
+      extraction,
+      messageCount: msgCount,
+      timestamp: Date.now()
+    };
+    fs2.writeFileSync(getCachePath(sessionId), JSON.stringify(cached));
+  } catch {}
+}
+function loadCachedExtraction(sessionId) {
+  try {
+    const fp = getCachePath(sessionId);
+    if (!fs2.existsSync(fp))
+      return null;
+    const cached = JSON.parse(fs2.readFileSync(fp, "utf8"));
+    if (Date.now() - cached.timestamp > 3600000)
+      return null;
+    return cached;
+  } catch {
+    return null;
+  }
+}
+function mergeExtractions(base, delta, baseMsgCount) {
+  return {
+    modifiedFiles: [...base.modifiedFiles, ...delta.modifiedFiles],
+    readFiles: [...new Set([...base.readFiles, ...delta.readFiles])],
+    deletedFiles: [...new Set([...base.deletedFiles, ...delta.deletedFiles])],
+    errors: [...base.errors, ...delta.errors],
+    decisions: [...base.decisions, ...delta.decisions],
+    constraints: [...base.constraints, ...delta.constraints],
+    topics: [...base.topics, ...delta.topics],
+    timeline: [...base.timeline, ...delta.timeline],
+    mainGoal: delta.mainGoal ?? base.mainGoal,
+    lastUserMessages: delta.lastUserMessages.length > 0 ? delta.lastUserMessages : base.lastUserMessages,
+    lastErrors: delta.lastErrors.length > 0 ? delta.lastErrors : base.lastErrors,
+    messageCount: baseMsgCount + delta.messageCount
+  };
+}
+function appendMetricsLog(sessionId) {
+  try {
+    if (!fs2.existsSync(CACHE_DIR))
+      fs2.mkdirSync(CACHE_DIR, { recursive: true });
+    const logPath = path2.join(CACHE_DIR, "compact-metrics.jsonl");
+    const entry = { ts: new Date().toISOString(), sessionId, ...getMetricsSummary() };
+    fs2.appendFileSync(logPath, JSON.stringify(entry) + `
+`);
+  } catch {}
+}
+
+// src/utils/extraction.ts
+import path3 from "path";
+
+// src/types.ts
+function isToolCallBlock(c) {
+  return typeof c === "object" && c !== null && c.type === "toolCall" && typeof c.name === "string";
+}
+function getToolCallNames(content) {
+  if (!Array.isArray(content))
+    return [];
+  return content.filter(isToolCallBlock).map((b) => b.name);
+}
+function filterToolCalls(content) {
+  if (!Array.isArray(content))
+    return [];
+  return content.filter(isToolCallBlock);
+}
+
+// src/utils/extraction.ts
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content))
+    return content.map((b) => {
+      if (typeof b === "string")
+        return b;
+      if (b?.type === "text")
+        return b.text ?? "";
+      return "";
+    }).join("");
+  return "";
+}
+function buildToolCallIndex(msgs) {
+  const idx = new Map;
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    if (m.role !== "assistant")
+      continue;
+    const blocks = Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (isToolCallBlock(b) && b.id) {
+        idx.set(b.id, { name: b.name, arguments: b.arguments, msgIndex: i });
+      }
+    }
+  }
+  return idx;
+}
+function trackFileOps(msgs) {
+  const tcIdx = buildToolCallIndex(msgs);
+  const modMap = new Map;
+  const readSet = new Set;
+  const delSet = new Set;
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    if (m.role !== "toolResult" || m.isError)
+      continue;
+    const tc = tcIdx.get(m.toolCallId ?? "");
+    if (!tc)
+      continue;
+    const args = tc.arguments;
+    const filePath = args?.path ?? args?.file_path ?? args?.filePath;
+    if (!filePath)
+      continue;
+    const tool = tc.name.toLowerCase();
+    if (tool.includes("write") || tool.includes("edit")) {
+      const resultText = extractText(m.content);
+      if (!NO_OP_RE.test(resultText)) {
+        const existing = modMap.get(filePath);
+        modMap.set(filePath, { toolCalls: (existing?.toolCalls ?? 0) + 1, lastIdx: i });
+      }
+    } else if (tool.includes("delete") || tool.includes("remove")) {
+      delSet.add(filePath);
+    } else if (tool.includes("read")) {
+      readSet.add(filePath);
+    }
+  }
+  return {
+    modified: [...modMap.entries()].map(([p, d]) => ({ path: p, toolCalls: d.toolCalls, lastModifiedIndex: d.lastIdx })),
+    read: [...readSet],
+    deleted: [...delSet]
+  };
+}
+function catalogErrors(msgs) {
+  const tcIdx = buildToolCallIndex(msgs);
+  const errors = [];
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    if (m.role !== "toolResult")
+      continue;
+    const tc = tcIdx.get(m.toolCallId ?? "");
+    if (m.isError) {
+      errors.push({ index: i, tool: tc?.name ?? "unknown", message: extractText(m.content).slice(0, 500), retryAttempted: false, resolved: false });
+      continue;
+    }
+    if (tc?.name === "bash") {
+      const txt = extractText(m.content);
+      const isLikelyError = /(?:command not found|no such file|permission denied|syntax error|cannot find|module not found|compilation error|build failed|test failed)/i.test(txt);
+      if (isLikelyError && txt.length < 2000) {
+        errors.push({ index: i, tool: "bash", message: txt.slice(0, 300), retryAttempted: false, resolved: false });
+      }
+    }
+  }
+  for (const err of errors) {
+    for (let j = err.index + 1;j < Math.min(msgs.length, err.index + 6); j++) {
+      if (msgs[j]?.role === "assistant") {
+        const blocks = Array.isArray(msgs[j]?.content) ? msgs[j].content : [];
+        for (const b of blocks) {
+          if (isToolCallBlock(b) && b.name === err.tool) {
+            err.retryAttempted = true;
+            for (let k = j + 1;k < Math.min(msgs.length, j + 10); k++) {
+              if (msgs[k]?.role === "toolResult" && msgs[k]?.toolCallId === b.id && !msgs[k]?.isError) {
+                err.resolved = true;
+                break;
+              }
+            }
+            break;
+          }
+        }
+        if (err.retryAttempted)
+          break;
+      }
+    }
+  }
+  return errors;
+}
+function extractDecisions(msgs) {
+  const tcIdx = buildToolCallIndex(msgs);
+  const decisions = [];
+  for (const [id, tc] of tcIdx) {
+    if (tc.name !== "ask_user")
+      continue;
+    const args = tc.arguments;
+    const question = typeof args === "string" ? args : args?.question ?? args?.prompt ?? "";
+    if (!question)
+      continue;
+    for (let i = tc.msgIndex + 1;i < Math.min(msgs.length, tc.msgIndex + 4); i++) {
+      if (msgs[i]?.role === "toolResult" && msgs[i]?.toolCallId === id) {
+        decisions.push({ index: tc.msgIndex, type: "explicit", summary: question.slice(0, 200), userResponse: extractText(msgs[i].content).slice(0, 300) });
+        break;
+      }
+    }
+  }
+  for (let i = 0;i < msgs.length; i++) {
+    if (msgs[i]?.role !== "user")
+      continue;
+    const txt = extractText(msgs[i].content);
+    if (CHOICE_RE.test(txt)) {
+      decisions.push({ index: i, type: "implicit", summary: txt.slice(0, 200) });
+    }
+  }
+  return decisions;
+}
+var CONSTRAINT_PATTERNS = [
+  { re: /\b(?:must|need|require|has to|important)\b.*\b(?:be|use|have|include|support)\b/i, cat: "requirement", conf: 0.85 },
+  { re: /\b(?:don't|never|avoid|shouldn't|must not|do not|no\s+(?:need|want))\b/i, cat: "prohibition", conf: 0.8 },
+  { re: /\b(?:prefer|like|want|would rather|should)\b.*\b(?:use|be|have|with)\b/i, cat: "preference", conf: 0.6 },
+  { re: /\b(?:kritik|kritikal|\u00f6nemli|onemli|\u015fart|sart|zorunlu|\u015fart ko\u015ful|\u00f6nemli \u015fart|kesinlikle|kesinlikle \u015fart|asla|sak\u0131n|sak\u0131nha|bunu yapma|b\u00f6yle olsun|b\u00f6yle yap\u0131n|\u015f\u00f6yle olsun|\u015f\u00f6yle yap\u0131n)\b/iu, cat: "requirement", conf: 0.8 },
+  { re: /\b(?:yapma|kullanma|sak\u0131n|asla\s+(?:kullanma|yapma|getirme))\b/iu, cat: "prohibition", conf: 0.8 },
+  { re: /\b(?:tercih|isterim|olsun|kullanal\u0131m|yapal\u0131m|istiyorum)\b/iu, cat: "preference", conf: 0.6 }
+];
+function mineConstraints(msgs) {
+  const constraints = [];
+  for (let i = 0;i < msgs.length; i++) {
+    if (msgs[i]?.role !== "user")
+      continue;
+    const txt = extractText(msgs[i].content);
+    if (txt.length < 10 || txt.startsWith("/"))
+      continue;
+    for (const { re, cat, conf } of CONSTRAINT_PATTERNS) {
+      if (re.test(txt)) {
+        constraints.push({ index: i, text: txt.slice(0, 300), category: cat, confidence: conf });
+        break;
+      }
+    }
+  }
+  return constraints;
+}
+function segmentTopicsHeuristic(msgs, pc, maxSegs = 20) {
+  const topics = [];
+  let startIdx = 0, tokenAcc = 0, lastFile = null, errAcc = 0;
+  const tcIdx = buildToolCallIndex(msgs);
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    const txt = extractText(m.content);
+    tokenAcc += estimateTokens(txt);
+    let brk = false;
+    let type = "exploration";
+    let primaryFile = null;
+    if (m.role === "assistant") {
+      const blocks = Array.isArray(m.content) ? m.content : [];
+      for (const b of blocks) {
+        if (isToolCallBlock(b)) {
+          const fp = b.arguments?.path ?? b.arguments?.file_path;
+          if (fp) {
+            const fn = path3.basename(fp);
+            if (lastFile && fn !== lastFile && tokenAcc > pc.minChunkTokens)
+              brk = true;
+            lastFile = fn;
+            primaryFile = fp;
+            if (b.name?.includes("write") || b.name?.includes("edit"))
+              type = "implementation";
+            else if (b.name?.includes("read"))
+              type = "review";
+          }
+        }
+      }
+    }
+    if (m.role === "toolResult" && m.isError) {
+      errAcc++;
+      type = "debugging";
+    }
+    if (m.role === "toolResult" && !m.isError) {
+      const tc = tcIdx.get(m.toolCallId ?? "");
+      if (tc?.name === "bash" && /error|fail/i.test(txt)) {
+        errAcc++;
+        type = "debugging";
+      }
+    }
+    if (m.role === "user" && SHIFT_RE.test(txt) && tokenAcc > pc.minChunkTokens)
+      brk = true;
+    if (tokenAcc >= pc.maxChunkTokens)
+      brk = true;
+    if (brk && i > startIdx && topics.length < maxSegs - 1) {
+      topics.push({ startIndex: startIdx, endIndex: i, primaryFile, type, errorDensity: errAcc });
+      startIdx = i + 1;
+      tokenAcc = 0;
+      lastFile = null;
+      errAcc = 0;
+    }
+  }
+  if (startIdx < msgs.length) {
+    topics.push({ startIndex: startIdx, endIndex: msgs.length - 1, primaryFile: null, type: "exploration", errorDensity: errAcc });
+  }
+  return topics;
+}
+function buildTimeline(msgs, errors) {
+  const timeline = [];
+  const errorIndices = new Set(errors.map((e) => e.index));
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    if (m.role === "user") {
+      const txt = extractText(m.content);
+      if (!txt.startsWith("/"))
+        timeline.push({ index: i, event: "user_request", summary: txt.slice(0, 150) });
+    }
+    if (errorIndices.has(i))
+      timeline.push({ index: i, event: "error", summary: errors.find((e) => e.index === i)?.message.slice(0, 100) ?? "error" });
+  }
+  return timeline.length > 30 ? [...timeline.filter((t) => t.event === "user_request").slice(0, 10), ...timeline.filter((t) => t.event === "error")] : timeline;
+}
+function extractMainGoal(msgs) {
+  for (const m of msgs) {
+    if (m?.role !== "user")
+      continue;
+    const txt = extractText(m.content).trim();
+    if (txt && !txt.startsWith("/"))
+      return txt.slice(0, 300);
+  }
+  return null;
+}
+function extractOpenLoops(msgs, extraction) {
+  const loops = [];
+  let loopId = 0;
+  for (const err of extraction.errors.filter((e) => !e.resolved)) {
+    const errFiles = extraction.modifiedFiles.filter((f) => err.message.toLowerCase().includes(f.path.split("/").pop()?.toLowerCase() ?? "__none__")).map((f) => f.path);
+    loops.push({
+      id: "loop-" + ++loopId,
+      type: "bugfix",
+      priority: err.retryAttempted ? "high" : "normal",
+      status: "open",
+      summary: err.message.slice(0, 120),
+      files: errFiles,
+      sourceIndex: err.index
+    });
+  }
+  const FOLLOWUP_RE = /(?:next\s+(?:step|thing)|todo|action item|follow\s*up|still (?:need|have) to|gotta|gotta|yapalim|yapmamiz|gerekiyor|eklenecek|d\u00FCzeltilecek|bitmedi|kaldi)/i;
+  for (const msg of msgs) {
+    if (msg.role !== "user")
+      continue;
+    const txt = extractText(msg.content);
+    if (txt.length < 10 || txt.startsWith("/"))
+      continue;
+    if (FOLLOWUP_RE.test(txt)) {
+      const idx = msgs.indexOf(msg);
+      const isDup = loops.some((l) => Math.abs((l.sourceIndex ?? 0) - idx) < 5);
+      if (!isDup) {
+        loops.push({
+          id: "loop-" + ++loopId,
+          type: "follow-up",
+          priority: "normal",
+          status: "open",
+          summary: txt.slice(0, 120),
+          files: [],
+          sourceIndex: idx
+        });
+      }
+    }
+  }
+  const BLOCKED_RE = /blocked|waiting for|depend|ba[\u011Fg]li|bekliyor|engell/i;
+  for (const msg of msgs) {
+    if (msg.role !== "user")
+      continue;
+    const txt = extractText(msg.content);
+    if (BLOCKED_RE.test(txt)) {
+      const idx = msgs.indexOf(msg);
+      const isDup = loops.some((l) => Math.abs((l.sourceIndex ?? 0) - idx) < 5);
+      if (!isDup) {
+        loops.push({
+          id: "loop-" + ++loopId,
+          type: "blocked",
+          priority: "high",
+          status: "open",
+          summary: txt.slice(0, 120),
+          files: [],
+          sourceIndex: idx
+        });
+      }
+    }
+  }
+  for (const err of extraction.errors.filter((e) => e.retryAttempted && !e.resolved)) {
+    const exists = loops.some((l) => l.type === "bugfix" && l.sourceIndex === err.index);
+    if (!exists) {
+      loops.push({
+        id: "loop-" + ++loopId,
+        type: "retry",
+        priority: "high",
+        status: "open",
+        summary: "Retried but unresolved: " + err.message.slice(0, 80),
+        files: [],
+        sourceIndex: err.index
+      });
+    }
+  }
+  return loops;
+}
+function extractStructured(msgs, pc) {
+  const { modified, read, deleted } = trackFileOps(msgs);
+  const errors = catalogErrors(msgs);
+  const decisions = extractDecisions(msgs);
+  const constraints = mineConstraints(msgs);
+  const topics = segmentTopicsHeuristic(msgs, pc);
+  const timeline = buildTimeline(msgs, errors);
+  const mainGoal = extractMainGoal(msgs);
+  const lastUserMessages = msgs.filter((m) => m.role === "user").slice(-5).map((m) => extractText(m.content));
+  const lastErrors = errors.slice(-3).map((e) => e.message);
+  return {
+    modifiedFiles: modified,
+    readFiles: read,
+    deletedFiles: deleted,
+    errors,
+    decisions,
+    constraints,
+    topics,
+    timeline,
+    mainGoal,
+    lastUserMessages,
+    lastErrors,
+    messageCount: msgs.length
+  };
+}
+
+// src/utils/state.ts
+import fs3 from "fs";
+import path4 from "path";
+var STATE_DIR = path4.join(process.env.HOME ?? "/tmp", ".pi", "agent", ".cache", "smart-compact", "states");
+function getStatePath(projectId) {
+  return path4.join(STATE_DIR, projectId + ".json");
+}
+function saveCompactionState(projectId, state) {
+  try {
+    if (!fs3.existsSync(STATE_DIR))
+      fs3.mkdirSync(STATE_DIR, { recursive: true });
+    fs3.writeFileSync(getStatePath(projectId), JSON.stringify(state, null, 2));
+  } catch {}
+}
+function loadCompactionState(projectId) {
+  try {
+    const fp = getStatePath(projectId);
+    if (!fs3.existsSync(fp))
+      return null;
+    const data = JSON.parse(fs3.readFileSync(fp, "utf8"));
+    if (data.compactionVersion && Date.now() - 0 > 7 * 24 * 60 * 60 * 1000) {}
+    return data;
+  } catch {
+    return null;
+  }
+}
+function buildCompactionState(extraction, openLoops, report, nextActions, criticalContext) {
+  let decisionId = 0;
+  let constraintId = 0;
+  let errorId = 0;
+  return {
+    goal: extraction.mainGoal,
+    decisions: extraction.decisions.map((d) => ({
+      id: "decision-" + ++decisionId,
+      summary: d.summary.slice(0, 200),
+      ...d.userResponse ? { userResponse: d.userResponse.slice(0, 300) } : {},
+      type: d.type
+    })),
+    constraints: extraction.constraints.map((c) => ({
+      id: "constraint-" + ++constraintId,
+      text: c.text.slice(0, 300),
+      category: c.category,
+      confidence: c.confidence
+    })),
+    modifiedFiles: extraction.modifiedFiles.map((f) => f.path),
+    readFiles: extraction.readFiles,
+    deletedFiles: extraction.deletedFiles,
+    unresolvedErrors: extraction.errors.filter((e) => !e.resolved).map((e) => {
+      const bn = extraction.modifiedFiles.find((f) => e.message.toLowerCase().includes(f.path.split("/").pop()?.toLowerCase() ?? "__none__"));
+      return {
+        id: "error-" + ++errorId,
+        message: e.message.slice(0, 300),
+        tool: e.tool,
+        files: bn ? [bn.path] : []
+      };
+    }),
+    resolvedErrors: extraction.errors.filter((e) => e.resolved).map((e) => ({
+      id: "error-" + ++errorId,
+      message: e.message.slice(0, 300),
+      tool: e.tool
+    })),
+    openLoops,
+    topics: extraction.topics.map((t, i) => ({
+      title: t.primaryFile ? t.primaryFile.split("/").pop() + " (" + t.type + ")" : "Topic " + (i + 1),
+      type: t.type,
+      priority: t.errorDensity > 2 ? "high" : "normal"
+    })),
+    nextActions,
+    criticalContext,
+    sessionType: report?.sessionType ?? "implementation",
+    compactionVersion: VERSION
+  };
+}
+function injectOpenLoopsSection(summary, openLoops) {
+  if (!openLoops.length)
+    return summary;
+  const lines = [
+    "## Open Loops",
+    "",
+    ...openLoops.map((l) => {
+      const prio = l.priority === "critical" || l.priority === "high" ? "[" + l.priority + "] " : "";
+      const files = l.files.length ? " \u2014 " + l.files.join(", ") : "";
+      return "- " + prio + l.summary + files;
+    }),
+    ""
+  ];
+  const nextStepsIdx = summary.indexOf("## Next Steps");
+  if (nextStepsIdx >= 0) {
+    return summary.slice(0, nextStepsIdx) + lines.join(`
+`) + summary.slice(nextStepsIdx);
+  }
+  return summary + `
+` + lines.join(`
+`);
+}
+function computeDelta(prev, current) {
+  const prevDecisionTexts = new Set(prev.decisions.map((d) => d.summary.toLowerCase().slice(0, 60)));
+  const currDecisionTexts = new Set(current.decisions.map((d) => d.summary.toLowerCase().slice(0, 60)));
+  const newDecisions = current.decisions.filter((d) => !prevDecisionTexts.has(d.summary.toLowerCase().slice(0, 60))).map((d) => d.summary);
+  const removedDecisions = prev.decisions.filter((d) => !currDecisionTexts.has(d.summary.toLowerCase().slice(0, 60))).map((d) => d.summary);
+  const prevLoopSummaries = new Map(prev.openLoops.map((l) => [l.summary.toLowerCase().slice(0, 50), l]));
+  const currLoopSummaries = new Map(current.openLoops.map((l) => [l.summary.toLowerCase().slice(0, 50), l]));
+  const resolvedLoops = [];
+  const persistentLoops = [];
+  for (const [key, loop] of prevLoopSummaries) {
+    if (currLoopSummaries.has(key)) {
+      persistentLoops.push(loop.summary);
+    } else {
+      resolvedLoops.push(loop.summary);
+    }
+  }
+  const newLoops = current.openLoops.filter((l) => !prevLoopSummaries.has(l.summary.toLowerCase().slice(0, 50))).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) => e.message.toLowerCase().slice(0, 40)));
+  const currErrorMsgs = new Set(current.unresolvedErrors.map((e) => e.message.toLowerCase().slice(0, 40)));
+  const resolvedErrors = prev.unresolvedErrors.filter((e) => !currErrorMsgs.has(e.message.toLowerCase().slice(0, 40))).map((e) => e.message);
+  const newErrors = current.unresolvedErrors.filter((e) => !prevErrorMsgs.has(e.message.toLowerCase().slice(0, 40))).map((e) => e.message);
+  const goalChanged = prev.goal !== current.goal && prev.goal !== null && current.goal !== null;
+  return {
+    newDecisions,
+    removedDecisions,
+    resolvedLoops,
+    persistentLoops,
+    newLoops,
+    newModifiedFiles,
+    resolvedErrors,
+    newErrors,
+    goalChanged,
+    previousGoal: goalChanged ? prev.goal : null
+  };
+}
+function formatDeltaSection(delta) {
+  const lines = ["## Changes Since Last Compaction", ""];
+  if (delta.goalChanged) {
+    lines.push("- **Goal shifted**: " + (delta.previousGoal ?? "?") + " \u2192 see current goal above");
+  }
+  if (delta.resolvedLoops.length) {
+    lines.push("- **Resolved loops**: " + delta.resolvedLoops.map((s) => "~~" + s.slice(0, 60) + "~~").join(", "));
+  }
+  if (delta.persistentLoops.length) {
+    lines.push("- **Still open**: " + delta.persistentLoops.map((s) => s.slice(0, 60)).join("; "));
+  }
+  if (delta.newLoops.length) {
+    lines.push("- **New loops**: " + delta.newLoops.map((s) => s.slice(0, 60)).join("; "));
+  }
+  if (delta.newDecisions.length) {
+    lines.push("- **New decisions**: " + delta.newDecisions.map((s) => s.slice(0, 80)).join("; "));
+  }
+  if (delta.resolvedErrors.length) {
+    lines.push("- **Resolved errors**: " + delta.resolvedErrors.map((s) => s.slice(0, 60)).join("; "));
+  }
+  if (delta.newErrors.length) {
+    lines.push("- **New errors**: " + delta.newErrors.map((s) => s.slice(0, 60)).join("; "));
+  }
+  if (delta.newModifiedFiles.length) {
+    lines.push("- **New files touched**: " + delta.newModifiedFiles.join(", "));
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function injectDeltaSection(summary, delta) {
+  const section = formatDeltaSection(delta);
+  const hasChanges = delta.goalChanged || delta.resolvedLoops.length > 0 || delta.newLoops.length > 0 || delta.newDecisions.length > 0 || delta.newErrors.length > 0 || delta.newModifiedFiles.length > 0;
+  if (!hasChanges)
+    return summary;
+  const openLoopsIdx = summary.indexOf("## Open Loops");
+  const nextStepsIdx = summary.indexOf("## Next Steps");
+  if (openLoopsIdx >= 0) {
+    const afterOL = summary.indexOf("## ", openLoopsIdx + 1);
+    if (afterOL >= 0) {
+      return summary.slice(0, afterOL) + section + summary.slice(afterOL);
+    }
+  }
+  if (nextStepsIdx >= 0) {
+    return summary.slice(0, nextStepsIdx) + section + summary.slice(nextStepsIdx);
+  }
+  return summary + `
+` + section;
+}
+function extractNextActions(summary) {
+  const match = summary.match(/## Next Steps\s*\n([\s\S]*?)(?=##|$)/);
+  if (!match)
+    return [];
+  return match[1].split(`
+`).map((l) => l.replace(/^\d+\.\s*/, "").trim()).filter((l) => l.length > 0);
+}
+function extractCriticalContext(summary) {
+  const match = summary.match(/## Critical Context\s*\n([\s\S]*?)(?=##|$)/);
+  if (!match)
+    return [];
+  return match[1].split(`
+`).map((l) => l.replace(/^-\s*/, "").trim()).filter((l) => l.length > 0);
+}
+
+// src/utils/pruning.ts
+var ACK_RE = /^(?:I'?ll |let me |sure|ok[,.]?|got it|i understand|i see|now i|next,? i|alright|great|perfect|sounds good|i can|i will|checking|looking|right away)/i;
+var MAX_TOOL_OUTPUT_CHARS = 800;
+function pruneRedundant(msgs) {
+  if (msgs.length < 5)
+    return { messages: msgs, prunedCount: 0, prunedTokenSaving: 0, reasons: [] };
+  const tcIdx = buildToolCallIndex(msgs);
+  const keep = new Set(msgs.map((_, i2) => i2));
+  const reasonMap = new Map;
+  const readIndices = new Map;
+  for (let i2 = 0;i2 < msgs.length; i2++) {
+    if (msgs[i2].role !== "toolResult")
+      continue;
+    const tc = tcIdx.get(msgs[i2].toolCallId ?? "");
+    if (!tc || tc.name !== "read")
+      continue;
+    const fp = tc?.arguments?.path ?? tc?.arguments?.file_path;
+    if (!fp)
+      continue;
+    const arr = readIndices.get(fp) ?? [];
+    arr.push(i2);
+    readIndices.set(fp, arr);
+  }
+  for (const [fp, indices] of readIndices) {
+    for (let j = 0;j < indices.length - 1; j++) {
+      keep.delete(indices[j]);
+      const tc = tcIdx.get(msgs[indices[j]].toolCallId ?? "");
+      if (tc)
+        keep.delete(tc.msgIndex);
+    }
+    if (indices.length > 1) {
+      reasonMap.set("Duplicate file reads", (reasonMap.get("Duplicate file reads") ?? 0) + indices.length - 1);
+    }
+  }
+  const failedToolResults = [];
+  for (let i2 = 0;i2 < msgs.length; i2++) {
+    if (msgs[i2].role !== "toolResult" || !msgs[i2].isError)
+      continue;
+    const tc = tcIdx.get(msgs[i2].toolCallId ?? "");
+    failedToolResults.push({ index: i2, tool: tc?.name ?? "unknown", tcIndex: tc?.msgIndex ?? -1 });
+  }
+  let i = 0;
+  while (i < failedToolResults.length) {
+    const tool = failedToolResults[i].tool;
+    let j = i + 1;
+    while (j < failedToolResults.length && failedToolResults[j].tool === tool && failedToolResults[j].index - failedToolResults[j - 1].index < 10) {
+      j++;
+    }
+    if (j - i >= 3) {
+      for (let k = i + 1;k < j - 1; k++) {
+        keep.delete(failedToolResults[k].index);
+        if (failedToolResults[k].tcIndex >= 0)
+          keep.delete(failedToolResults[k].tcIndex);
+      }
+      reasonMap.set("Collapsed error chains", (reasonMap.get("Collapsed error chains") ?? 0) + (j - i - 2));
+    }
+    i = j;
+  }
+  for (let idx = 0;idx < msgs.length; idx++) {
+    if (msgs[idx].role !== "assistant")
+      continue;
+    const blocks = Array.isArray(msgs[idx].content) ? msgs[idx].content : [];
+    const hasToolCall = blocks.some((b) => isToolCallBlock(b));
+    if (hasToolCall)
+      continue;
+    const text = extractText(msgs[idx].content).trim();
+    if (text.length > 0 && text.length < 100 && ACK_RE.test(text)) {
+      keep.delete(idx);
+      reasonMap.set("Agent acknowledgments", (reasonMap.get("Agent acknowledgments") ?? 0) + 1);
+    }
+  }
+  const kept = msgs.map((m, idx) => {
+    if (!keep.has(idx))
+      return null;
+    if (m.role !== "toolResult")
+      return m;
+    const text = extractText(m.content);
+    if (text.length > MAX_TOOL_OUTPUT_CHARS) {
+      const head = text.slice(0, 400);
+      const tail = text.slice(-400);
+      const truncated = head + `
+... [truncated ` + (text.length - 800) + ` chars] ...
+` + tail;
+      return { ...m, content: [{ type: "text", text: truncated }] };
+    }
+    return m;
+  });
+  const finalMsgs = kept.filter((m) => m !== null);
+  const prunedCount = msgs.length - finalMsgs.length;
+  const originalTokens = estimateTokens(msgs.map((m) => extractText(m.content)).join(""));
+  const prunedTokens = estimateTokens(finalMsgs.map((m) => extractText(m.content)).join(""));
+  const reasons = [...reasonMap.entries()].map(([reason, count]) => ({ count, reason }));
+  return {
+    messages: finalMsgs,
+    prunedCount,
+    prunedTokenSaving: Math.max(0, originalTokens - prunedTokens),
+    reasons
+  };
+}
+
+// src/utils/fingerprint.ts
+import fs4 from "fs";
+import path5 from "path";
+var FINGERPRINT_DIR = path5.join(process.env.HOME ?? "/tmp", ".pi", "agent", ".cache", "smart-compact", "projects");
+var LANG_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".rs": "rust",
+  ".py": "python",
+  ".go": "go",
+  ".java": "java",
+  ".rb": "ruby",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".php": "php"
+};
+var FRAMEWORK_SIGNALS = [
+  { pattern: /next\.config/i, framework: "nextjs" },
+  { pattern: /nuxt\.config/i, framework: "nuxt" },
+  { pattern: /vite\.config/i, framework: "vite" },
+  { pattern: /astro\.config/i, framework: "astro" },
+  { pattern: /tailwind\.config/i, framework: "tailwind" },
+  { pattern: /django/i, framework: "django" },
+  { pattern: /flask/i, framework: "flask" },
+  { pattern: /cargo\.toml/i, framework: "cargo" },
+  { pattern: /go\.mod/i, framework: "go-modules" },
+  { pattern: /Gemfile/i, framework: "bundler" },
+  { pattern: /package\.json/i, framework: "node" }
+];
+function getFingerprintPath(projectId) {
+  return path5.join(FINGERPRINT_DIR, projectId + ".json");
+}
+function deriveProjectId(extraction) {
+  const allPaths = [
+    ...extraction.modifiedFiles.map((f) => f.path),
+    ...extraction.readFiles
+  ];
+  if (!allPaths.length)
+    return "unknown";
+  const roots = new Map;
+  for (const p of allPaths) {
+    const parts = p.split("/");
+    const root = parts.length > 1 ? parts.slice(0, Math.min(2, parts.length - 1)).join("/") : "root";
+    roots.set(root, (roots.get(root) ?? 0) + 1);
+  }
+  const topRoot = [...roots.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "unknown";
+  let hash = 0;
+  for (let i = 0;i < topRoot.length; i++) {
+    hash = (hash << 5) - hash + topRoot.charCodeAt(i) | 0;
+  }
+  return "proj-" + Math.abs(hash).toString(36);
+}
+function detectLanguage(extraction) {
+  const extCounts = new Map;
+  for (const f of extraction.modifiedFiles) {
+    const ext = path5.extname(f.path).toLowerCase();
+    if (ext && LANG_MAP[ext]) {
+      extCounts.set(LANG_MAP[ext], (extCounts.get(LANG_MAP[ext]) ?? 0) + 1);
+    }
+  }
+  for (const f of extraction.readFiles) {
+    const ext = path5.extname(f).toLowerCase();
+    if (ext && LANG_MAP[ext]) {
+      extCounts.set(LANG_MAP[ext], (extCounts.get(LANG_MAP[ext]) ?? 0) + 1);
+    }
+  }
+  if (!extCounts.size)
+    return "unknown";
+  return [...extCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+function detectFramework(extraction) {
+  const allPaths = extraction.readFiles.join(" ") + " " + extraction.modifiedFiles.map((f) => f.path).join(" ");
+  for (const { pattern, framework } of FRAMEWORK_SIGNALS) {
+    if (pattern.test(allPaths))
+      return framework;
+  }
+  return null;
+}
+function extractKeyDirs(extraction, maxDirs = 8) {
+  const dirCounts = new Map;
+  for (const f of extraction.modifiedFiles) {
+    const parts = f.path.split("/");
+    if (parts.length > 1) {
+      const dir = parts.slice(0, -1).join("/");
+      dirCounts.set(dir, (dirCounts.get(dir) ?? 0) + 1);
+    }
+  }
+  return [...dirCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, maxDirs).map(([d]) => d);
+}
+function loadProjectFingerprint(projectId) {
+  try {
+    const fp = getFingerprintPath(projectId);
+    if (!fs4.existsSync(fp))
+      return null;
+    const data = JSON.parse(fs4.readFileSync(fp, "utf8"));
+    if (Date.now() - data.updatedAt > 30 * 24 * 60 * 60 * 1000)
+      return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveProjectFingerprint(projectId, extraction) {
+  try {
+    if (!fs4.existsSync(FINGERPRINT_DIR))
+      fs4.mkdirSync(FINGERPRINT_DIR, { recursive: true });
+    const existing = loadProjectFingerprint(projectId);
+    const newKnownFiles = [...new Set([
+      ...existing?.knownFiles ?? [],
+      ...extraction.modifiedFiles.map((f) => f.path),
+      ...extraction.readFiles
+    ])].slice(-50);
+    const fingerprint = {
+      id: projectId,
+      language: existing?.language ?? detectLanguage(extraction),
+      framework: existing?.framework ?? detectFramework(extraction),
+      keyDirectories: extractKeyDirs(extraction),
+      knownFiles: newKnownFiles,
+      sessionCount: (existing?.sessionCount ?? 0) + 1,
+      updatedAt: Date.now()
+    };
+    fs4.writeFileSync(getFingerprintPath(projectId), JSON.stringify(fingerprint, null, 2));
+  } catch {}
+}
+function buildProjectContext(fingerprint) {
+  if (!fingerprint)
+    return "";
+  return [
+    "## Project Context (learned from " + fingerprint.sessionCount + " session(s))",
+    "Language: " + fingerprint.language,
+    fingerprint.framework ? "Framework: " + fingerprint.framework : "",
+    fingerprint.keyDirectories.length ? "Key dirs: " + fingerprint.keyDirectories.join(", ") : ""
+  ].filter(Boolean).join(`
+`);
+}
+
+// src/utils/damage.ts
+import fs5 from "fs";
+import path6 from "path";
+var COMPLAINT_PATTERNS = [
+  /(?:I already (?:told|said|mentioned|explained) you|(?:we|I) (?:already|just) (?:discussed|went over|covered) this|you forgot|you lost|nerede kald\u0131|hat\u0131rlam\u0131yor|unuttun)/i,
+  /(?:that'?s? not (?:what I|right)|that'?s? wrong|yanl\u0131\u015F|hay\u0131r de\u011Fil|no that'|that doesn'?t match)/i,
+  /(?:go back to|return to|(?:look|check) again|tekrar bak|geri d\u00F6n)/i
+];
+function detectDamage(postMessages, details) {
+  const signals = [];
+  const compactedFiles = new Set(details.modifiedFiles.map((f) => f.toLowerCase()));
+  const compactedReadFiles = new Set(details.readFiles.map((f) => f.toLowerCase()));
+  for (let i = 0;i < postMessages.length; i++) {
+    const msg = postMessages[i];
+    const text = extractText(msg.content).toLowerCase();
+    if (msg.role === "assistant") {
+      const blocks = Array.isArray(msg.content) ? msg.content : [];
+      for (const b of blocks) {
+        if (isToolCallBlock(b) && (b.name === "read" || b.name === "bash")) {
+          const fp = b.arguments?.path ?? b.arguments?.file_path;
+          if (fp) {
+            const fpLower = fp.toLowerCase();
+            if (compactedFiles.has(fpLower) || compactedReadFiles.has(fpLower)) {
+              signals.push({
+                type: "re-read",
+                severity: "medium",
+                detail: "Agent re-read compacted file: " + fp
+              });
+            }
+          }
+        }
+      }
+    }
+    if (msg.role === "user") {
+      for (const pattern of COMPLAINT_PATTERNS) {
+        if (pattern.test(text)) {
+          signals.push({
+            type: "user-complaint",
+            severity: "high",
+            detail: 'User complaint after compaction: "' + text.slice(0, 100) + '"'
+          });
+          break;
+        }
+      }
+      for (const t of details.topics) {
+        const topicWords = t.toLowerCase().split(/\s+/).filter((w) => w.length > 4).slice(0, 3);
+        if (topicWords.length >= 2 && topicWords.some((w) => text.includes(w))) {
+          signals.push({
+            type: "re-question",
+            severity: "low",
+            detail: "User mentions compacted topic: " + t.slice(0, 80)
+          });
+        }
+      }
+    }
+  }
+  let damageScore = 0;
+  for (const s of signals) {
+    if (s.severity === "high")
+      damageScore += 25;
+    else if (s.severity === "medium")
+      damageScore += 10;
+    else
+      damageScore += 3;
+  }
+  damageScore = Math.min(100, damageScore);
+  const parts = [];
+  const reReads = signals.filter((s) => s.type === "re-read").length;
+  const complaints = signals.filter((s) => s.type === "user-complaint").length;
+  const reQuestions = signals.filter((s) => s.type === "re-question").length;
+  if (reReads)
+    parts.push(reReads + " re-read(s)");
+  if (complaints)
+    parts.push(complaints + " user complaint(s)");
+  if (reQuestions)
+    parts.push(reQuestions + " re-question(s)");
+  return {
+    signals,
+    damageScore,
+    summary: parts.length ? "Damage score: " + damageScore + "/100 \u2014 " + parts.join(", ") : "No regression signals detected (score: 0)"
+  };
+}
+function logDamageReport(sessionId, report, details) {
+  try {
+    const dir = path6.join(process.env.HOME ?? "/tmp", ".pi", "agent", ".cache", "smart-compact");
+    if (!fs5.existsSync(dir))
+      fs5.mkdirSync(dir, { recursive: true });
+    const logPath = path6.join(dir, "damage-reports.jsonl");
+    const entry = {
+      ts: new Date().toISOString(),
+      sessionId,
+      method: details.method,
+      profile: details.profile,
+      qualityScore: details.qualityScore,
+      damageScore: report.damageScore,
+      signals: report.signals.length,
+      summary: report.summary
+    };
+    fs5.appendFileSync(logPath, JSON.stringify(entry) + `
+`);
+  } catch {}
+}
+
+// src/phases/explore.ts
+var _toolSupportCache = new Map;
+var TOOL_CACHE_TTL = 30 * 60 * 1000;
+function shouldExplore(extraction) {
+  const unresolvedErrors = extraction.errors.filter((e) => !e.resolved).length;
+  const topicCount = extraction.topics.length;
+  const decisionCount = extraction.decisions.length;
+  const crossFileWork = new Set(extraction.modifiedFiles.map((f) => {
+    const parts = f.path.split("/");
+    return parts.length > 1 ? parts.slice(0, -1).join("/") : "root";
+  })).size;
+  if (topicCount <= 3 && unresolvedErrors <= 1 && decisionCount <= 2 && crossFileWork <= 2) {
+    return false;
+  }
+  return true;
+}
+var EXPLORATION_TOOLS = [
+  {
+    name: "get_message_range",
+    description: "Get compact summaries of messages from start to end index (0-based).",
+    parameters: { type: "object", properties: { start: { type: "number" }, end: { type: "number" } }, required: ["start", "end"] }
+  },
+  {
+    name: "search_conversation",
+    description: "Search for text in conversation messages.",
+    parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] }
+  },
+  {
+    name: "get_recent_user_messages",
+    description: "Get the last N user messages.",
+    parameters: { type: "object", properties: { count: { type: "number" } } }
+  },
+  {
+    name: "get_context_around",
+    description: "Get context around a specific message index.",
+    parameters: { type: "object", properties: { index: { type: "number" }, radius: { type: "number" } }, required: ["index"] }
+  },
+  {
+    name: "get_file_changes",
+    description: "Get tool calls that modified a specific file.",
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] }
+  },
+  {
+    name: "get_error_chain",
+    description: "Get all messages related to a specific error.",
+    parameters: { type: "object", properties: { index: { type: "number" }, context_radius: { type: "number" } }, required: ["index"] }
+  }
+];
+function executeExplorationTool(call, llmMessages) {
+  const args = call.arguments ?? {};
+  switch (call.name) {
+    case "get_message_range": {
+      const s = args.start ?? 0, e = Math.min(args.end ?? llmMessages.length, llmMessages.length);
+      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+        idx: s + i,
+        role: m?.role,
+        preview: extractText(m?.content).slice(0, 150),
+        toolCalls: getToolCallNames(m?.content),
+        isError: m?.isError
+      })));
+    }
+    case "search_conversation": {
+      const q = (args.query ?? "").toLowerCase();
+      return JSON.stringify(llmMessages.filter((m) => JSON.stringify(m).toLowerCase().includes(q)).slice(0, 10).map((m) => ({
+        idx: llmMessages.indexOf(m),
+        role: m?.role,
+        preview: extractText(m?.content).slice(0, 150)
+      })));
+    }
+    case "get_recent_user_messages": {
+      const count = args.count ?? 10;
+      return JSON.stringify(llmMessages.filter((m) => m?.role === "user").slice(-count).map((m) => extractText(m.content)));
+    }
+    case "get_context_around": {
+      const idx = args.index ?? 0, radius = args.radius ?? 5;
+      const s = Math.max(0, idx - radius), e = Math.min(llmMessages.length, idx + radius + 1);
+      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+        idx: s + i,
+        role: m?.role,
+        text: extractText(m?.content).slice(0, 300),
+        toolCalls: getToolCallNames(m?.content),
+        isError: m?.isError
+      })));
+    }
+    case "get_file_changes": {
+      const target = (args.path ?? "").toLowerCase();
+      const results = [];
+      for (let i = 0;i < llmMessages.length; i++) {
+        const tcs = filterToolCalls(llmMessages[i]?.content);
+        for (const block of tcs) {
+          if (block.name === "edit" && JSON.stringify(block).toLowerCase().includes(target)) {
+            results.push({ idx: i, role: "assistant", toolCall: "edit", args: block.arguments, preview: extractText(llmMessages[i]?.content).slice(0, 400) });
+          }
+          if (block.name === "write" && JSON.stringify(block).toLowerCase().includes(target)) {
+            results.push({ idx: i, role: "assistant", toolCall: "write", preview: extractText(llmMessages[i]?.content).slice(0, 400) });
+          }
+        }
+      }
+      return JSON.stringify(results.slice(0, 15) || [{ info: "No edits found for: " + args.path }]);
+    }
+    case "get_error_chain": {
+      const errIdx = args.index ?? 0;
+      const ctxRadius = args.context_radius ?? 8;
+      const s = Math.max(0, errIdx - ctxRadius), e = Math.min(llmMessages.length, errIdx + ctxRadius + 1);
+      return JSON.stringify(llmMessages.slice(s, e).map((m, i) => ({
+        idx: s + i,
+        role: m?.role,
+        text: extractText(m?.content).slice(0, 500),
+        isError: m?.isError,
+        toolCalls: getToolCallNames(m?.content)
+      })));
+    }
+    default:
+      return "Unknown tool: " + call.name;
+  }
+}
+function parseExplorationReport(text, llmMessages) {
+  let json = text.trim();
+  const md = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (md)
+    json = md[1].trim();
+  let s = json.indexOf("{"), e = json.lastIndexOf("}");
+  if (s === -1 || e === -1)
+    return fallbackExplorationReport(llmMessages);
+  let rawJson = json.slice(s, e + 1);
+  try {
+    return buildExplorationReportFromParsed(JSON.parse(rawJson), llmMessages);
+  } catch {}
+  const cleaned = rawJson.replace(/,\s*([}\]])/g, "$1").replace(/'/g, '"').replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  try {
+    return buildExplorationReportFromParsed(JSON.parse(cleaned), llmMessages);
+  } catch {}
+  const boundaryMatch = rawJson.match(/"boundaries"\s*:\s*\[([\s\S]*?)\]/);
+  if (boundaryMatch) {
+    try {
+      const boundaries = JSON.parse("[" + boundaryMatch[1] + "]");
+      return { ...fallbackExplorationReport(llmMessages), boundaries: boundaries.filter((b) => typeof b?.afterIndex === "number").map((b) => ({
+        afterIndex: Math.min(b.afterIndex, llmMessages.length - 2),
+        topic: String(b.topic ?? "").slice(0, 100),
+        priority: ["critical", "high", "normal", "low"].includes(b.priority) ? b.priority : "normal",
+        confidence: Math.min(1, Math.max(0, b.confidence ?? 0.5))
+      })) };
+    } catch {}
+  }
+  return fallbackExplorationReport(llmMessages);
+}
+function buildExplorationReportFromParsed(parsed, llmMessages) {
+  return {
+    boundaries: (parsed.boundaries ?? []).filter((b) => typeof b?.afterIndex === "number").map((b) => ({
+      afterIndex: Math.min(b.afterIndex, llmMessages.length - 2),
+      topic: String(b.topic ?? "").slice(0, 100),
+      priority: ["critical", "high", "normal", "low"].includes(b.priority) ? b.priority : "normal",
+      confidence: Math.min(1, Math.max(0, b.confidence ?? 0.5))
+    })),
+    mainGoal: parsed.mainGoal ?? "",
+    sessionType: ["implementation", "review", "debugging", "discussion"].includes(parsed.sessionType) ? parsed.sessionType : "implementation",
+    enrichedConstraints: Array.isArray(parsed.enrichedConstraints) ? parsed.enrichedConstraints.map(String) : [],
+    crossReferences: Array.isArray(parsed.crossReferences) ? parsed.crossReferences.map(String) : [],
+    statusAssessment: {
+      done: Array.isArray(parsed.statusAssessment?.done) ? parsed.statusAssessment.done.map(String) : [],
+      inProgress: Array.isArray(parsed.statusAssessment?.inProgress) ? parsed.statusAssessment.inProgress.map(String) : [],
+      blocked: Array.isArray(parsed.statusAssessment?.blocked) ? parsed.statusAssessment.blocked.map(String) : []
+    },
+    criticalContext: Array.isArray(parsed.criticalContext) ? parsed.criticalContext.map(String) : [],
+    keyDecisions: Array.isArray(parsed.keyDecisions) ? parsed.keyDecisions.map(String) : []
+  };
+}
+function fallbackExplorationReport(llmMessages) {
+  return {
+    boundaries: [],
+    mainGoal: extractMainGoal(llmMessages) ?? "",
+    sessionType: "implementation",
+    enrichedConstraints: [],
+    crossReferences: [],
+    statusAssessment: { done: [], inProgress: [], blocked: [] },
+    criticalContext: [],
+    keyDecisions: []
+  };
+}
+async function exploreConversation(llmMessages, extraction, model, auth, prevSummary, userNote, signal, maxRounds = 8, notify) {
+  const extractionContext = [
+    "## Deterministic Extraction (verified facts)",
+    "Message count: " + extraction.messageCount,
+    "Main goal: " + (extraction.mainGoal ?? "unknown"),
+    "Files modified (" + extraction.modifiedFiles.length + "): " + (extraction.modifiedFiles.map((f) => f.path).join(", ") || "none"),
+    "Files read (" + extraction.readFiles.length + "): " + (extraction.readFiles.join(", ") || "none"),
+    "Errors (" + extraction.errors.length + "): " + (extraction.errors.map((e) => "[" + e.tool + "] " + e.message.slice(0, 80) + (e.resolved ? " (resolved)" : e.retryAttempted ? " (retry attempted)" : "")).join("; ") || "none"),
+    "Decisions (" + extraction.decisions.length + "): " + (extraction.decisions.map((d) => d.type + ": " + d.summary.slice(0, 80)).join("; ") || "none"),
+    "Constraints (" + extraction.constraints.length + "): " + (extraction.constraints.map((cc) => "[" + cc.category + "] " + cc.text.slice(0, 80)).join("; ") || "none"),
+    "Heuristic topics (" + extraction.topics.length + "): " + (extraction.topics.map((t) => "[" + t.startIndex + "-" + t.endIndex + "] " + t.type).join("; ") || "none"),
+    extraction.lastUserMessages.length ? "Last user messages: " + extraction.lastUserMessages.map((m) => m.slice(0, 100)).join(" | ") : "",
+    extraction.lastErrors.length ? "Last errors: " + extraction.lastErrors.map((e) => e.slice(0, 100)).join(" | ") : ""
+  ].filter(Boolean).join(`
+`);
+  const userContent = `Explore this conversation and produce the structured report.
+
+` + extractionContext + (prevSummary ? `
+
+## Previous Summary
+` + prevSummary : "") + (userNote ? `
+
+## User Steering
+"` + userNote + '"' : "");
+  const cacheKey = model.provider + "/" + model.id;
+  const cachedSupport = _toolSupportCache.get(cacheKey);
+  const cacheValid = cachedSupport && Date.now() - cachedSupport.timestamp < TOOL_CACHE_TTL;
+  let supportsTools = false;
+  try {
+    if (cacheValid && !cachedSupport.result) {
+      if (notify)
+        notify("Tool support cached: unsupported (" + cacheKey + ")", "info");
+      const report2 = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+      if (!report2.boundaries.length) {
+        const retried = await explorationRetry(model, auth, llmMessages, extraction, prevSummary, userNote, signal);
+        if (retried.boundaries.length)
+          return { report: retried, rounds: 1, toolSupported: false };
+      }
+      return { report: report2, rounds: 0, toolSupported: false };
+    }
+    const probeResp = await trackedComplete("explore", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [{ role: "user", content: [{ type: "text", text: userContent }] }],
+      tools: EXPLORATION_TOOLS
+    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, signal }));
+    const toolCalls = probeResp.content.filter((c) => c.type === "toolCall");
+    if (toolCalls.length > 0) {
+      supportsTools = true;
+      _toolSupportCache.set(cacheKey, { result: true, timestamp: Date.now() });
+      const messages = [
+        { role: "user", content: [{ type: "text", text: userContent }], timestamp: Date.now() },
+        { role: "assistant", content: probeResp.content, timestamp: Date.now() }
+      ];
+      for (const tc of toolCalls) {
+        const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages);
+        messages.push({ role: "toolResult", toolCallId: tc.id, toolName: tc.name, content: [{ type: "text", text: result }], isError: false, timestamp: Date.now() });
+      }
+      let rounds = 1;
+      while (rounds < maxRounds) {
+        rounds++;
+        let response;
+        try {
+          response = await trackedComplete("explore-loop", model, {
+            systemPrompt: COMPACT_SYSTEM_PREFIX + `
+
+` + EXPLORER_SYSTEM_PROMPT,
+            messages,
+            tools: EXPLORATION_TOOLS
+          }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, signal }));
+        } catch (err) {
+          console.error("[smart-compact] Explore loop error:", err instanceof Error ? err.message : err);
+          break;
+        }
+        const nextToolCalls = response.content.filter((c) => c.type === "toolCall");
+        if (nextToolCalls.length === 0) {
+          const text = response.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`).trim();
+          let report2 = parseExplorationReport(text, llmMessages);
+          if (!report2.boundaries.length) {
+            report2 = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+            if (report2.boundaries.length)
+              rounds++;
+          }
+          return { report: report2, rounds, toolSupported: true };
+        }
+        messages.push({ role: "assistant", content: response.content, timestamp: Date.now() });
+        for (const tc of nextToolCalls) {
+          const result = executeExplorationTool({ name: tc.name, arguments: tc.arguments }, llmMessages);
+          messages.push({ role: "toolResult", toolCallId: tc.id, toolName: tc.name, content: [{ type: "text", text: result }], isError: false, timestamp: Date.now() });
+        }
+      }
+      const lastAssistant = messages.filter((m) => m.role === "assistant").pop();
+      if (lastAssistant?.content) {
+        const text = lastAssistant.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`).trim();
+        const report2 = parseExplorationReport(text, llmMessages);
+        if (report2.boundaries.length)
+          return { report: report2, rounds, toolSupported: true };
+      }
+    } else {
+      const text = probeResp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`).trim();
+      let report2 = parseExplorationReport(text, llmMessages);
+      if (!report2.boundaries.length) {
+        report2 = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+      }
+      return { report: report2, rounds: 1, toolSupported: true };
+    }
+  } catch {
+    console.error("[smart-compact] Tool calling probe failed for " + cacheKey);
+    _toolSupportCache.set(cacheKey, { result: false, timestamp: Date.now() });
+    if (notify)
+      notify("Tool calling not supported, using direct exploration", "warning");
+  }
+  const report = await directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal);
+  if (!report.boundaries.length) {
+    const retried = await explorationRetry(model, auth, llmMessages, extraction, prevSummary, userNote, signal);
+    if (retried.boundaries.length)
+      return { report: retried, rounds: 1, toolSupported: false };
+  }
+  return { report, rounds: 0, toolSupported: supportsTools };
+}
+async function explorationRetry(model, auth, llmMessages, extraction, prevSummary, userNote, signal) {
+  const last5 = llmMessages.slice(-5).map((m) => "[" + m?.role + "] " + extractText(m?.content).slice(0, 150)).join(`
+`);
+  const retryPrompt = `IMPORTANT: Output ONLY valid raw JSON. No markdown. No explanation. No code fences. Just the JSON object.
+
+` + `Produce this exact structure:
+{"mainGoal":"...","sessionType":"implementation|review|debugging|discussion","boundaries":[{"afterIndex":N,"topic":"...","priority":"normal","confidence":0.5}],"enrichedConstraints":[],"crossReferences":[],"statusAssessment":{"done":[],"inProgress":[],"blocked":[]},"criticalContext":[],"keyDecisions":[]}
+
+` + `Context:
+Files: ` + extraction.modifiedFiles.map((f) => f.path).join(", ") + `
+` + "Topics heuristic: " + extraction.topics.map((t) => "[" + t.startIndex + "-" + t.endIndex + "]").join(", ") + `
+` + `Last messages:
+` + last5 + (userNote ? `
+User steering: ` + userNote : "");
+  try {
+    const resp = await trackedComplete("explore-retry", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [{ role: "user", content: [{ type: "text", text: retryPrompt }] }]
+    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 4096, signal }));
+    const text = resp.content.filter((c) => c.type === "text").map((c) => c.text).join("").trim();
+    return parseExplorationReport(text, llmMessages);
+  } catch {
+    return fallbackExplorationReport(llmMessages);
+  }
+}
+async function directExploration(llmMessages, extraction, model, auth, prevSummary, userNote, signal) {
+  const first3 = llmMessages.filter((m) => m?.role === "user").slice(0, 3).map((m) => extractText(m?.content).slice(0, 200)).join(`
+---
+`);
+  const last30 = llmMessages.slice(-30).map((m) => "[" + m?.role + "] " + extractText(m?.content).slice(0, 300)).join(`
+`);
+  const prompt = `Analyze this conversation and produce a JSON report.
+
+First user messages:
+` + first3 + `
+
+Deterministic data:
+` + "- Files modified: " + (extraction.modifiedFiles.map((f) => f.path).join(", ") || "none") + `
+- Errors: ` + (extraction.errors.map((e) => e.message.slice(0, 80)).join("; ") || "none") + `
+- Decisions: ` + (extraction.decisions.map((d) => d.summary.slice(0, 80)).join("; ") || "none") + `
+- Constraints: ` + (extraction.constraints.map((c) => c.text.slice(0, 80)).join("; ") || "none") + `
+
+Last 30 messages:
+` + last30 + (prevSummary ? `
+
+Previous summary:
+` + prevSummary : "") + (userNote ? `
+
+User note: "` + userNote + '"' : "") + `
+
+Output ONLY JSON: {"mainGoal":"...","sessionType":"implementation|review|debugging|discussion","boundaries":[{"afterIndex":N,"topic":"...","priority":"normal","confidence":0.5}],"enrichedConstraints":[...],"crossReferences":[...],"statusAssessment":{"done":[...],"inProgress":[...],"blocked":[...]},"criticalContext":[...],"keyDecisions":[...]}`;
+  try {
+    const resp = await trackedComplete("explore-direct", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [{ role: "user", content: [{ type: "text", text: prompt }] }]
+    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 4096, signal }));
+    const text = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`).trim();
+    return parseExplorationReport(text, llmMessages);
+  } catch {
+    return fallbackExplorationReport(llmMessages);
+  }
+}
+
+// src/phases/synthesize.ts
+function chunkLlmMessages(msgs, boundaries, pc) {
+  if (!msgs.length)
+    return [];
+  if (!boundaries.length) {
+    return [{
+      startIndex: 0,
+      endIndex: msgs.length - 1,
+      tokenEstimate: estimateTokens(JSON.stringify(msgs)),
+      topic: "Full conversation",
+      priority: "normal",
+      messages: msgs
+    }];
+  }
+  const sorted = [...boundaries].sort((a, b) => a.afterIndex - b.afterIndex);
+  const chunks = [];
+  let start = 0;
+  for (const bp of sorted) {
+    const end = bp.afterIndex + 1;
+    if (end > start && end <= msgs.length) {
+      const slice = msgs.slice(start, end);
+      chunks.push({
+        startIndex: start,
+        endIndex: end - 1,
+        tokenEstimate: estimateTokens(JSON.stringify(slice)),
+        topic: bp.topic || "Segment " + (chunks.length + 1),
+        priority: bp.priority,
+        messages: slice
+      });
+    }
+    start = end;
+  }
+  if (start < msgs.length) {
+    const slice = msgs.slice(start);
+    const lastTopic = sorted.length ? "After: " + sorted[sorted.length - 1].topic : "Full conversation";
+    chunks.push({
+      startIndex: start,
+      endIndex: msgs.length - 1,
+      tokenEstimate: estimateTokens(JSON.stringify(slice)),
+      topic: lastTopic,
+      priority: "normal",
+      messages: slice
+    });
+  }
+  const merged = [];
+  for (const ch of chunks) {
+    if (merged.length && ch.tokenEstimate < pc.minChunkTokens) {
+      const prev = merged[merged.length - 1];
+      prev.endIndex = ch.endIndex;
+      prev.tokenEstimate += ch.tokenEstimate;
+      prev.messages = msgs.slice(prev.startIndex, prev.endIndex + 1);
+      prev.topic = prev.topic + " + " + ch.topic;
+    } else {
+      merged.push(ch);
+    }
+  }
+  return merged;
+}
+async function singlePassCompact(convText, extraction, report, prevContext, model, auth, signal) {
+  const extractionCtx = buildExtractionContext(extraction);
+  const explorationCtx = report ? buildExplorationContext(report) : "";
+  const sessionType = report?.sessionType ?? "implementation";
+  const sessionInstruction = SESSION_TYPE_INSTRUCTIONS[sessionType] ?? SESSION_TYPE_INSTRUCTIONS.implementation;
+  const adaptedPrefix = SINGLE_PASS_PREFIX + `
+Session-specific instructions:
+` + sessionInstruction;
+  const dynamicSuffix = SINGLE_PASS_SUFFIX.replace("{PREV_CONTEXT}", prevContext).replace("{EXTRACTION_CONTEXT}", extractionCtx).replace("{EXPLORATION_CONTEXT}", explorationCtx).replace("{CONVERSATION}", convText);
+  const resp = await trackedComplete("single-pass", model, {
+    systemPrompt: COMPACT_SYSTEM_PREFIX,
+    messages: [
+      { role: "user", content: [{ type: "text", text: adaptedPrefix }] },
+      { role: "user", content: [{ type: "text", text: dynamicSuffix }] }
+    ]
+  }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 8192, signal }));
+  const summary = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`).trim();
+  if (!summary.startsWith("##"))
+    throw new Error("Single-pass malformed output");
+  return { summary, llmCalls: 1 };
+}
+async function summarizeBatch(batch, extraction, model, auth, signal) {
+  const range = { start: batch[0].startIndex, end: batch[batch.length - 1].endIndex };
+  const extractionCtx = buildExtractionContext(extraction, range);
+  const activeDecisions = extraction.decisions.filter((d) => d.index < range.start).map((d) => "- " + d.summary.slice(0, 120) + (d.userResponse ? " \u2192 " + d.userResponse.slice(0, 60) : ""));
+  const decisionCtx = activeDecisions.length ? `
+## Active Decisions from previous segments (honour these):
+` + activeDecisions.join(`
+`) : "";
+  const text = batch.map((ch) => "--- Topic: " + ch.topic + " (" + ch.priority + `) ---
+` + ch.messages.map((m) => {
+    const role = m?.role ?? "unknown";
+    const content = extractText(m?.content).slice(0, 500);
+    return "[" + role + "] " + content;
+  }).join(`
+`)).join(`
+
+`);
+  const dynamicSuffix = BATCH_PROMPT_SUFFIX.replace("{EXTRACTION_CONTEXT}", extractionCtx + decisionCtx).replace("{TEXT}", text);
+  const resp = await trackedComplete("batch", model, {
+    systemPrompt: COMPACT_SYSTEM_PREFIX,
+    messages: [
+      { role: "user", content: [{ type: "text", text: BATCH_PROMPT_PREFIX }] },
+      { role: "user", content: [{ type: "text", text: dynamicSuffix }] }
+    ]
+  }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 4096, signal }));
+  const output = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+  const sections = output.split(/^### /m).filter((s) => s.trim());
+  return batch.map((ch, i) => {
+    const sec = sections[i] ?? "";
+    const f = (n) => {
+      const m = sec.match(new RegExp("\\*\\*" + n + "\\*\\*:\\s*(.+?)(?:\\n|$)", "i"));
+      return m ? m[1].trim() : "";
+    };
+    const l = (n) => {
+      const v = f(n);
+      return !v || v === "None" ? [] : v.split(",").map((s) => s.trim()).filter(Boolean);
+    };
+    const prio = f("Priority").toLowerCase();
+    return {
+      topic: ch.topic,
+      startIndex: ch.startIndex,
+      endIndex: ch.endIndex,
+      summary: f("Summary") || sec.split(`
+`).slice(1).join(`
+`).trim().slice(0, 500),
+      keyDecisions: l("Decisions"),
+      filesModified: l("Modified"),
+      filesRead: l("Read"),
+      priority: ["critical", "high", "normal", "low"].includes(prio) ? prio : ch.priority
+    };
+  });
+}
+async function assembleLLM(summaries, extraction, report, model, auth, budget, prevContext, signal) {
+  const pp = preProcessSummaries(summaries, budget);
+  const detModified = extraction.modifiedFiles.map((f) => f.path);
+  const detRead = extraction.readFiles;
+  const explorationCtx = report ? buildExplorationContext(report) : "";
+  const dynamicSuffix = ASSEMBLY_PROMPT_SUFFIX.replace("{DECISIONS}", pp.decisions.join("; ") || "None").replace("{MODIFIED}", detModified.join(", ") || "None").replace("{READ}", detRead.join(", ") || "None").replace("{EXPLORATION_CONTEXT}", explorationCtx).replace("{PREV_CONTEXT}", prevContext).replace("{SUMMARIES}", pp.text);
+  const resp = await trackedComplete("assemble", model, {
+    systemPrompt: COMPACT_SYSTEM_PREFIX,
+    messages: [
+      { role: "user", content: [{ type: "text", text: ASSEMBLY_PROMPT_PREFIX }] },
+      { role: "user", content: [{ type: "text", text: dynamicSuffix }] }
+    ]
+  }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: Math.min(budget, 8192), signal }));
+  return resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`).trim();
+}
+function assembleFallback(summaries, extraction) {
+  const detModified = extraction.modifiedFiles.map((f) => f.path);
+  const detRead = extraction.readFiles;
+  return [
+    "## Goal",
+    extraction.mainGoal ?? "See topics below.",
+    "",
+    "## Constraints & Preferences",
+    ...extraction.constraints.map((c) => "- [" + c.category + "] " + c.text.slice(0, 200)),
+    "",
+    "## Progress",
+    "### Done",
+    "- See topics below",
+    "### In Progress",
+    ...summaries.filter((s) => s.priority === "high").map((s) => "- [ ] " + s.summary.slice(0, 150)),
+    "### Blocked",
+    "- None",
+    "",
+    "## Key Decisions",
+    ...extraction.decisions.map((d) => "- **" + d.summary.slice(0, 100) + "**" + (d.userResponse ? " \u2192 " + d.userResponse : "")),
+    "",
+    "## Files Modified",
+    ...detModified.map((f) => "- " + f),
+    "",
+    "## Files Read",
+    ...detRead.map((f) => "- " + f),
+    "",
+    "## Next Steps",
+    "1. See topics below",
+    "",
+    "## Critical Context",
+    ...extraction.errors.filter((e) => !e.resolved).map((e) => "- Unresolved error: " + e.message.slice(0, 100)),
+    "",
+    "## Topics Covered",
+    ...summaries.map((s) => "- **" + s.topic + "** [" + s.priority + "]: " + s.summary.slice(0, 200))
+  ].join(`
+`);
+}
+
+// src/phases/verify.ts
+function verifySummary(summary, extraction) {
+  const gaps = [];
+  const lower = summary.toLowerCase();
+  let score = 100;
+  for (const f of extraction.modifiedFiles) {
+    const pathLower = f.path.toLowerCase();
+    const parts = pathLower.split("/");
+    const suffixes = [];
+    for (let j = 0;j < parts.length; j++) {
+      suffixes.push(parts.slice(j).join("/"));
+    }
+    const pathMatch = suffixes.some((s) => s.length > 2 && lower.includes(s));
+    if (!pathMatch) {
+      gaps.push("Missing modified file: " + f.path);
+      score -= 5;
+    }
+  }
+  for (const e of extraction.errors.filter((e2) => !e2.resolved)) {
+    const snippet = e.message.slice(0, 30).toLowerCase();
+    if (snippet.length > 5 && !lower.includes(snippet)) {
+      gaps.push("Missing error: " + e.message.slice(0, 80));
+      score -= 5;
+    }
+  }
+  for (const c of extraction.constraints.filter((c2) => c2.confidence >= 0.8)) {
+    const keywords = c.text.split(/\s+/).filter((w) => w.length > 4).slice(0, 3);
+    const found = keywords.some((k) => lower.includes(k.toLowerCase()));
+    if (!found && keywords.length > 0) {
+      gaps.push("Missing constraint: " + c.text.slice(0, 100));
+      score -= 3;
+    }
+  }
+  if (extraction.mainGoal) {
+    const goalWords = extraction.mainGoal.split(/\s+/).filter((w) => w.length > 3).slice(0, 4);
+    const goalFound = goalWords.some((w) => lower.includes(w.toLowerCase()));
+    if (!goalFound) {
+      gaps.push("Main goal may be missing from summary");
+      score -= 10;
+    }
+  }
+  if (!lower.includes("## goal"))
+    score -= 5;
+  if (!lower.includes("## progress"))
+    score -= 5;
+  if (!lower.includes("## critical context"))
+    score -= 3;
+  const summaryFileRefs = (summary.match(/[\w.\/-]+\.[\w]+/g) ?? []).filter((p) => p.includes("/") || p.match(/\.(ts|tsx|js|jsx|rs|py|go|java|rb|css|html|json|yaml|yml|toml|md|sh|sql)$/i));
+  const knownFiles = new Set([
+    ...extraction.modifiedFiles.map((f) => f.path.toLowerCase()),
+    ...extraction.readFiles.map((f) => f.toLowerCase())
+  ]);
+  for (const ref of summaryFileRefs) {
+    const refLower = ref.toLowerCase();
+    const isKnown = [...knownFiles].some((kf) => kf.endsWith("/" + refLower) || kf === refLower || kf.endsWith(refLower) && refLower.length > 3);
+    if (!isKnown) {
+      gaps.push("Potentially fabricated file: " + ref);
+      score -= 4;
+    }
+  }
+  const errorFiles = new Set(extraction.errors.map((e) => e.message));
+  if (errorFiles.size > 0) {
+    const doneSection = (summary.match(/### Done[\s\S]*?(?=###|$)/i) ?? [""])[0];
+    if (doneSection) {
+      for (const f of extraction.modifiedFiles) {
+        const bn = f.path.split("/").pop() ?? "";
+        const hasError = [...errorFiles].some((e) => e.toLowerCase().includes(bn.toLowerCase()));
+        const markedDone = doneSection.toLowerCase().includes(bn.toLowerCase());
+        if (hasError && markedDone) {
+          const unresolved = extraction.errors.find((e) => e.message.toLowerCase().includes(bn.toLowerCase()) && !e.resolved);
+          if (unresolved) {
+            gaps.push("Inconsistency: " + bn + " marked Done but has unresolved error");
+            score -= 5;
+          }
+        }
+      }
+    }
+  }
+  const highConfDecisions = extraction.decisions.filter((d) => d.type === "explicit");
+  if (highConfDecisions.length > 0) {
+    const decisionSection = (summary.match(/## Key Decisions[\s\S]*?(?=##|$)/i) ?? [""])[0];
+    for (const d of highConfDecisions) {
+      const keywords = d.summary.split(/\s+/).filter((w) => w.length > 4).slice(0, 3);
+      if (keywords.length > 0 && !keywords.some((k) => decisionSection.toLowerCase().includes(k.toLowerCase()))) {
+        gaps.push("Missing decision: " + d.summary.slice(0, 100));
+        score -= 3;
+      }
+    }
+  }
+  if (extraction.errors.some((e) => !e.resolved)) {
+    const hasOpenLoops = lower.includes("## open loops") || lower.includes("unresolved") || lower.includes("open loop");
+    if (!hasOpenLoops && extraction.errors.filter((e) => !e.resolved).length >= 2) {
+      gaps.push("Missing Open Loops section despite " + extraction.errors.filter((e) => !e.resolved).length + " unresolved errors");
+      score -= 5;
+    }
+  }
+  return { ok: gaps.length === 0, gaps, score: Math.max(0, score) };
+}
+function patchDeterministic(summary, gaps, extraction) {
+  let patched = summary;
+  const fileGaps = gaps.filter((g) => g.startsWith("Missing modified file:"));
+  const errorGaps = gaps.filter((g) => g.startsWith("Missing error:"));
+  const constraintGaps = gaps.filter((g) => g.startsWith("Missing constraint:"));
+  const decisionGaps = gaps.filter((g) => g.startsWith("Missing decision:"));
+  const otherGaps = gaps.filter((g) => !g.startsWith("Missing modified file:") && !g.startsWith("Missing error:") && !g.startsWith("Missing constraint:") && !g.startsWith("Missing decision:") && !g.startsWith("Potentially fabricated") && !g.startsWith("Inconsistency"));
+  if (fileGaps.length > 0) {
+    const filesSection = patched.match(/## Files Modified\n/);
+    if (filesSection) {
+      const insertPos = filesSection.index + filesSection[0].length;
+      const entries = fileGaps.map((g) => "- " + g.replace("Missing modified file: ", "")).join(`
+`) + `
+`;
+      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
+    }
+  }
+  if (errorGaps.length > 0) {
+    const ctxSection = patched.match(/## Critical Context\n/);
+    if (ctxSection) {
+      const insertPos = ctxSection.index + ctxSection[0].length;
+      const entries = errorGaps.map((g) => "- " + g).join(`
+`) + `
+`;
+      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
+    }
+  }
+  if (constraintGaps.length > 0) {
+    const constrSection = patched.match(/## Constraints & Preferences\n/);
+    if (constrSection) {
+      const insertPos = constrSection.index + constrSection[0].length;
+      const entries = constraintGaps.map((g) => "- " + g).join(`
+`) + `
+`;
+      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
+    }
+  }
+  if (decisionGaps.length > 0) {
+    const decSection = patched.match(/## Key Decisions\n/);
+    if (decSection) {
+      const insertPos = decSection.index + decSection[0].length;
+      const entries = decisionGaps.map((g) => "- **" + g.replace("Missing decision: ", "") + "**").join(`
+`) + `
+`;
+      patched = patched.slice(0, insertPos) + entries + patched.slice(insertPos);
+    }
+  }
+  if (otherGaps.length > 0) {
+    patched += `
+## Verification Note
+` + otherGaps.map((g) => "- " + g).join(`
+`);
+  }
+  return patched;
+}
+async function patchSummary(summary, gaps, model, auth, signal) {
+  const patchPrompt = `The summary below is missing some critical information. Add the missing items WITHOUT restructuring the summary.
+
+Missing items:
+` + gaps.map((g, i) => i + 1 + ". " + g).join(`
+`) + `
+
+Current summary:
+` + summary + `
+
+Return the COMPLETE updated summary with missing items integrated. Keep the same format.`;
+  try {
+    const resp = await trackedComplete("patch", model, {
+      systemPrompt: COMPACT_SYSTEM_PREFIX,
+      messages: [{ role: "user", content: [{ type: "text", text: patchPrompt }] }]
+    }, cacheOpts({ apiKey: auth.apiKey, headers: auth.headers, maxTokens: 8192, signal }));
+    const patched = resp.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`).trim();
+    return patched.startsWith("##") ? patched : summary;
+  } catch {
+    return summary;
+  }
+}
+
+// src/ui/overlays.ts
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Container, SelectList, Text } from "@earendil-works/pi-tui";
+import path7 from "path";
+function renderContextBar(theme, pct, tokens, barLen = 24) {
+  const clamped = Math.min(Math.max(pct, 0), 100);
+  const filled = Math.min(barLen, Math.round(clamped / 100 * barLen));
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(barLen - filled);
+  const color = clamped > 80 ? "error" : clamped > 50 ? "warning" : "success";
+  return theme.fg("text", "  Context: ") + theme.fg(color, bar) + theme.fg("text", " " + clamped + "%") + theme.fg("dim", " (" + (tokens ?? 0).toLocaleString() + "t)");
+}
+function renderTokenBar(theme, before, after, label, barLen = 30) {
+  const ratio = before > 0 ? after / before : 0;
+  const savedPct = Math.round((1 - ratio) * 100);
+  const filled = Math.min(barLen, Math.round(ratio * barLen));
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(barLen - filled);
+  const savedColor = savedPct >= 50 ? "success" : savedPct >= 25 ? "warning" : "error";
+  return theme.fg("text", "  " + label + ": ") + theme.fg(savedColor, bar) + theme.fg("text", " " + (after ?? 0).toLocaleString() + "t") + theme.fg(savedColor, " (saved " + savedPct + "%)");
+}
+var _toolSupportCache2 = new Map;
+async function selectModel(ctx, opts) {
+  const available = ctx.modelRegistry.getAvailable();
+  const options = available.map((m) => ({
+    value: m.provider + "/" + m.id,
+    label: m.provider + "/" + m.id + (m.contextWindow >= 200000 ? " (" + Math.round(m.contextWindow / 1000) + "K)" : ""),
+    model: m,
+    supportsTools: true
+  }));
+  const items = options.map((o, i) => ({
+    value: "model:" + i,
+    label: o.label,
+    description: i === opts.defaultModelIndex ? "\u2190 session model" : undefined
+  }));
+  const result = await ctx.ui.custom((tui, theme, _kb, done) => {
+    const c = new Container;
+    c.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+    c.addChild(new Text(theme.fg("accent", theme.bold("  \uD83D\uDD0D Smart Compact \u2014 Step 1/2")), 1, 0));
+    c.addChild(new Text(theme.fg("dim", "  Architecture: EESV (Extract \u2192 Explore \u2192 Synthesize \u2192 Verify)"), 0, 0));
+    c.addChild(new Text("", 0, 0));
+    c.addChild(new Text(renderContextBar(theme, opts.contextPercent, opts.contextTokens), 0, 0));
+    c.addChild(new Text(theme.fg("dim", "  Session: " + opts.currentModel), 0, 0));
+    c.addChild(new Text("", 0, 0));
+    c.addChild(new Text(theme.fg("text", "  Select model for compaction:"), 1, 0));
+    c.addChild(new Text("", 0, 0));
+    const sel = new SelectList(items, Math.min(items.length, 12), {
+      selectedPrefix: (t) => theme.fg("accent", t),
+      selectedText: (t) => theme.fg("accent", t),
+      description: (t) => theme.fg("muted", t),
+      scrollInfo: (t) => theme.fg("dim", t),
+      noMatch: (t) => theme.fg("warning", t)
+    });
+    sel.selectedIndex = opts.defaultModelIndex;
+    sel.onSelect = (item) => done(item.value);
+    sel.onCancel = () => done(null);
+    c.addChild(sel);
+    c.addChild(new Text("", 0, 0));
+    c.addChild(new Text(theme.fg("dim", "  \u2191\u2193 navigate \u2022 enter select \u2022 esc cancel"), 0, 0));
+    c.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+    return {
+      render: (w) => c.render(w),
+      invalidate: () => c.invalidate(),
+      handleInput: (d) => {
+        sel.handleInput(d);
+        tui.requestRender();
+      }
+    };
+  });
+  if (!result?.startsWith("model:"))
+    return null;
+  return options[parseInt(result.slice(6), 10)] ?? null;
+}
+async function selectProfile(ctx, selectedModel, opts) {
+  const estAfter = (budget, keep) => budget + Math.min(opts.contextTokens, keep);
+  const profiles = [
+    { value: "light", label: "\u2601\uFE0F  Light", desc: "Max detail", budget: 1e4, keep: 30000 },
+    { value: "balanced", label: "\u2696\uFE0F  Balanced", desc: "Recommended", budget: 6000, keep: 20000 },
+    { value: "aggressive", label: "\uD83D\uDD25 Aggressive", desc: "Minimal", budget: 3000, keep: 1e4 }
+  ];
+  const items = profiles.map((p) => {
+    const after = estAfter(p.budget, p.keep);
+    const pct = opts.contextTokens > 0 ? Math.round((1 - after / opts.contextTokens) * 100) : 0;
+    return { value: p.value, label: p.label, description: p.desc + " \u2014 est. ~" + after.toLocaleString() + "t after (save ~" + pct + "%)" };
+  });
+  const result = await ctx.ui.custom((tui, theme, _kb, done) => {
+    const c = new Container;
+    c.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+    c.addChild(new Text(theme.fg("accent", theme.bold("  \uD83D\uDD0D Smart Compact \u2014 Step 2/2")), 1, 0));
+    c.addChild(new Text("", 0, 0));
+    c.addChild(new Text(theme.fg("dim", "  Model: " + selectedModel.label), 0, 0));
+    c.addChild(new Text(renderContextBar(theme, opts.contextPercent, opts.contextTokens), 0, 0));
+    c.addChild(new Text("", 0, 0));
+    c.addChild(new Text(theme.fg("text", "  Select compression profile:"), 1, 0));
+    c.addChild(new Text("", 0, 0));
+    const sel = new SelectList(items, 3, {
+      selectedPrefix: (t) => theme.fg("accent", t),
+      selectedText: (t) => theme.fg("accent", t),
+      description: (t) => theme.fg("muted", t),
+      scrollInfo: (t) => theme.fg("dim", t),
+      noMatch: (t) => theme.fg("warning", t)
+    });
+    sel.selectedIndex = 1;
+    sel.onSelect = (item) => done(item.value);
+    sel.onCancel = () => done(null);
+    c.addChild(sel);
+    c.addChild(new Text("", 0, 0));
+    c.addChild(new Text(theme.fg("dim", "  \u2191\u2193 navigate \u2022 enter select \u2022 esc cancel"), 0, 0));
+    c.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+    return {
+      render: (w) => c.render(w),
+      invalidate: () => c.invalidate(),
+      handleInput: (d) => {
+        sel.handleInput(d);
+        tui.requestRender();
+      }
+    };
+  });
+  if (!result)
+    return null;
+  return profiles.find((p) => p.value === result)?.value ?? null;
+}
+function showProgressOverlay(ctx, state) {
+  const phaseNames = ["Extract", "Explore", "Synthesize", "Verify"];
+  const progress = Math.round(state.phase / 4 * 100);
+  const name = phaseNames[state.phase - 1] ?? "?";
+  const detail = state.detail ? " (" + state.detail + ")" : "";
+  const type = state.phase >= 4 ? "success" : "info";
+  ctx.ui.notify("EESV [" + progress + "%] Phase " + state.phase + "/4: " + name + detail, type);
+}
+async function showResultScreen(ctx, details, extraction) {
+  await ctx.ui.custom((tui, theme, _kb, done) => {
+    const c = new Container;
+    c.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+    c.addChild(new Text(theme.fg("accent", theme.bold("  \u2705 Smart Compact Complete")), 1, 0));
+    c.addChild(new Text("", 0, 0));
+    const estimatedAfter = (details.tokensBefore ?? 0) - (details.tokensSaved ?? 0);
+    c.addChild(new Text(renderTokenBar(theme, details.tokensBefore, estimatedAfter, "Result  "), 0, 0));
+    c.addChild(new Text(theme.fg("dim", "  Before: " + (details.tokensBefore ?? 0).toLocaleString() + "t \u2192 After: ~" + estimatedAfter.toLocaleString() + "t \u2192 Saved: " + (details.tokensSaved ?? 0).toLocaleString() + "t"), 0, 0));
+    c.addChild(new Text("", 0, 0));
+    const methodColors = { eesv: "accent", "single-pass": "success", heuristic: "warning" };
+    const methodColor = methodColors[details.method] ?? "text";
+    c.addChild(new Text(theme.fg("text", "  Method: ") + theme.fg(methodColor, details.method.toUpperCase()) + theme.fg("dim", " \u2022 " + details.llmCalls + " LLM call(s) \u2022 Profile: " + details.profile), 0, 0));
+    if (details.model) {
+      c.addChild(new Text(theme.fg("dim", "  Model: " + details.model), 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("", 0, 0));
+    c.addChild(new Text(theme.fg("text", theme.bold("  \uD83D\uDCCB Extraction")), 0, 0));
+    const ms = getMetricsSummary();
+    if (ms.totalCalls > 0) {
+      const cachePct = Math.round(ms.cacheHitRate * 100);
+      const cacheColor = cachePct >= 50 ? "success" : cachePct >= 20 ? "warning" : "dim";
+      c.addChild(new Text(theme.fg("dim", "  LLM: ") + theme.fg("text", ms.totalCalls + " calls") + theme.fg("dim", " \u2022 ") + theme.fg("text", ms.totalInput.toLocaleString() + "t in") + theme.fg("dim", " \u2022 ") + theme.fg(cacheColor, cachePct + "% cache hit") + theme.fg("dim", " \u2022 ") + theme.fg("dim", ms.avgLatency + "ms avg"), 0, 0));
+    }
+    const modFiles = details.modifiedFiles;
+    const errCount = extraction.errors.length;
+    const resolvedErr = extraction.errors.filter((e) => e.resolved).length;
+    const unresolvedErr = errCount - resolvedErr;
+    c.addChild(new Text(theme.fg("dim", "  Files: ") + theme.fg("success", modFiles.length + " modified") + theme.fg("dim", " \u2022 ") + theme.fg("text", details.readFiles.length + " read") + theme.fg("dim", " \u2022 ") + theme.fg("text", details.totalMessages + " messages"), 0, 0));
+    if (errCount > 0) {
+      c.addChild(new Text(theme.fg("dim", "  Errors: ") + theme.fg("warning", errCount + " total") + theme.fg("dim", " \u2022 ") + theme.fg("success", resolvedErr + " resolved") + theme.fg("dim", " \u2022 ") + theme.fg("error", unresolvedErr + " unresolved"), 0, 0));
+    }
+    if (extraction.decisions.length > 0) {
+      const expD = extraction.decisions.filter((d) => d.type === "explicit").length;
+      const impD = extraction.decisions.filter((d) => d.type === "implicit").length;
+      c.addChild(new Text(theme.fg("dim", "  Decisions: " + extraction.decisions.length + " (" + expD + " explicit, " + impD + " implicit)"), 0, 0));
+    }
+    if (extraction.constraints.length > 0) {
+      const reqC = extraction.constraints.filter((cc) => cc.category === "requirement").length;
+      const proC = extraction.constraints.filter((cc) => cc.category === "prohibition").length;
+      const preC = extraction.constraints.filter((cc) => cc.category === "preference").length;
+      c.addChild(new Text(theme.fg("dim", "  Constraints: " + extraction.constraints.length + " (" + reqC + " req, " + proC + " prohibit, " + preC + " pref)"), 0, 0));
+    }
+    c.addChild(new Text("", 0, 0));
+    if (modFiles.length > 0) {
+      c.addChild(new Text(theme.fg("text", theme.bold("  \uD83D\uDCC1 Modified Files")), 0, 0));
+      const maxShow = 8;
+      for (let i = 0;i < Math.min(modFiles.length, maxShow); i++) {
+        const f = modFiles[i];
+        const fc = extraction.modifiedFiles.find((e) => e.path === f);
+        const count = fc ? " (" + fc.toolCalls + "x)" : "";
+        c.addChild(new Text(theme.fg("success", "    \u270E ") + theme.fg("text", path7.basename(f)) + theme.fg("dim", count + " \u2192 " + f), 0, 0));
+      }
+      if (modFiles.length > maxShow) {
+        c.addChild(new Text(theme.fg("dim", "    + " + (modFiles.length - maxShow) + " more"), 0, 0));
+      }
+      c.addChild(new Text("", 0, 0));
+    }
+    if (details.topics.length > 0) {
+      c.addChild(new Text(theme.fg("text", theme.bold("  \uD83D\uDCE6 Topics")), 0, 0));
+      const maxTopics = 10;
+      for (let i = 0;i < Math.min(details.topics.length, maxTopics); i++) {
+        c.addChild(new Text(theme.fg("dim", "    " + (i + 1) + ". " + details.topics[i]), 0, 0));
+      }
+      if (details.topics.length > maxTopics) {
+        c.addChild(new Text(theme.fg("dim", "    + " + (details.topics.length - maxTopics) + " more"), 0, 0));
+      }
+      c.addChild(new Text("", 0, 0));
+    }
+    c.addChild(new Text(theme.fg("text", theme.bold("  \uD83D\uDD0D Verification")), 0, 0));
+    if (details.verified) {
+      c.addChild(new Text(theme.fg("success", "    \u2705 All facts verified \u2014 no gaps detected"), 0, 0));
+    } else if (details.gaps.length > 0) {
+      c.addChild(new Text(theme.fg("warning", "    \u26A0\uFE0F  " + details.gaps.length + " gap(s) patched:"), 0, 0));
+      for (const g of details.gaps.slice(0, 5)) {
+        c.addChild(new Text(theme.fg("dim", "      \u2022 " + g), 0, 0));
+      }
+    }
+    c.addChild(new Text("", 0, 0));
+    c.addChild(new Text(theme.fg("text", theme.bold("  \uD83D\uDD04 Pipeline")), 0, 0));
+    const phase1Status = theme.fg("success", "\u2713");
+    const phase2Status = details.explorationRounds > 0 ? theme.fg("success", "\u2713 " + details.explorationRounds + " rounds") : theme.fg("warning", "\u26A0 skipped");
+    const phase2Bounds = details.explorationBoundaries > 0 ? theme.fg("text", " (" + details.explorationBoundaries + " boundaries)") : theme.fg("dim", " (heuristic fallback)");
+    const phase4Status = details.verified ? theme.fg("success", "\u2713 verified") : details.gaps.length > 0 ? theme.fg("warning", "\u2713 patched (" + details.gaps.length + " gaps)") : theme.fg("dim", "\u2014");
+    c.addChild(new Text(theme.fg("dim", "    Phase 1 Extract: ") + phase1Status, 0, 0));
+    c.addChild(new Text(theme.fg("dim", "    Phase 2 Explore: ") + phase2Status + phase2Bounds, 0, 0));
+    c.addChild(new Text(theme.fg("dim", "    Phase 3 Synthesize: ") + theme.fg("success", "\u2713 " + details.chunkCount + " chunks"), 0, 0));
+    c.addChild(new Text(theme.fg("dim", "    Phase 4 Verify: ") + phase4Status, 0, 0));
+    c.addChild(new Text("", 0, 0));
+    if (details.backupPath) {
+      c.addChild(new Text(theme.fg("dim", "  \uD83D\uDCBE Backup: " + details.backupPath), 0, 0));
+      c.addChild(new Text("", 0, 0));
+    }
+    c.addChild(new Text(theme.fg("dim", "  Press any key to close"), 0, 0));
+    c.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+    return {
+      render: (w) => c.render(w),
+      invalidate: () => c.invalidate(),
+      handleInput: (_d) => done(undefined)
+    };
+  }, { overlay: true, overlayOptions: { width: "70%", anchor: "center", maxHeight: "80%" } });
+}
+async function showCompactUI(ctx, opts) {
+  const selectedModel = await selectModel(ctx, opts);
+  if (!selectedModel)
+    return null;
+  const selectedProfile = await selectProfile(ctx, selectedModel, { contextTokens: opts.contextTokens, contextPercent: opts.contextPercent });
+  if (!selectedProfile)
+    return null;
+  return { model: selectedModel, profile: selectedProfile };
+}
+
+// src/core.ts
+async function runSmartCompact(ctx, summaryModel, segModel, profile, verbose, dryRun, pendingRef, isRunning, autoTriggered, userNote, skipCompact) {
+  if (isRunning.value)
+    return;
+  isRunning.value = true;
+  const pipelineStart = Date.now();
+  resetCompactSessionId();
+  resetMetrics();
+  if (!summaryModel || !segModel) {
+    isRunning.value = false;
+    if (!autoTriggered)
+      ctx.ui.notify("Model resolve failed", "error");
+    return;
+  }
+  try {
+    const config = loadConfig();
+    const pc = { ...PROFILES[profile], ...config.profiles?.[profile] ?? {} };
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(summaryModel);
+    const segAuth = segModel !== summaryModel ? await ctx.modelRegistry.getApiKeyAndHeaders(segModel) : auth;
+    if (!auth.ok || !auth.apiKey || (!segAuth.ok || !segAuth.apiKey)) {
+      isRunning.value = false;
+      if (!autoTriggered)
+        ctx.ui.notify("Auth failed", "error");
+      return;
+    }
+    const usage = ctx.getContextUsage();
+    const totalTokens = usage?.tokens ?? 0;
+    if (!totalTokens || totalTokens < 5000) {
+      isRunning.value = false;
+      if (!autoTriggered)
+        ctx.ui.notify("Context OK or unknown", "info");
+      return;
+    }
+    const notify = (msg, type = "info") => {
+      ctx.ui.notify(msg, type);
+    };
+    const ctrl = new AbortController;
+    const signal = ctrl.signal;
+    const modelLabel = summaryModel.provider + "/" + summaryModel.id;
+    notify("Smart compact: " + modelLabel + ", " + profile + ", tokens=" + totalTokens, "info");
+    notify("EESV Compact (" + modelLabel + ", " + profile + ") \u2014 " + (totalTokens ?? 0).toLocaleString() + "t", "info");
+    const branch = ctx.sessionManager.getBranch();
+    const msgs = branch.filter((e) => e.type === "message" && e.message != null);
+    if (msgs.length < 3) {
+      isRunning.value = false;
+      return;
+    }
+    let accTokens = 0, keepFrom = msgs.length;
+    for (let i = msgs.length - 1;i >= 0; i--) {
+      const msg = msgs[i].message;
+      const contentRaw = msg?.content;
+      const contentText = typeof contentRaw === "string" ? contentRaw : contentRaw != null ? JSON.stringify(contentRaw) : "";
+      accTokens += estimateTokens(contentText);
+      if (accTokens >= pc.keepRecentTokens) {
+        keepFrom = i;
+        break;
+      }
+    }
+    keepFrom = smartKeepBoundary(msgs, keepFrom);
+    const toCompact = msgs.slice(0, keepFrom);
+    if (!toCompact.length) {
+      isRunning.value = false;
+      return;
+    }
+    const firstKeptId = msgs[keepFrom]?.id ?? msgs[msgs.length - 1]?.id ?? "";
+    if (!autoTriggered) {
+      showProgressOverlay(ctx, { phase: 1, phaseName: "Extract", detail: "Preparing...", model: modelLabel, profile });
+    }
+    const llmMessages = convertToLlm(toCompact.map((e) => e.message));
+    const pruning = pruneRedundant(llmMessages);
+    if (pruning.prunedCount > 0) {
+      notify("Pruning: " + pruning.prunedCount + " msgs removed (" + pruning.reasons.map((r) => r.count + "x " + r.reason).join(", ") + ")", "info");
+    }
+    const prunedMessages = pruning.messages;
+    const convText = serializeConversation(prunedMessages);
+    const convTokens = estimateTokens(convText);
+    const sessionId = ctx.sessionManager.getSessionId?.() ?? "unknown";
+    const backupPath = backupConversation(convText, sessionId);
+    const prevContext = getPreviousCompactionContext(branch);
+    const cachedExt = loadCachedExtraction(sessionId);
+    let extraction;
+    if (cachedExt && cachedExt.lastMessageIndex < llmMessages.length - 1) {
+      const newMsgs = llmMessages.slice(cachedExt.lastMessageIndex + 1);
+      const delta = extractStructured(newMsgs, pc);
+      extraction = mergeExtractions(cachedExt.extraction, delta, cachedExt.messageCount);
+      notify("Phase 1 Incremental: " + (cachedExt.lastMessageIndex + 1) + " cached + " + newMsgs.length + " new messages", "info");
+    } else {
+      extraction = extractStructured(llmMessages, pc);
+      notify("Phase 1 Full: " + extraction.modifiedFiles.length + " files, " + extraction.errors.length + " errors", "info");
+    }
+    saveCachedExtraction(sessionId, extraction, llmMessages.length);
+    const projectId = deriveProjectId(extraction);
+    const fingerprint = loadProjectFingerprint(projectId);
+    if (fingerprint) {
+      notify("Project: " + fingerprint.language + (fingerprint.framework ? "/" + fingerprint.framework : "") + " (" + fingerprint.sessionCount + " sessions)", "info");
+    }
+    const projectCtx = buildProjectContext(fingerprint);
+    let finalSummary;
+    let method;
+    let llmCalls = 0;
+    let summaries = [];
+    let explorationReport = null;
+    let explorationRounds = 0;
+    let chunkCount = 0;
+    if (convTokens < pc.singlePassMaxTokens) {
+      if (!autoTriggered)
+        showProgressOverlay(ctx, { phase: 2, phaseName: "Explore", detail: "Single-pass (" + convTokens.toLocaleString() + "t)", model: modelLabel, profile, extraction });
+      try {
+        const r = await singlePassCompact(convText, extraction, null, prevContext + projectCtx, summaryModel, { apiKey: auth.apiKey, headers: auth.headers }, signal);
+        finalSummary = r.summary;
+        method = "single-pass";
+        llmCalls = r.llmCalls;
+      } catch (err) {
+        notify("Single-pass failed: " + (err instanceof Error ? err.message : String(err)), "warning");
+        finalSummary = assembleFallback([], extraction);
+        method = "heuristic";
+        llmCalls = 0;
+      }
+    } else {
+      const needsExploration = shouldExplore(extraction);
+      if (needsExploration) {
+        if (!autoTriggered)
+          showProgressOverlay(ctx, { phase: 2, phaseName: "Explore", detail: "Exploring...", model: modelLabel, profile, extraction });
+        try {
+          const expResult = await exploreConversation(llmMessages, extraction, segModel, { apiKey: segAuth.apiKey, headers: segAuth.headers }, prevContext || undefined, userNote, signal, 8, notify);
+          explorationReport = expResult.report;
+          explorationRounds = expResult.rounds;
+          notify("Phase 2 Explore: " + expResult.rounds + " rounds, " + explorationReport.boundaries.length + " boundaries" + (expResult.toolSupported ? "" : " (no tool support)"), "info");
+        } catch (err) {
+          notify("Phase 2 Explore: failed - " + (err instanceof Error ? err.message : String(err)), "warning");
+        }
+      } else {
+        notify("Phase 2 Explore: skipped (simple session: " + extraction.topics.length + " topics, " + extraction.errors.filter((e) => !e.resolved).length + " unresolved errors)", "info");
+      }
+      let boundaries;
+      if (explorationReport?.boundaries.length) {
+        const llmBounds = explorationReport.boundaries.filter((b) => b.confidence >= 0.4);
+        const heuristicBounds = extraction.topics.map((t) => ({
+          afterIndex: t.endIndex,
+          topic: t.primaryFile ? "Working on " + t.primaryFile.split("/").pop() : "Segment",
+          priority: t.errorDensity > 2 ? "high" : "normal",
+          confidence: 0.6
+        }));
+        if (llmBounds.length > 0) {
+          const merged = [...llmBounds];
+          for (const hb of heuristicBounds) {
+            const nearby = merged.find((m) => Math.abs(m.afterIndex - hb.afterIndex) <= 3);
+            if (!nearby)
+              merged.push(hb);
+          }
+          boundaries = merged.sort((a, b) => a.afterIndex - b.afterIndex);
+        } else {
+          boundaries = heuristicBounds;
+        }
+      } else {
+        boundaries = extraction.topics.map((t) => ({
+          afterIndex: t.endIndex,
+          topic: t.primaryFile ? "Working on " + t.primaryFile.split("/").pop() : "Segment",
+          priority: t.errorDensity > 2 ? "high" : "normal",
+          confidence: 0.6
+        }));
+      }
+      const chunks = chunkLlmMessages(llmMessages, boundaries, pc);
+      chunkCount = chunks.length;
+      notify("Chunked: " + chunkCount + " chunks", "info");
+      const batches = createBatches(chunks, pc.batchMaxTokens);
+      const totalBatches = batches.length;
+      if (!autoTriggered)
+        showProgressOverlay(ctx, { phase: 3, phaseName: "Synthesize", detail: "0/" + totalBatches + " batches", model: modelLabel, profile, extraction, totalBatches });
+      const caps = getProviderCaps(summaryModel.provider);
+      const concurrency = caps.concurrencyLimit;
+      if (totalBatches <= 1) {
+        try {
+          summaries.push(...await summarizeBatch(batches[0], extraction, summaryModel, { apiKey: auth.apiKey, headers: auth.headers }, signal));
+        } catch (err) {
+          summaries.push(...batches[0].map((ch) => ({
+            topic: ch.topic,
+            startIndex: ch.startIndex,
+            endIndex: ch.endIndex,
+            summary: "[Failed] " + ch.messages.map((m) => extractText(m.content)).join(`
+`).slice(0, 300),
+            keyDecisions: [],
+            filesModified: [],
+            filesRead: [],
+            priority: ch.priority
+          })));
+        }
+      } else {
+        const results = new Array(totalBatches);
+        const errors = new Array(totalBatches).fill(null);
+        let completed = 0;
+        for (let wave = 0;wave < totalBatches; wave += concurrency) {
+          const waveBatches = batches.slice(wave, Math.min(wave + concurrency, totalBatches));
+          const wavePromises = waveBatches.map(async (batch, i) => {
+            const idx = wave + i;
+            try {
+              results[idx] = await summarizeBatch(batch, extraction, summaryModel, { apiKey: auth.apiKey, headers: auth.headers }, signal);
+            } catch (err) {
+              errors[idx] = err instanceof Error ? err : new Error(String(err));
+              results[idx] = batch.map((ch) => ({
+                topic: ch.topic,
+                startIndex: ch.startIndex,
+                endIndex: ch.endIndex,
+                summary: "[Failed] " + ch.messages.map((m) => extractText(m.content)).join(`
+`).slice(0, 300),
+                keyDecisions: [],
+                filesModified: [],
+                filesRead: [],
+                priority: ch.priority
+              }));
+            }
+            completed++;
+            if (!autoTriggered)
+              showProgressOverlay(ctx, { phase: 3, phaseName: "Synthesize", detail: completed + "/" + totalBatches + " batches", model: modelLabel, profile, extraction, totalBatches, currentBatch: completed });
+          });
+          await Promise.all(wavePromises);
+        }
+        for (const r of results)
+          if (r)
+            summaries.push(...r);
+        for (let i = 0;i < errors.length; i++)
+          if (errors[i])
+            notify("Batch " + (i + 1) + " failed: " + errors[i].message, "warning");
+      }
+      if (!autoTriggered)
+        showProgressOverlay(ctx, { phase: 3, phaseName: "Synthesize", detail: "Assembling...", model: modelLabel, profile, extraction, totalBatches: batches.length });
+      let assemblyCalls = 1;
+      try {
+        const r = await assembleLLM(summaries, extraction, explorationReport, summaryModel, { apiKey: auth.apiKey, headers: auth.headers }, pc.summaryBudgetTokens, prevContext, signal);
+        if (r?.startsWith("##"))
+          finalSummary = r;
+        else
+          throw new Error("bad");
+      } catch (err) {
+        console.error("[smart-compact] Assembly failed:", err instanceof Error ? err.message : err);
+        finalSummary = assembleFallback(summaries, extraction);
+        assemblyCalls = 0;
+      }
+      method = "eesv";
+      llmCalls = explorationRounds + batches.length + assemblyCalls;
+    }
+    if (!autoTriggered)
+      showProgressOverlay(ctx, { phase: 4, phaseName: "Verify", detail: "Checking...", model: modelLabel, profile, extraction, explorationRounds });
+    const verification = verifySummary(finalSummary, extraction);
+    if (!verification.ok) {
+      if (verification.score < 85) {
+        notify("Phase 4 Verify: " + verification.gaps.length + " gap(s), score=" + verification.score + ", applying deterministic patch", "warning");
+        finalSummary = patchDeterministic(finalSummary, verification.gaps, extraction);
+        const recheck = verifySummary(finalSummary, extraction);
+        if (!recheck.ok && recheck.score < 75) {
+          notify("Phase 4 Verify: deterministic patch insufficient (score=" + recheck.score + "), trying LLM patch", "warning");
+          try {
+            finalSummary = await patchSummary(finalSummary, recheck.gaps, summaryModel, { apiKey: auth.apiKey, headers: auth.headers }, signal);
+            llmCalls++;
+          } catch (err) {
+            console.error("[smart-compact] LLM patch failed:", err instanceof Error ? err.message : err);
+          }
+        }
+      } else {
+        notify("Phase 4 Verify: " + verification.gaps.length + " gap(s), score=" + verification.score + " \u2265 85 \u2014 skipping patch", "info");
+      }
+    }
+    const detModified = extraction.modifiedFiles.map((f) => f.path);
+    const detRead = extraction.readFiles;
+    const estimatedAfter = estimateTokens(finalSummary) + accTokens;
+    const tokensSaved = Math.max(0, totalTokens - estimatedAfter);
+    const pipelineInfo = method === "eesv" ? "EESV: Extract > Explore (" + explorationRounds + "r) > Synthesize (" + (chunkCount || 1) + " chunks) > Verify (" + (verification.ok ? "pass" : verification.gaps.length + " gaps") + ")" : method + " (" + (chunkCount || 1) + " chunks, " + llmCalls + " calls)";
+    const pipelineMs = Date.now() - pipelineStart;
+    const durationStr = pipelineMs < 1000 ? pipelineMs + "ms" : (pipelineMs / 1000).toFixed(1) + "s";
+    notify("Done: " + pipelineInfo + " \u2014 saved " + (tokensSaved ?? 0).toLocaleString() + "t (" + durationStr + ")", "success");
+    const openLoops = extractOpenLoops(llmMessages, extraction);
+    if (openLoops.length > 0) {
+      notify("Open Loops: " + openLoops.length + " detected (" + openLoops.filter((l) => l.priority === "high").length + " high)", "info");
+      finalSummary = injectOpenLoopsSection(finalSummary, openLoops);
+    }
+    const nextActions = extractNextActions(finalSummary);
+    const criticalContextItems = extractCriticalContext(finalSummary);
+    const compactionState = buildCompactionState(extraction, openLoops, explorationReport, nextActions, criticalContextItems);
+    const prevState = loadCompactionState(projectId);
+    if (prevState) {
+      const delta = computeDelta(prevState, compactionState);
+      if (delta.newLoops.length || delta.resolvedLoops.length || delta.newDecisions.length || delta.newErrors.length || delta.newModifiedFiles.length) {
+        finalSummary = injectDeltaSection(finalSummary, delta);
+        notify("Delta: " + delta.newLoops.length + " new loops, " + delta.resolvedLoops.length + " resolved, " + delta.newModifiedFiles.length + " new files", "info");
+      }
+    }
+    const details = {
+      method,
+      chunkCount: chunkCount || 1,
+      topics: summaries.length ? summaries.map((s) => s.topic) : [method],
+      readFiles: detRead,
+      modifiedFiles: detModified,
+      totalMessages: toCompact.length,
+      totalTokensSummarized: convTokens,
+      llmCalls,
+      profile,
+      backupPath,
+      tokensSaved,
+      verified: verification.ok,
+      gaps: verification.gaps,
+      explorationRounds,
+      explorationBoundaries: explorationReport?.boundaries.length ?? 0,
+      model: modelLabel,
+      qualityScore: verification.score,
+      tokensBefore: totalTokens,
+      compactionState,
+      openLoops
+    };
+    if (dryRun) {
+      notify("DRY RUN (" + method + ", " + profile + ") \u2014 " + toCompact.length + " msgs, " + llmCalls + " calls", "info");
+      return;
+    }
+    pendingRef.value = { summary: finalSummary, firstKeptEntryId: firstKeptId, tokensBefore: totalTokens, details, compactionState };
+    pendingRef.createdAt = Date.now();
+    saveProjectFingerprint(projectId, extraction);
+    saveCompactionState(projectId, compactionState);
+    appendMetricsLog(sessionId);
+    try {
+      const postCompactMsgs = msgs.slice(keepFrom).map((e) => convertToLlm([e.message])).flat().map((m) => m);
+      if (postCompactMsgs.length > 2) {
+        const lastCompaction = branch.filter((e) => e.type === "compaction").slice(-1)[0];
+        if (lastCompaction?.details) {
+          const prevDetails = lastCompaction.details;
+          const damage = detectDamage(postCompactMsgs.slice(0, Math.min(15, postCompactMsgs.length)), prevDetails);
+          if (damage.damageScore > 0) {
+            notify("Previous compaction damage: " + damage.summary, "warning");
+          }
+          logDamageReport(sessionId, damage, prevDetails);
+        }
+      }
+    } catch (err) {
+      console.error("[smart-compact] Damage detection error:", err instanceof Error ? err.message : err);
+    }
+    const ms = getMetricsSummary();
+    if (ms.totalCalls > 0) {
+      notify("Metrics: " + ms.totalCalls + " calls, " + ms.totalInput + "t in, " + ms.totalOutput + "t out, cache " + Math.round(ms.cacheHitRate * 100) + "%, " + ms.avgLatency + "ms avg", "info");
+    }
+    if (!autoTriggered) {
+      try {
+        const timeout = new Promise((resolve) => setTimeout(resolve, 5000));
+        await Promise.race([showResultScreen(ctx, details, extraction), timeout]);
+      } catch (err) {
+        console.error("[smart-compact] Result screen error:", err instanceof Error ? err.message : err);
+        notify("Result screen skipped", "info");
+      }
+    }
+    if (!skipCompact) {
+      ctx.compact({
+        customInstructions: "Use pre-computed smart summary from /smart-compact",
+        onComplete: () => {
+          if (!autoTriggered)
+            ctx.ui.notify("Applied \u2713", "success");
+        },
+        onError: (e) => {
+          if (!autoTriggered)
+            ctx.ui.notify("Failed: " + e.message, "error");
+        }
+      });
+    }
+  } finally {
+    isRunning.value = false;
+    const pipelineMs = Date.now() - pipelineStart;
+    if (autoTriggered) {
+      ctx.ui.notify("Compaction completed in " + (pipelineMs < 1000 ? pipelineMs + "ms" : (pipelineMs / 1000).toFixed(1) + "s"), "info");
+    }
+  }
+}
+
+// src/index.ts
+function resolveModelArg(ctx, modelArg) {
+  const [p, ...r] = modelArg.split("/");
+  return ctx.modelRegistry.find(p, r.join("/"));
+}
+function resolveModels(ctx, primary, config) {
+  const fallback = primary ?? ctx.model;
+  const available = ctx.modelRegistry.getAvailable();
+  let sumModel = fallback;
+  const configuredSumModels = [config.summaryModel].filter(Boolean);
+  for (const modelId of configuredSumModels) {
+    const [p, ...r] = modelId.split("/");
+    const found = ctx.modelRegistry.find(p, r.join("/"));
+    if (found) {
+      sumModel = found;
+      break;
+    }
+  }
+  if (sumModel === fallback && !fallback)
+    sumModel = available[0];
+  let segModel = sumModel;
+  if (config.segmentationModel) {
+    const [p, ...r] = config.segmentationModel.split("/");
+    segModel = ctx.modelRegistry.find(p, r.join("/")) ?? sumModel;
+  }
+  return { segModel, sumModel };
+}
+function smartCompactExtension(pi) {
+  const pendingRef = { value: null, createdAt: 0 };
+  const isRunning = { value: false };
+  const PENDING_TTL_MS = 5 * 60 * 1000;
+  pi.registerCommand("smart-compact", {
+    description: "EESV smart compaction v" + VERSION + ". Usage: /smart-compact [model] [light|balanced|aggressive] [verbose|debug|dry-run] [note]",
+    getArgumentCompletions: (prefix) => {
+      const m = ["verbose", "debug", "dry-run", "light", "balanced", "aggressive"].filter((o) => o.startsWith(prefix)).map((o) => ({ value: o, label: o }));
+      return m.length ? m : null;
+    },
+    handler: async (args, ctx) => {
+      try {
+        const tokens = args.trim().split(/\s+/).filter(Boolean);
+        const flags = tokens.map((t) => t.toLowerCase());
+        const verbose = flags.includes("verbose") || flags.includes("debug");
+        const dryRun = flags.includes("dry-run");
+        const modelArg = tokens.find((t) => t.includes("/"));
+        const profileArg = tokens.find((t) => ["light", "balanced", "aggressive"].includes(t));
+        const profile = profileArg ?? loadConfig().profile;
+        if (!tokens.length) {
+          const usage = ctx.getContextUsage();
+          const totalTokens = usage?.tokens ?? 0;
+          const pct = ctx.model && totalTokens ? Math.round(totalTokens / ctx.model.contextWindow * 100) : 0;
+          if (!totalTokens || totalTokens < 5000) {
+            ctx.ui.notify("Context OK or unknown", "info");
+            return;
+          }
+          const cur = ctx.model;
+          const avail = ctx.modelRegistry.getAvailable();
+          const opts = avail.map((m) => ({ value: m.provider + "/" + m.id, label: m.provider + "/" + m.id + (m.contextWindow >= 200000 ? " (" + Math.round(m.contextWindow / 1000) + "K)" : ""), model: m }));
+          const defIdx = cur ? opts.findIndex((o) => o.value === cur.provider + "/" + cur.id) : 0;
+          const selected = await showCompactUI(ctx, { contextTokens: totalTokens, contextPercent: pct, currentModel: cur ? cur.provider + "/" + cur.id : "?", defaultModelIndex: defIdx >= 0 ? defIdx : 0 });
+          if (!selected) {
+            ctx.ui.notify("Cancelled", "info");
+            return;
+          }
+          const { segModel: segModel2, sumModel: sumModel2 } = resolveModels(ctx, selected.model.model, loadConfig());
+          if (!sumModel2) {
+            ctx.ui.notify("Could not resolve model", "error");
+            return;
+          }
+          await runSmartCompact(ctx, sumModel2, segModel2 ?? sumModel2, selected.profile, false, false, pendingRef, isRunning, false);
+          return;
+        }
+        const { segModel, sumModel } = resolveModels(ctx, modelArg ? resolveModelArg(ctx, modelArg) : ctx.model, loadConfig());
+        if (!sumModel) {
+          ctx.ui.notify("Could not resolve model", "error");
+          return;
+        }
+        const note = extractUserNote(args);
+        await runSmartCompact(ctx, sumModel, segModel ?? sumModel, profile, verbose, dryRun, pendingRef, isRunning, false, note);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message + `
+` + error.stack : String(error);
+        ctx.ui.notify("smart-compact error: " + msg, "error");
+      }
+    }
+  });
+  pi.on("session_before_compact", async (_event, ctx) => {
+    if (pendingRef.value) {
+      const age = Date.now() - pendingRef.createdAt;
+      if (age > PENDING_TTL_MS) {
+        pendingRef.value = null;
+        pendingRef.createdAt = 0;
+      } else {
+        const c = pendingRef.value;
+        pendingRef.value = null;
+        pendingRef.createdAt = 0;
+        return { compaction: { summary: c.summary, firstKeptEntryId: c.firstKeptEntryId, tokensBefore: c.tokensBefore, details: c.details } };
+      }
+    }
+    const config = loadConfig();
+    if (!config.autoTrigger)
+      return;
+    try {
+      const usage = ctx.getContextUsage();
+      const totalTokens = usage?.tokens ?? 0;
+      if (!totalTokens || totalTokens < 5000)
+        return;
+      const cur = ctx.model;
+      if (!cur)
+        return;
+      const { segModel, sumModel } = resolveModels(ctx, cur, config);
+      if (!sumModel)
+        return;
+      if (!isRunning.value) {
+        await runSmartCompact(ctx, sumModel, segModel ?? sumModel, config.profile, false, false, pendingRef, isRunning, true);
+        if (pendingRef.value) {
+          const c = pendingRef.value;
+          pendingRef.value = null;
+          pendingRef.createdAt = 0;
+          return { compaction: { summary: c.summary, firstKeptEntryId: c.firstKeptEntryId, tokensBefore: c.tokensBefore, details: c.details } };
+        }
+      }
+    } catch {}
+  });
+  pi.registerTool({
+    name: "smart_compact",
+    label: "Smart Compact",
+    description: "EESV smart compaction v" + VERSION + " with deterministic extraction, exploration, and verification.",
+    promptSnippet: "Smart compaction",
+    promptGuidelines: ["Use for long conversations.", "Prefer over default compact."],
+    parameters: {
+      type: "object",
+      properties: {
+        profile: { type: "string", description: "light, balanced, or aggressive" },
+        verbose: { type: "boolean" },
+        dry_run: { type: "boolean" }
+      }
+    },
+    async execute(_id, params, _sig, _onUp, ctx) {
+      const profile = params.profile === "light" || params.profile === "balanced" || params.profile === "aggressive" ? params.profile : undefined;
+      const verbose = !!params.verbose;
+      const dryRun = !!params.dry_run;
+      const config = loadConfig();
+      const resolvedProfile = profile ?? config.profile;
+      const cur = "model" in ctx ? ctx.model : undefined;
+      const { segModel, sumModel } = resolveModels(ctx, cur, config);
+      if (!sumModel) {
+        return { content: [{ type: "text", text: "Error: Could not resolve model." }] };
+      }
+      try {
+        const toolStart = Date.now();
+        await runSmartCompact(ctx, sumModel, segModel ?? sumModel, resolvedProfile, verbose, dryRun, pendingRef, isRunning, true, undefined, true);
+        const toolSecs = ((Date.now() - toolStart) / 1000).toFixed(1);
+        if (pendingRef.value) {
+          return { content: [{ type: "text", text: "Smart summary generated (" + resolvedProfile + "). Tokens: " + (pendingRef.value.tokensBefore ?? "?") + " -> " + (pendingRef.value.summary?.length ?? 0) + " chars (" + toolSecs + `s).
+
+Now run tree compact to apply \u2014 the session_before_compact hook will use this summary.
+TTL: ` + Math.round(PENDING_TTL_MS / 60000) + " minutes." }] };
+        }
+        return { content: [{ type: "text", text: "Compaction finished (" + resolvedProfile + ") but no summary was generated." }] };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: "Compaction error: " + msg }] };
+      }
+    }
+  });
+}
+function extractUserNote(args) {
+  const SKIP = new Set(["verbose", "debug", "dry-run", "light", "balanced", "aggressive"]);
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  const nonFlags = tokens.filter((t) => !t.includes("/") && !SKIP.has(t.toLowerCase()));
+  return nonFlags.length > 0 ? nonFlags.join(" ") : undefined;
+}
+export {
+  smartCompactExtension as default
+};