min-agent 0.2.1 → 0.4.0

package/dist/compaction.js

@@ -1,6 +1,8 @@
 import { generateText } from "ai";
-import { loadConfig } from "./config.js";
+import { getEffectiveConfig } from "./config.js";
 import { resolveModel } from "./provider.js";
+import { getContextWindowInfo, DEFAULT_CONTEXT_WINDOW } from "./context-window.js";
+import { collectLoadedSkillNames, buildSkillReloadNote } from "./skills.js";
 /**
  * Context compaction system — modeled after opencode's SessionCompaction.
  *
@@ -40,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)"]
@@ -51,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 = 40000;
-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 ─────────────────────────────────────────────────────────
@@ -66,15 +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) {
-        const input = usage.inputTokens ?? 0;
-        const output = usage.outputTokens ?? 0;
-        const cacheRead = usage.cachedInputTokens ?? 0;
-        this._lastInputTokens = input;
-        this._totalInputTokens += input;
-        this._totalOutputTokens += output;
-        this._totalCacheRead += cacheRead;
+        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) {
+        this._totalInputTokens += usage.inputTokens ?? 0;
+        this._totalOutputTokens += usage.outputTokens ?? 0;
+        this.emit();
     }
     get lastInputTokens() {
         return this._lastInputTokens;
@@ -88,138 +113,346 @@ 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 ──────────────────────────────────────────────────────
-/** Token estimation: ~4 chars per token (aligned with opencode) */
-export function estimateTokens(messages) {
-    let chars = 0;
-    for (const msg of messages) {
-        if (typeof msg.content === "string") {
-            chars += msg.content.length;
+function isCjk(code) {
+    return ((code >= 0x2e80 && code <= 0x9fff) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xff00 && code <= 0xffef) ||
+        (code >= 0x20000 && code <= 0x3fffd) ||
+        (code >= 0x3040 && code <= 0x30ff) ||
+        (code >= 0xac00 && code <= 0xd7af));
+}
+/** ~4 ASCII chars per token, CJK chars weighted separately (much denser in tokens). */
+function estimateTextTokens(text) {
+    let ascii = 0;
+    let other = 0;
+    for (const ch of text) {
+        if (isCjk(ch.codePointAt(0) ?? 0))
+            other++;
+        else
+            ascii++;
+    }
+    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));
         }
-        else if (Array.isArray(msg.content)) {
-            for (const part of msg.content) {
-                if ("text" in part && typeof part.text === "string") {
-                    chars += part.text.length;
-                }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+}
+function estimateMessageTextTokens(msg) {
+    const content = msg.content;
+    if (typeof content === "string")
+        return estimateTextTokens(content);
+    if (Array.isArray(content)) {
+        let tokens = 0;
+        for (const part of content) {
+            if (isToolResultPart(part)) {
+                const text = toolResultText(part);
+                tokens += text ? estimateTextTokens(text) : 0;
+                continue;
             }
+            tokens += estimatePartTokens(part);
         }
+        return tokens;
     }
-    return Math.ceil(chars / 4);
+    return 0;
+}
+/** Token estimation: ASCII ~4 chars/token, CJK ~0.7 token/char (aligned with opencode) */
+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) {
-    if (typeof msg.content === "string")
-        return Math.ceil(msg.content.length / 4);
-    if (Array.isArray(msg.content)) {
-        let chars = 0;
-        for (const part of msg.content) {
-            if ("text" in part && typeof part.text === "string")
-                chars += part.text.length;
+    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(chars / 4);
     }
-    return 0;
+    return Math.ceil(tokens);
 }
 // ─── Compaction Check ──────────────────────────────────────────────────────
 /**
- * Check if compaction is needed.
- * Uses model-aware context window from config or getContextWindow cache.
+ * Resolve context window: explicit override, then model-aware detection.
+ * Undetected models use 512k.
  */
-export function needsCompaction(messages, tracker, config) {
-    const maxTokens = config?.maxTokens ?? getMaxTokensFromConfig();
-    const threshold = maxTokens * COMPACTION_RATIO;
+async function resolveWindow(config) {
+    if (config?.maxTokens)
+        return { tokens: config.maxTokens, source: "config" };
+    try {
+        return await getContextWindowInfo(config?.modelId);
+    }
+    catch {
+        return { tokens: DEFAULT_CONTEXT_WINDOW, source: "fallback" };
+    }
+}
+/**
+ * Check if LLM summarization is needed.
+ * Uses configured or detected window; otherwise 512k.
+ */
+export async function needsCompaction(messages, tracker, config) {
+    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;
 }
-/** Get max tokens from user config (model-aware) */
-function getMaxTokensFromConfig() {
-    const cfg = loadConfig();
-    return cfg.provider?.contextWindow ?? DEFAULT_MAX_TOKENS;
+function toolResultText(part) {
+    const out = part.output;
+    if (typeof out === "string")
+        return out;
+    if (out && typeof out === "object" && "value" in out) {
+        const v = out.value;
+        if (typeof v === "string")
+            return v;
+    }
+    return null;
 }
-// ─── Tool Output Pruning ───────────────────────────────────────────────────
-/**
- * Prune old tool outputs in-place to free context space.
- * Keeps recent tool outputs intact, trims older ones.
- * Protects skill tool outputs from pruning.
- * Returns the estimated tokens saved.
- */
-export function pruneToolOutputs(messages) {
-    let totalTokens = 0;
-    let saved = 0;
-    let turns = 0;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role === "user")
-            turns++;
-        if (turns < 2)
-            continue;
-        // Check if this is a tool result
-        if (msg.role === "tool" || (Array.isArray(msg.content) && msg.content.some((p) => p.type === "tool-result"))) {
-            // Skip protected tools (skill results are never pruned)
-            if (isProtectedToolMessage(msg))
-                continue;
-            const content = typeof msg.content === "string" ? msg.content : "";
-            const estimate = Math.ceil(content.length / 4);
-            totalTokens += estimate;
-            if (totalTokens > PRUNE_PROTECT_TOKENS && content.length > TOOL_OUTPUT_MAX_CHARS) {
-                const truncated = content.slice(0, TOOL_OUTPUT_MAX_CHARS) + "\n\n[... output truncated during compaction ...]";
-                msg.content = truncated;
-                saved += estimate - Math.ceil(truncated.length / 4);
-            }
-        }
+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 saved;
+    return value;
 }
-/** Check if a message is from a protected tool (e.g. skill) */
 function isProtectedToolMessage(msg) {
     if (typeof msg.content === "string") {
-        // Skill tool outputs are wrapped in <skill_content> tags
         return msg.content.includes("<skill_content");
     }
     if (Array.isArray(msg.content)) {
-        return msg.content.some((p) => p.type === "tool-result" && PRUNE_PROTECTED_TOOLS.has(p.toolName ?? ""));
+        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;
+}
 /**
- * Select how many recent turns to keep verbatim based on token budget.
+ * 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.
  */
-function selectTail(messages, config) {
-    const maxTokens = config?.maxTokens ?? getMaxTokensFromConfig();
-    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);
+export function pruneToolOutputs(messages, options = {}) {
+    const protectFrom = protectFromIndex(messages);
+    const candidates = [];
+    for (let i = 0; i < protectFrom; i++) {
+        const msg = messages[i];
+        const pruned = msg.role === "tool" ? pruneToolResultMessage(msg) : msg.role === "assistant" ? pruneAssistantToolCalls(msg) : null;
+        if (!pruned)
+            continue;
+        candidates.push({
+            index: i,
+            pruned,
+            tokensSaved: Math.max(0, estimateMessageTokens(msg) - estimateMessageTokens(pruned)),
+        });
     }
-    if (turnStarts.length <= 1) {
+    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;
+            replaced.set(c.index, c.pruned);
+            estimate -= c.tokensSaved;
+        }
+    }
+    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 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 ──────────────────────────────────────────────────────
@@ -229,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.`;
 /**
@@ -238,22 +473,43 @@ 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);
     }
     return mainModel;
 }
+const SKILL_NOTE_HEADER = "## Skills Previously Loaded";
 function extractPreviousSummary(messages) {
     const first = messages[0];
     if (first?.role === "system" && typeof first.content === "string" && first.content.includes("[Context Summary")) {
         const match = first.content.match(/\[Context Summary[^\]]*\]\n\n([\s\S]*)/);
-        return match?.[1];
+        return match?.[1]?.split(SKILL_NOTE_HEADER)[0]?.trimEnd();
     }
     return undefined;
 }
-function buildCompactionPrompt(previousSummary) {
+/** Skills listed in a previous compaction note, so repeated compactions don't forget them. */
+function extractNotedSkills(messages) {
+    const first = messages[0];
+    if (first?.role !== "system" || typeof first.content !== "string")
+        return [];
+    const section = first.content.split(SKILL_NOTE_HEADER)[1];
+    if (!section)
+        return [];
+    return section
+        .split("\n")
+        .filter((line) => line.startsWith("- "))
+        .map((line) => line
+        .slice(2)
+        .replace(/\s*\(base dir:.*$/, "")
+        .trim())
+        .filter(Boolean);
+}
+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.",
@@ -264,36 +520,84 @@ 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;
     if (Array.isArray(msg.content)) {
-        return msg.content
-            .filter((p) => "text" in p && typeof p.text === "string")
-            .map((p) => p.text)
-            .join("\n");
+        const parts = [];
+        for (const p of msg.content) {
+            if ("text" in p && typeof p.text === "string") {
+                parts.push(p.text);
+            }
+            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);
+                }
+                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.
@@ -301,56 +605,40 @@ 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 outputs (skip skill results)
-    pruneToolOutputs(messages);
-    // Step 2: Select tail (recent turns to keep verbatim)
-    const { headEnd, tailStart } = selectTail(messages, config);
-    if (headEnd <= 1) {
-        return { messages, compacted: false, shouldContinue: false };
-    }
-    const toSummarize = messages.slice(0, headEnd);
-    const toKeep = messages.slice(tailStart);
-    // Step 3: Check for previous summary (incremental)
+    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 <= 0)
+        return pruneOnly();
+    const toSummarize = pruned.slice(0, headEnd);
+    const toKeep = pruned.slice(tailStart);
     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 },
-            ],
-        });
+        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 = [
+            ...new Set([...collectLoadedSkillNames(toSummarize), ...extractNotedSkills(toSummarize)]),
+        ].filter((name) => !stillPresent.has(name));
+        const reloadNote = buildSkillReloadNote(droppedSkills);
         const compactedMessages = [
             {
                 role: "system",
-                content: `[Context Summary - Previous conversation was compacted]\n\n${summary}`,
+                content: `[Context Summary - Previous conversation was compacted]\n\n${summary}${reloadNote ? `\n\n${reloadNote}` : ""}`,
             },
             ...toKeep,
         ];
-        // Step 7: Check if the last user message had media — if so, provide replay text
-        let replayText;
-        const lastUserMsg = toKeep.find((m) => m.role === "user");
-        if (lastUserMsg && hasMedia(lastUserMsg)) {
-            replayText = extractTextOnly(lastUserMsg);
-        }
-        return { messages: compactedMessages, compacted: true, shouldContinue: autoContinue, replayText };
+        return {
+            messages: compactedMessages,
+            compacted: true,
+            usage: result.usage,
+        };
     }
-    catch {
-        return { messages: toKeep, compacted: true, shouldContinue: false };
+    catch (error) {
+        console.error("[compaction] summary generation failed, keeping pruned messages:", error);
+        return pruneOnly();
     }
 }