min-agent 0.5.0 → 0.6.0

package/dist/compaction.js

@@ -1,644 +0,0 @@
-import { generateText } from "ai";
-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.
- *
- * Features:
- * 1. Real token tracking from API responses
- * 2. Structured summary template (Goal/Progress/Decisions/Files)
- * 3. Incremental summaries (update previous summary instead of rewriting)
- * 4. Tool output pruning with skill protection
- * 5. Auto-continue after compaction with overflow replay
- * 6. Token-budget-aware tail preservation
- * 7. Model-aware thresholds (uses actual context window)
- * 8. Configurable compaction model
- */
-// ─── Structured Summary Template ───────────────────────────────────────────
-const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown below. Keep the section order unchanged.
-
-## Goal
-- [single-sentence task summary]
-
-## Constraints & Preferences
-- [user constraints, preferences, specs, or "(none)"]
-
-## Progress
-### Done
-- [completed work or "(none)"]
-
-### In Progress
-- [current work or "(none)"]
-
-### Blocked
-- [blockers or "(none)"]
-
-## Key Decisions
-- [decision and why, or "(none)"]
-
-## Next Steps
-- [ordered next actions or "(none)"]
-
-## Critical Context
-- [important technical facts, numbers, dates, scores, URLs, errors, open questions, or "(none)"]
-
-## Relevant Files
-- [file or directory path: why it matters, or "(none)"]
-
-Rules:
-- Keep every section, even when empty.
-- Use terse bullets, not prose paragraphs.
-- Preserve exact file paths, commands, error strings, and identifiers when known.
-- Do not mention the summary process or that context was compacted.`;
-// ─── Constants ─────────────────────────────────────────────────────────────
-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.04;
-const MIN_TAIL_BUDGET = 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 ─────────────────────────────────────────────────────────
-export class TokenTracker {
-    _lastInputTokens = 0;
-    _totalOutputTokens = 0;
-    _totalInputTokens = 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._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;
-    }
-    get totalInputTokens() {
-        return this._totalInputTokens;
-    }
-    get totalOutputTokens() {
-        return this._totalOutputTokens;
-    }
-    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 ──────────────────────────────────────────────────────
-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));
-        }
-        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 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) {
-    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 context window: explicit override, then model-aware detection.
- * Undetected models use 512k.
- */
-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) + overhead > threshold;
-}
-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;
-}
-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" || 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 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, 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 (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;
-    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 + unitTokens > budget && tokensUsed > 0)
-            break;
-        tokensUsed += unitTokens;
-        tailStart = unitStart;
-    }
-    if (tailStart >= messages.length)
-        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 ──────────────────────────────────────────────────────
-const COMPACTION_AGENT_SYSTEM = `You are an anchored context summarization assistant for coding sessions.
-
-Summarize only the conversation history you are given. The newest turns may be kept verbatim outside your summary, so focus on the older context that still matters for continuing the work.
-
-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, 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.`;
-/**
- * Resolve the model to use for compaction.
- * If config.compaction.model is set, use that (allows cheap/fast model for summaries).
- * Otherwise falls back to the main model.
- */
-function resolveCompactionModel(mainModel) {
-    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]?.split(SKILL_NOTE_HEADER)[0]?.trimEnd();
-    }
-    return undefined;
-}
-/** 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.",
-            "Preserve still-true details, remove stale details, and merge in the new facts.",
-            "",
-            "<previous-summary>",
-            previousSummary,
-            "</previous-summary>",
-        ].join("\n")
-        : "Create a new anchored summary from the conversation history above.";
-    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)) {
-        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 "";
-}
-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)}`;
-}
-/**
- * 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");
-    }
-    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.
- * Supports incremental summaries, skill protection, configurable model,
- * and overflow replay.
- */
-export async function compactMessages(messages, model, config) {
-    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);
-    const conversationText = conversationForSummary(toSummarize);
-    const compactionModel = resolveCompactionModel(model);
-    try {
-        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}${reloadNote ? `\n\n${reloadNote}` : ""}`,
-            },
-            ...toKeep,
-        ];
-        return {
-            messages: compactedMessages,
-            compacted: true,
-            usage: result.usage,
-        };
-    }
-    catch (error) {
-        console.error("[compaction] summary generation failed, keeping pruned messages:", error);
-        return pruneOnly();
-    }
-}