min-agent 0.3.0 → 0.4.0

package/dist/compaction.js

@@ -1,7 +1,7 @@
 import { generateText } from "ai";
-import { loadConfig, getActiveProvider } from "./config.js";
+import { getEffectiveConfig } from "./config.js";
 import { resolveModel } from "./provider.js";
-import { getContextWindow } from "./context-window.js";
+import { getContextWindowInfo, DEFAULT_CONTEXT_WINDOW } from "./context-window.js";
 import { collectLoadedSkillNames, buildSkillReloadNote } from "./skills.js";
 /**
  * Context compaction system — modeled after opencode's SessionCompaction.
@@ -42,7 +42,7 @@ const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown below. Kee
 - [ordered next actions or "(none)"]
 
 ## Critical Context
-- [important technical facts, errors, open questions, or "(none)"]
+- [important technical facts, numbers, dates, scores, URLs, errors, open questions, or "(none)"]
 
 ## Relevant Files
 - [file or directory path: why it matters, or "(none)"]
@@ -53,14 +53,23 @@ Rules:
 - Preserve exact file paths, commands, error strings, and identifiers when known.
 - Do not mention the summary process or that context was compacted.`;
 // ─── Constants ─────────────────────────────────────────────────────────────
-const DEFAULT_MAX_TOKENS = 128000;
-const COMPACTION_RATIO = 0.75;
+export const COMPACTION_RATIO = 0.75;
+/** Start pruning old tool payloads only once the context is this full. */
+export const PRUNE_PRESSURE_RATIO = 0.6;
+/** Prune (largest first) until the estimate is back under this. */
+export const PRUNE_TARGET_RATIO = 0.45;
 const DEFAULT_TAIL_TURNS = 2;
-const TAIL_TOKEN_BUDGET_RATIO = 0.25;
+const TAIL_TOKEN_BUDGET_RATIO = 0.04;
 const MIN_TAIL_BUDGET = 2000;
-const MAX_TAIL_BUDGET = 8000;
-const PRUNE_PROTECT_TOKENS = 24000;
-const TOOL_OUTPUT_MAX_CHARS = 2000;
+const MAX_TAIL_BUDGET = 48000;
+const KEEP_RECENT_ASSISTANT_UNITS = 4;
+const TOOL_RESULT_STUB_CHARS = 400;
+const TOOL_CALL_STRING_MAX = 500;
+const SUMMARIZE_TOOL_CHARS = 400;
+const SUMMARIZE_RESEARCH_CHARS = 2500;
+const MAX_SUMMARIZE_CHARS = 100_000;
+const OMITTED_TOOL_MARKER = "old tool output omitted";
+const RESEARCH_SUMMARY_TOOLS = new Set(["search_web", "web_fetch"]);
 /** Tools whose output should never be pruned during compaction */
 const PRUNE_PROTECTED_TOOLS = new Set(["skill"]);
 // ─── Token Tracker ─────────────────────────────────────────────────────────
@@ -68,20 +77,29 @@ export class TokenTracker {
     _lastInputTokens = 0;
     _totalOutputTokens = 0;
     _totalInputTokens = 0;
-    _totalCacheRead = 0;
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener();
+    }
     update(usage) {
-        this.add(usage);
+        this._totalInputTokens += usage.inputTokens ?? 0;
+        this._totalOutputTokens += usage.outputTokens ?? 0;
         this._lastInputTokens = usage.inputTokens ?? 0;
+        this.emit();
     }
     /** Add to running totals only (e.g. compaction / sub-agent calls), without
      * touching the "last step input" used for context-window display. */
     add(usage) {
-        const input = usage.inputTokens ?? 0;
-        const output = usage.outputTokens ?? 0;
-        const cacheRead = usage.cachedInputTokens ?? 0;
-        this._totalInputTokens += input;
-        this._totalOutputTokens += output;
-        this._totalCacheRead += cacheRead;
+        this._totalInputTokens += usage.inputTokens ?? 0;
+        this._totalOutputTokens += usage.outputTokens ?? 0;
+        this.emit();
     }
     get lastInputTokens() {
         return this._lastInputTokens;
@@ -95,8 +113,15 @@ export class TokenTracker {
     summary() {
         return `context: ${this._lastInputTokens} | total in: ${this._totalInputTokens} out: ${this._totalOutputTokens}`;
     }
+    reset() {
+        this._lastInputTokens = 0;
+        this._totalInputTokens = 0;
+        this._totalOutputTokens = 0;
+        this.emit();
+    }
     resetContext() {
         this._lastInputTokens = 0;
+        this.emit();
     }
 }
 // ─── Token Estimation ──────────────────────────────────────────────────────
@@ -120,6 +145,22 @@ function estimateTextTokens(text) {
     }
     return ascii / 4 + other * 0.7;
 }
+const IMAGE_TOKEN_ESTIMATE = 800;
+function estimatePartTokens(part) {
+    if (typeof part.text === "string")
+        return estimateTextTokens(part.text);
+    if (part.type === "image" || part.type === "file")
+        return IMAGE_TOKEN_ESTIMATE;
+    if (part.type === "tool-call" && part.input !== undefined) {
+        try {
+            return estimateTextTokens(JSON.stringify(part.input));
+        }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+}
 function estimateMessageTextTokens(msg) {
     const content = msg.content;
     if (typeof content === "string")
@@ -127,9 +168,12 @@ function estimateMessageTextTokens(msg) {
     if (Array.isArray(content)) {
         let tokens = 0;
         for (const part of content) {
-            if ("text" in part && typeof part.text === "string") {
-                tokens += estimateTextTokens(part.text);
+            if (isToolResultPart(part)) {
+                const text = toolResultText(part);
+                tokens += text ? estimateTextTokens(text) : 0;
+                continue;
             }
+            tokens += estimatePartTokens(part);
         }
         return tokens;
     }
@@ -139,38 +183,68 @@ function estimateMessageTextTokens(msg) {
 export function estimateTokens(messages) {
     return Math.ceil(messages.reduce((sum, msg) => sum + estimateMessageTextTokens(msg), 0));
 }
+/** Same estimator for a plain string (assistant text, tool-call JSON, …). */
+export function estimateStringTokens(text) {
+    return Math.ceil(estimateTextTokens(text));
+}
 function estimateMessageTokens(msg) {
     return Math.ceil(estimateMessageTextTokens(msg));
 }
+/**
+ * Tokens spent on everything that is not in `messages`: the system prompt and
+ * the JSON schema of every tool. This is routinely 10k+ tokens with skills and
+ * MCP servers attached, so leaving it out makes every threshold too generous.
+ */
+export function estimateOverheadTokens(systemPrompt, tools) {
+    let tokens = estimateTextTokens(systemPrompt);
+    for (const [name, tool] of Object.entries(tools ?? {})) {
+        tokens += estimateTextTokens(name);
+        const t = tool;
+        if (typeof t?.description === "string")
+            tokens += estimateTextTokens(t.description);
+        const schema = t?.inputSchema ?? t?.parameters;
+        if (schema != null) {
+            try {
+                tokens += estimateTextTokens(JSON.stringify(schema));
+            }
+            catch {
+                /* non-serializable schema — skip */
+            }
+        }
+    }
+    return Math.ceil(tokens);
+}
 // ─── Compaction Check ──────────────────────────────────────────────────────
 /**
- * Resolve max tokens: explicit user config first, then model-aware detection.
+ * Resolve context window: explicit override, then model-aware detection.
+ * Undetected models use 512k.
  */
-async function resolveMaxTokens() {
-    const cfg = loadConfig();
-    const provider = getActiveProvider(cfg);
-    if (provider?.contextWindow)
-        return provider.contextWindow;
+async function resolveWindow(config) {
+    if (config?.maxTokens)
+        return { tokens: config.maxTokens, source: "config" };
     try {
-        return await getContextWindow(provider?.defaultModel);
+        return await getContextWindowInfo(config?.modelId);
     }
     catch {
-        return DEFAULT_MAX_TOKENS;
+        return { tokens: DEFAULT_CONTEXT_WINDOW, source: "fallback" };
     }
 }
 /**
- * Check if compaction is needed.
- * Uses model-aware context window (user config or provider detection).
+ * Check if LLM summarization is needed.
+ * Uses configured or detected window; otherwise 512k.
  */
 export async function needsCompaction(messages, tracker, config) {
-    const maxTokens = config?.maxTokens ?? await resolveMaxTokens();
-    const threshold = maxTokens * COMPACTION_RATIO;
+    if (config?.force)
+        return true;
+    const window = await resolveWindow(config);
+    const threshold = window.tokens * COMPACTION_RATIO;
+    const overhead = config?.overheadTokens ?? 0;
     if (tracker && tracker.lastInputTokens > 0) {
+        // Reported input tokens already include the system prompt and tool schemas.
         return tracker.lastInputTokens > threshold;
     }
-    return estimateTokens(messages) > threshold;
+    return estimateTokens(messages) + overhead > threshold;
 }
-// ─── Tool Output Pruning ───────────────────────────────────────────────────
 function toolResultText(part) {
     const out = part.output;
     if (typeof out === "string")
@@ -182,93 +256,203 @@ function toolResultText(part) {
     }
     return null;
 }
+function isOmittedToolOutput(text) {
+    return text.includes(OMITTED_TOOL_MARKER);
+}
+/** Keep the "full output saved to <path>" hint alive so the model can re-read it. */
+function savedPathHint(text) {
+    const match = /Full output saved to:\s*(\S+)/.exec(text);
+    return match ? `, full output: ${match[1]}` : "";
+}
+function stubToolOutput(toolName, text) {
+    return `[${OMITTED_TOOL_MARKER}: ${toolName}, ${text.length} chars${savedPathHint(text)}]`;
+}
+function truncateToolCallValue(value) {
+    if (typeof value === "string") {
+        if (value.length <= TOOL_CALL_STRING_MAX)
+            return value;
+        return `${value.slice(0, TOOL_CALL_STRING_MAX)}\n\n[... ${value.length - TOOL_CALL_STRING_MAX} chars omitted from old tool call ...]`;
+    }
+    if (Array.isArray(value))
+        return value.map(truncateToolCallValue);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, truncateToolCallValue(v)]));
+    }
+    return value;
+}
 function isProtectedToolMessage(msg) {
     if (typeof msg.content === "string") {
         return msg.content.includes("<skill_content");
     }
     if (Array.isArray(msg.content)) {
-        return msg.content.some((p) => p.type === "tool-result" &&
+        return msg.content.some((p) => (p.type === "tool-result" || p.type === "tool-call") &&
+            "toolName" in p &&
             PRUNE_PROTECTED_TOOLS.has(p.toolName));
     }
     return false;
 }
+function unitStarts(messages) {
+    const starts = [];
+    for (let i = 0; i < messages.length; i++) {
+        const role = messages[i].role;
+        if (role === "user" || role === "assistant")
+            starts.push(i);
+    }
+    return starts;
+}
+function assistantStarts(messages) {
+    const starts = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i].role === "assistant")
+            starts.push(i);
+    }
+    return starts;
+}
+/** Keep the last few assistant+tool steps intact so the model can see recent work. */
+function protectFromIndex(messages) {
+    const starts = assistantStarts(messages);
+    if (starts.length <= KEEP_RECENT_ASSISTANT_UNITS)
+        return 0;
+    return starts[starts.length - KEEP_RECENT_ASSISTANT_UNITS];
+}
+function pruneToolResultMessage(msg) {
+    if (msg.role !== "tool" || !Array.isArray(msg.content) || isProtectedToolMessage(msg))
+        return null;
+    const parts = [...msg.content];
+    let changed = false;
+    for (let j = 0; j < parts.length; j++) {
+        const p = parts[j];
+        if (p.type !== "tool-result")
+            continue;
+        const text = toolResultText(p);
+        if (!text || isOmittedToolOutput(text) || text.length <= TOOL_RESULT_STUB_CHARS)
+            continue;
+        parts[j] = { ...p, output: { type: "text", value: stubToolOutput(p.toolName, text) } };
+        changed = true;
+    }
+    return changed ? { ...msg, content: parts } : null;
+}
+function pruneAssistantToolCalls(msg) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content) || isProtectedToolMessage(msg))
+        return null;
+    const parts = [...msg.content];
+    let changed = false;
+    for (let j = 0; j < parts.length; j++) {
+        const p = parts[j];
+        if (p.type !== "tool-call" || p.input === undefined)
+            continue;
+        const next = truncateToolCallValue(p.input);
+        let unchanged = next === p.input;
+        if (!unchanged) {
+            try {
+                unchanged = JSON.stringify(next) === JSON.stringify(p.input);
+            }
+            catch {
+                unchanged = false;
+            }
+        }
+        if (unchanged)
+            continue;
+        parts[j] = { ...p, input: next };
+        changed = true;
+    }
+    return changed ? { ...msg, content: parts } : null;
+}
 /**
- * Return a copy of messages with old tool outputs truncated to free context space.
- * Keeps recent tool results intact, trims older ones.
- * Protects skill tool results from pruning.
+ * Return a copy of messages with old tool payloads stubbed.
+ * Recent assistant steps stay intact. Skill results are never pruned.
  * Does not mutate the input.
+ *
+ * Without a token budget (or with `force`) every prunable payload outside the
+ * recent window is stubbed. With a budget, pruning is pressure driven: nothing
+ * happens below `pressureTokens`, and above it the biggest payloads go first
+ * until the estimate is back under `targetTokens` — so a long session with a
+ * roomy context window keeps its tool output.
  */
-export function pruneToolOutputs(messages) {
-    let totalTokens = 0;
-    let turns = 0;
-    const replaced = new Map();
-    for (let i = messages.length - 1; i >= 0; i--) {
+export function pruneToolOutputs(messages, options = {}) {
+    const protectFrom = protectFromIndex(messages);
+    const candidates = [];
+    for (let i = 0; i < protectFrom; i++) {
         const msg = messages[i];
-        if (msg.role === "user")
-            turns++;
-        if (turns < 2)
-            continue;
-        if (msg.role !== "tool")
-            continue;
-        if (isProtectedToolMessage(msg))
+        const pruned = msg.role === "tool" ? pruneToolResultMessage(msg) : msg.role === "assistant" ? pruneAssistantToolCalls(msg) : null;
+        if (!pruned)
             continue;
-        const parts = [...msg.content];
-        let changed = false;
-        for (let j = 0; j < parts.length; j++) {
-            const p = parts[j];
-            if (p.type !== "tool-result")
-                continue;
-            const text = toolResultText(p);
-            if (!text)
+        candidates.push({
+            index: i,
+            pruned,
+            tokensSaved: Math.max(0, estimateMessageTokens(msg) - estimateMessageTokens(pruned)),
+        });
+    }
+    if (candidates.length === 0)
+        return messages;
+    const pressure = options.pressureTokens ?? options.targetTokens;
+    const replaced = new Map();
+    if (options.force || pressure == null) {
+        for (const c of candidates)
+            replaced.set(c.index, c.pruned);
+    }
+    else {
+        let estimate = estimateTokens(messages) + (options.overheadTokens ?? 0);
+        if (estimate <= pressure)
+            return messages;
+        const goal = options.targetTokens ?? pressure;
+        for (const c of [...candidates].sort((a, b) => b.tokensSaved - a.tokensSaved)) {
+            if (estimate <= goal)
+                break;
+            if (c.tokensSaved <= 0)
                 continue;
-            totalTokens += estimateTextTokens(text);
-            if (totalTokens > PRUNE_PROTECT_TOKENS && text.length > TOOL_OUTPUT_MAX_CHARS) {
-                const truncated = text.slice(0, TOOL_OUTPUT_MAX_CHARS) + "\n\n[... output truncated during compaction ...]";
-                parts[j] = { ...p, output: { type: "text", value: truncated } };
-                changed = true;
-            }
+            replaced.set(c.index, c.pruned);
+            estimate -= c.tokensSaved;
         }
-        if (changed)
-            replaced.set(i, { ...msg, content: parts });
     }
     if (replaced.size === 0)
         return messages;
     return messages.map((msg, i) => replaced.get(i) ?? msg);
 }
+/** Replace `messages` in place when old tool payloads can be dropped. */
+export function applyToolPrune(messages, options = {}) {
+    const pruned = pruneToolOutputs(messages, options);
+    if (pruned === messages)
+        return false;
+    messages.length = 0;
+    messages.push(...pruned);
+    return true;
+}
 /**
  * Select how many recent turns to keep verbatim based on token budget.
  */
 async function selectTail(messages, config) {
-    const maxTokens = config?.maxTokens ?? await resolveMaxTokens();
-    const tailTurns = config?.keepRecentTurns ?? DEFAULT_TAIL_TURNS;
-    const budget = Math.min(MAX_TAIL_BUDGET, Math.max(MIN_TAIL_BUDGET, Math.floor(maxTokens * TAIL_TOKEN_BUDGET_RATIO)));
-    const turnStarts = [];
-    for (let i = 0; i < messages.length; i++) {
-        if (messages[i].role === "user")
-            turnStarts.push(i);
-    }
-    if (turnStarts.length <= 1) {
+    const window = await resolveWindow(config);
+    const budget = Math.min(MAX_TAIL_BUDGET, Math.max(MIN_TAIL_BUDGET, Math.floor(window.tokens * TAIL_TOKEN_BUDGET_RATIO)));
+    const starts = unitStarts(messages);
+    if (starts.length === 0) {
         return { headEnd: 0, tailStart: 0 };
     }
     let tokensUsed = 0;
     let tailStart = messages.length;
-    const recentTurns = turnStarts.slice(-tailTurns);
-    for (let i = recentTurns.length - 1; i >= 0; i--) {
-        const turnStart = recentTurns[i];
-        const turnEnd = i < recentTurns.length - 1 ? recentTurns[i + 1] : messages.length;
-        let turnTokens = 0;
-        for (let j = turnStart; j < turnEnd; j++) {
-            turnTokens += estimateMessageTokens(messages[j]);
+    for (let i = starts.length - 1; i >= 0; i--) {
+        const unitStart = starts[i];
+        const unitEnd = i < starts.length - 1 ? starts[i + 1] : messages.length;
+        let unitTokens = 0;
+        for (let j = unitStart; j < unitEnd; j++) {
+            unitTokens += estimateMessageTokens(messages[j]);
         }
-        if (tokensUsed + turnTokens > budget && tokensUsed > 0)
+        if (tokensUsed + unitTokens > budget && tokensUsed > 0)
             break;
-        tokensUsed += turnTokens;
-        tailStart = turnStart;
+        tokensUsed += unitTokens;
+        tailStart = unitStart;
     }
     if (tailStart >= messages.length)
-        tailStart = messages.length - 2;
-    if (tailStart < 0)
-        tailStart = 0;
+        tailStart = starts[starts.length - 1];
+    const keepUsers = config?.keepRecentTurns ?? DEFAULT_TAIL_TURNS;
+    const userStarts = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i].role === "user")
+            userStarts.push(i);
+    }
+    if (tailStart === 0 && userStarts.length > keepUsers) {
+        tailStart = userStarts[userStarts.length - keepUsers];
+    }
     return { headEnd: tailStart, tailStart };
 }
 // ─── Compaction Agent ──────────────────────────────────────────────────────
@@ -278,7 +462,9 @@ Summarize only the conversation history you are given. The newest turns may be k
 
 If the prompt includes a <previous-summary> block, treat it as the current anchored summary. Update it with the new history by preserving still-true details, removing stale details, and merging in new facts.
 
-Always follow the exact output structure requested by the user prompt. Keep every section, preserve exact file paths and identifiers when known, and prefer terse bullets over paragraphs.
+Always follow the exact output structure requested by the user prompt. Keep every section, preserve exact file paths, identifiers, numeric scores, dates, and URLs when known, and prefer terse bullets over paragraphs.
+
+When the history includes web search or fetched pages, copy concrete facts (names, scores, dates, URLs) into Critical Context. Do not drop numbers.
 
 Do not answer the conversation itself. Do not mention that you are summarizing, compacting, or merging context. Respond in the same language as the conversation.`;
 /**
@@ -287,7 +473,7 @@ Do not answer the conversation itself. Do not mention that you are summarizing,
  * Otherwise falls back to the main model.
  */
 function resolveCompactionModel(mainModel) {
-    const cfg = loadConfig();
+    const cfg = getEffectiveConfig();
     const compactionModelId = cfg.compaction?.model;
     if (compactionModelId) {
         return resolveModel(compactionModelId);
@@ -314,10 +500,16 @@ function extractNotedSkills(messages) {
     return section
         .split("\n")
         .filter((line) => line.startsWith("- "))
-        .map((line) => line.slice(2).replace(/\s*\(base dir:.*$/, "").trim())
+        .map((line) => line
+        .slice(2)
+        .replace(/\s*\(base dir:.*$/, "")
+        .trim())
         .filter(Boolean);
 }
-function buildCompactionPrompt(previousSummary) {
+function buildCompactionPrompt(previousSummary, taskGoal) {
+    const goal = taskGoal?.trim()
+        ? ["The original user goal that must be preserved in ## Goal:", taskGoal.trim(), ""].join("\n")
+        : "";
     const anchor = previousSummary
         ? [
             "Update the anchored summary below using the conversation history above.",
@@ -328,11 +520,19 @@ function buildCompactionPrompt(previousSummary) {
             "</previous-summary>",
         ].join("\n")
         : "Create a new anchored summary from the conversation history above.";
-    return [anchor, "", SUMMARY_TEMPLATE].join("\n");
+    return [goal, anchor, "", SUMMARY_TEMPLATE].filter(Boolean).join("\n");
 }
 function isToolResultPart(p) {
     return typeof p === "object" && p !== null && "type" in p && p.type === "tool-result";
 }
+function clipForSummary(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}\n[... ${text.length - max} chars omitted ...]`;
+}
+function clipLimitForTool(name) {
+    return RESEARCH_SUMMARY_TOOLS.has(name) ? SUMMARIZE_RESEARCH_CHARS : SUMMARIZE_TOOL_CHARS;
+}
 function messageToText(msg) {
     if (typeof msg.content === "string")
         return msg.content;
@@ -342,40 +542,62 @@ function messageToText(msg) {
             if ("text" in p && typeof p.text === "string") {
                 parts.push(p.text);
             }
-            else if (isToolResultPart(p)) {
-                const out = p.output;
-                if (typeof out === "string") {
-                    parts.push(out);
+            else if (p.type === "tool-call") {
+                const name = "toolName" in p ? String(p.toolName) : "tool";
+                let input = "";
+                try {
+                    input = JSON.stringify("input" in p ? p.input : undefined);
                 }
-                else if ("value" in out && out.value != null) {
-                    parts.push(String(out.value));
-                }
-                else {
-                    parts.push(JSON.stringify(out));
+                catch {
+                    input = "";
                 }
+                parts.push(`[tool-call ${name}] ${clipForSummary(input, clipLimitForTool(name))}`);
+            }
+            else if (isToolResultPart(p)) {
+                const name = p.toolName || "tool";
+                const out = p.output;
+                const raw = typeof out === "string"
+                    ? out
+                    : out && typeof out === "object" && "value" in out && out.value != null
+                        ? String(out.value)
+                        : JSON.stringify(out);
+                parts.push(`[tool-result ${name}] ${clipForSummary(raw, clipLimitForTool(name))}`);
             }
         }
         return parts.join("\n");
     }
     return "";
 }
-/** Check if a message contains media (images, etc.) */
-function hasMedia(msg) {
-    if (!Array.isArray(msg.content))
-        return false;
-    return msg.content.some((p) => p.type === "image" || p.type === "file");
+function conversationForSummary(messages) {
+    const text = messages.map((msg) => `[${msg.role}]: ${clipForSummary(messageToText(msg), 1500)}`).join("\n\n");
+    if (text.length <= MAX_SUMMARIZE_CHARS)
+        return text;
+    const keep = Math.floor((MAX_SUMMARIZE_CHARS - 40) / 2);
+    return `${text.slice(0, keep)}\n\n[... middle omitted ...]\n\n${text.slice(-keep)}`;
 }
-/** Extract text-only content from a message (strip media) */
-function extractTextOnly(msg) {
-    if (typeof msg.content === "string")
-        return msg.content;
-    if (Array.isArray(msg.content)) {
-        return msg.content
-            .filter((p) => p.type === "text")
-            .map((p) => p.text)
-            .join("\n");
+/**
+ * Summarize with one retry: losing the summary means falling back to plain
+ * pruning, which throws away far more context than a second attempt costs.
+ */
+async function summarizeWithRetry(model, prompt, config) {
+    const attempt = () => generateText({
+        model,
+        system: COMPACTION_AGENT_SYSTEM,
+        messages: [{ role: "user", content: prompt }],
+        abortSignal: config?.abortSignal,
+    });
+    try {
+        const first = await attempt();
+        if (first.text.trim())
+            return first;
+        console.error("[compaction] empty summary, retrying once");
     }
-    return "";
+    catch (err) {
+        if (config?.abortSignal?.aborted)
+            throw err;
+        console.error("[compaction] summary attempt failed, retrying once:", err);
+    }
+    return attempt();
 }
 /**
  * Compact messages by summarizing older history with structured template.
@@ -383,40 +605,19 @@ function extractTextOnly(msg) {
  * and overflow replay.
  */
 export async function compactMessages(messages, model, config) {
-    const cfg = loadConfig();
-    const autoContinue = config?.autoContinue ?? cfg.compaction?.autoContinue ?? true;
-    // Step 1: Prune old tool results (skip skill results)
-    const pruned = pruneToolOutputs(messages);
-    // Step 2: Select tail (recent turns to keep verbatim)
+    const pruned = pruneToolOutputs(messages, { force: true });
+    const pruneOnly = () => pruned === messages ? { messages, compacted: false } : { messages: pruned, compacted: true };
     const { headEnd, tailStart } = await selectTail(pruned, config);
-    if (headEnd <= 1) {
-        return { messages, compacted: false, shouldContinue: false };
-    }
+    if (headEnd <= 0)
+        return pruneOnly();
     const toSummarize = pruned.slice(0, headEnd);
     const toKeep = pruned.slice(tailStart);
-    // Step 3: Check for previous summary (incremental)
     const previousSummary = extractPreviousSummary(toSummarize);
-    // Step 4: Build conversation text for summarization
-    const conversationText = toSummarize
-        .map((msg) => {
-        const role = msg.role;
-        const text = messageToText(msg);
-        return `[${role}]: ${text.slice(0, 3000)}`;
-    })
-        .join("\n\n");
-    // Step 5: Resolve compaction model (may differ from main model)
+    const conversationText = conversationForSummary(toSummarize);
     const compactionModel = resolveCompactionModel(model);
-    // Step 6: Generate structured summary
     try {
-        const prompt = buildCompactionPrompt(previousSummary);
-        const result = await generateText({
-            model: compactionModel,
-            system: COMPACTION_AGENT_SYSTEM,
-            messages: [
-                { role: "user", content: conversationText + "\n\n" + prompt },
-            ],
-            abortSignal: config?.abortSignal,
-        });
+        const prompt = buildCompactionPrompt(previousSummary, config?.taskGoal);
+        const result = await summarizeWithRetry(compactionModel, conversationText + "\n\n" + prompt, config);
         const summary = result.text;
         const stillPresent = collectLoadedSkillNames(toKeep);
         const droppedSkills = [
@@ -430,28 +631,14 @@ export async function compactMessages(messages, model, config) {
             },
             ...toKeep,
         ];
-        // Step 7: If the last user message (in the kept tail) had media, provide replay text
-        let replayText;
-        let lastUserMsg;
-        for (let i = toKeep.length - 1; i >= 0; i--) {
-            if (toKeep[i].role === "user") {
-                lastUserMsg = toKeep[i];
-                break;
-            }
-        }
-        if (lastUserMsg && hasMedia(lastUserMsg)) {
-            replayText = extractTextOnly(lastUserMsg);
-        }
         return {
             messages: compactedMessages,
             compacted: true,
-            shouldContinue: autoContinue,
-            replayText,
             usage: result.usage,
         };
     }
     catch (error) {
-        console.error("[compaction] summary generation failed, keeping original messages:", error);
-        return { messages, compacted: false, shouldContinue: false };
+        console.error("[compaction] summary generation failed, keeping pruned messages:", error);
+        return pruneOnly();
     }
 }