qlogicagent 2.13.5 → 2.13.6

package/dist/runtime/context/context-compression-strategies.js

@@ -1,860 +0,0 @@
-// ============================================================
-// Context compression strategies — reduce message history
-// to fit within a token budget.
-//
-// Phase 1: ToolResultTrim + SlidingWindow (sync, no LLM)
-// Phase 2: Structured LLM summarization + head/tail protection
-// Phase 3: Prompt cache awareness
-// Phase 4: Adaptive threshold + metrics + engine plugin
-// ============================================================
-export function isAsyncCompressionStrategy(s) {
-    return typeof s.compressAsync === "function";
-}
-// ── Sliding Window ──────────────────────────────────────────
-// Keep the system prompt(s) + first user message + last N messages that fit the budget.
-// Minimum guarantee: always keeps at least the first user message and last 4 messages
-// to prevent total context loss. CC doesn't have explicit pinning but preserves user intent.
-const MINIMUM_RECENT_MESSAGES = 4;
-export class SlidingWindowStrategy {
-    estimateTokens;
-    constructor(estimateTokens) {
-        this.estimateTokens = estimateTokens;
-    }
-    compress(messages, budget) {
-        const systemMessages = [];
-        const nonSystem = [];
-        for (const msg of messages) {
-            if (msg.role === "system") {
-                systemMessages.push(msg);
-            }
-            else {
-                nonSystem.push(msg);
-            }
-        }
-        let remaining = budget;
-        for (const sys of systemMessages) {
-            remaining -= this.estimateTokens(sys);
-        }
-        // Pin the first user message (original task intent — must never be dropped)
-        let pinnedFirst;
-        for (const msg of nonSystem) {
-            if (msg.role === "user") {
-                pinnedFirst = msg;
-                break;
-            }
-        }
-        if (pinnedFirst) {
-            remaining -= this.estimateTokens(pinnedFirst);
-        }
-        if (remaining <= 0) {
-            // Budget only fits system + pinned first user message
-            const result = pinnedFirst ? [...systemMessages, pinnedFirst] : systemMessages;
-            return { messages: result, droppedCount: nonSystem.length - (pinnedFirst ? 1 : 0), strategy: "sliding-window" };
-        }
-        // Fill from the end (most recent first), excluding pinned
-        const kept = [];
-        let keptCount = 0;
-        for (let i = nonSystem.length - 1; i >= 0; i--) {
-            const msg = nonSystem[i];
-            if (msg === pinnedFirst)
-                continue; // already pinned
-            const cost = this.estimateTokens(msg);
-            if (remaining - cost < 0 && keptCount >= MINIMUM_RECENT_MESSAGES)
-                break;
-            // Force-keep minimum recent messages even if over budget
-            if (remaining - cost < 0 && keptCount < MINIMUM_RECENT_MESSAGES) {
-                kept.unshift(msg);
-                keptCount++;
-                continue;
-            }
-            remaining -= cost;
-            kept.unshift(msg);
-            keptCount++;
-        }
-        // Assemble: system + pinned first + recent window
-        const assembled = [...systemMessages];
-        if (pinnedFirst && !kept.includes(pinnedFirst)) {
-            assembled.push(pinnedFirst);
-        }
-        assembled.push(...kept);
-        return {
-            messages: assembled,
-            droppedCount: nonSystem.length - (kept.length + (pinnedFirst && !kept.includes(pinnedFirst) ? 1 : 0)),
-            strategy: "sliding-window",
-        };
-    }
-}
-// ── Summarize Old ───────────────────────────────────────────
-// Keep last `recentCount` messages as-is, replace older ones
-// with a single system-role summary placeholder.
-export class SummarizeOldStrategy {
-    recentCount;
-    summarize;
-    constructor(recentCount, summarize) {
-        this.recentCount = recentCount;
-        this.summarize = summarize;
-    }
-    compress(messages, _budget) {
-        const systemMessages = messages.filter((m) => m.role === "system");
-        const nonSystem = messages.filter((m) => m.role !== "system");
-        if (nonSystem.length <= this.recentCount) {
-            return { messages, droppedCount: 0, strategy: "summarize-old" };
-        }
-        const oldMessages = nonSystem.slice(0, nonSystem.length - this.recentCount);
-        const recentMessages = nonSystem.slice(nonSystem.length - this.recentCount);
-        const summary = this.summarize(oldMessages);
-        return {
-            messages: [
-                ...systemMessages,
-                { role: "system", content: `[Conversation summary]\n${summary}` },
-                ...recentMessages,
-            ],
-            droppedCount: oldMessages.length,
-            strategy: "summarize-old",
-        };
-    }
-}
-// ── Tool Result Trim ────────────────────────────────────────
-// Deep compression stage: truncates remaining oversized tool results.
-// Level 1 (executor, 50KB) and Level 2 (budget, 200KB aggregate) run
-// first in tool-loop.ts; this stage fires during autocompact when
-// context is tight, applying a more aggressive threshold.
-export class ToolResultTrimStrategy {
-    maxToolResultChars;
-    constructor(maxToolResultChars = 8_000) {
-        this.maxToolResultChars = maxToolResultChars;
-    }
-    compress(messages, _budget) {
-        let trimmedCount = 0;
-        const result = messages.map((msg) => {
-            if (msg.role !== "tool" || typeof msg.content !== "string")
-                return msg;
-            if (msg.content.length <= this.maxToolResultChars)
-                return msg;
-            trimmedCount++;
-            return {
-                ...msg,
-                content: smartTruncateToolResult(msg.content, this.maxToolResultChars),
-            };
-        });
-        return {
-            messages: result,
-            droppedCount: trimmedCount,
-            strategy: "tool-result-trim",
-        };
-    }
-}
-/**
- * Truncate tool result with structural awareness.
- * Tries to find a clean break point (newline or JSON boundary) to avoid
- * mid-field cuts that produce unparseable data.
- */
-function smartTruncateToolResult(content, maxChars) {
-    if (content.length <= maxChars)
-        return content;
-    // Try to detect JSON and truncate at a structural boundary
-    const trimmed = content.slice(0, maxChars);
-    const isJson = content.trimStart().startsWith("{") || content.trimStart().startsWith("[");
-    if (isJson) {
-        // Find the last complete JSON "line" boundary (closing brace/bracket + comma/newline)
-        const lastCleanBreak = Math.max(trimmed.lastIndexOf("},"), trimmed.lastIndexOf("],"), trimmed.lastIndexOf("}\n"), trimmed.lastIndexOf("]\n"));
-        if (lastCleanBreak > maxChars * 0.5) {
-            return trimmed.slice(0, lastCleanBreak + 1) +
-                `\n[...truncated: ${content.length - lastCleanBreak - 1} chars omitted]`;
-        }
-    }
-    // For non-JSON, find the last newline
-    const lastNewline = trimmed.lastIndexOf("\n");
-    if (lastNewline > maxChars * 0.7) {
-        return trimmed.slice(0, lastNewline) +
-            `\n[...truncated: ${content.length - lastNewline} chars omitted]`;
-    }
-    // Fallback: raw cut
-    return trimmed + `\n[...truncated: ${content.length - maxChars} chars omitted]`;
-}
-// ── Composite ───────────────────────────────────────────────
-// Apply multiple strategies in sequence.
-export function composeStrategies(...strategies) {
-    return {
-        compress(messages, budget) {
-            let current = messages;
-            let totalDropped = 0;
-            const names = [];
-            for (const strategy of strategies) {
-                const result = strategy.compress(current, budget);
-                current = result.messages;
-                totalDropped += result.droppedCount;
-                if (result.droppedCount > 0) {
-                    names.push(result.strategy);
-                }
-            }
-            return {
-                messages: current,
-                droppedCount: totalDropped,
-                strategy: names.length > 0 ? names.join("+") : "none",
-            };
-        },
-    };
-}
-/**
- * Compose strategies with async support — if any strategy is async,
- * the pipeline becomes async.
- */
-export function composeAsyncStrategies(...strategies) {
-    return {
-        compress(messages, budget) {
-            // Sync fallback: skip async strategies
-            let current = messages;
-            let totalDropped = 0;
-            const names = [];
-            for (const strategy of strategies) {
-                const result = strategy.compress(current, budget);
-                current = result.messages;
-                totalDropped += result.droppedCount;
-                if (result.droppedCount > 0)
-                    names.push(result.strategy);
-            }
-            return {
-                messages: current,
-                droppedCount: totalDropped,
-                strategy: names.length > 0 ? names.join("+") : "none",
-            };
-        },
-        async compressAsync(messages, budget) {
-            let current = messages;
-            let totalDropped = 0;
-            const names = [];
-            let totalLatency = 0;
-            let anyLlm = false;
-            let anyCacheInvalidated = false;
-            for (const strategy of strategies) {
-                const result = isAsyncCompressionStrategy(strategy)
-                    ? await strategy.compressAsync(current, budget)
-                    : strategy.compress(current, budget);
-                current = result.messages;
-                totalDropped += result.droppedCount;
-                if (result.droppedCount > 0)
-                    names.push(result.strategy);
-                if (result.metrics) {
-                    totalLatency += result.metrics.latencyMs;
-                    anyLlm = anyLlm || result.metrics.usedLlm;
-                    anyCacheInvalidated = anyCacheInvalidated || !!result.metrics.cacheInvalidated;
-                }
-            }
-            return {
-                messages: current,
-                droppedCount: totalDropped,
-                strategy: names.length > 0 ? names.join("+") : "none",
-                metrics: totalLatency > 0 || anyLlm
-                    ? { tokensBefore: 0, tokensAfter: 0, compressionRatio: 0, latencyMs: totalLatency, usedLlm: anyLlm, cacheInvalidated: anyCacheInvalidated }
-                    : undefined,
-            };
-        },
-    };
-}
-// ════════════════════════════════════════════════════════════
-// Phase 2: LLM Summarization Strategies
-// ════════════════════════════════════════════════════════════
-// ── 2.1 Structured Summary Prompt (Claude Code style) ──────
-/**
- * Build the structured 9-section summary instruction for the LLM.
- * Based on Claude Code's Full Compact mode, adapted for Hub.
- */
-export function buildStructuredSummaryPrompt(messagesToSummarize, opts) {
-    const userMsgs = messagesToSummarize.filter((m) => m.role === "user");
-    const toolCalls = messagesToSummarize.filter((m) => m.tool_calls != null);
-    const toolResults = messagesToSummarize.filter((m) => m.role === "tool");
-    const sections = [
-        "You are a conversation summarizer. Produce a structured summary of the conversation history below.",
-        "",
-        "## Instructions",
-        "Analyze the conversation and produce a summary with these sections:",
-        "",
-        "### 1. Primary Objective",
-        "What is the user's main goal or task? State it in one sentence.",
-        "",
-        "### 2. Key Decisions Made",
-        "List the important decisions, choices, or conclusions reached during the conversation.",
-        "",
-        "### 3. Current Progress",
-        `Describe the current state. ${toolCalls.length > 0 ? `${toolCalls.length} tool calls and ${toolResults.length} tool results were exchanged.` : "No tools were used."}`,
-        "",
-        "### 4. Pending Tasks",
-        "List any tasks that are in-progress or planned but not yet completed.",
-        "",
-        "### 5. Important Context",
-        "MUST preserve verbatim: IP addresses, file paths, URLs, port numbers, credentials/tokens, "
-            + "specific numeric values, version numbers, proper nouns, identifiers, and any user-provided data points. "
-            + "These MUST appear exactly as stated in the original conversation.",
-        "",
-        "### 6. All User Messages",
-        `List ALL ${userMsgs.length} user messages chronologically, each as 1-2 sentences capturing the core request. `
-            + "Include exact values, identifiers, keywords, or secrets the user mentioned or asked you to remember. "
-            + "Do NOT omit any user message — every user request must be traceable in this summary.",
-        "",
-        "### 7. Error & Recovery History",
-        "Summarize any errors encountered and how they were resolved.",
-        "",
-        "### 8. User Preferences Expressed",
-        `Note any stated preferences about style, approach, or constraints.`,
-        "",
-        "### 9. Technical State",
-        "Note file paths, variable names, API endpoints, or configuration values that were discussed.",
-        "",
-        "### 10. Conversation Flow",
-        "Briefly describe the overall flow: what happened first, what changed, where we are now.",
-    ];
-    if (opts?.taskContext) {
-        sections.push("", `## Additional Context`, opts.taskContext);
-    }
-    sections.push("", "## Conversation to Summarize", "", ...messagesToSummarize.map((m) => {
-        const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content ?? "");
-        // CC parity: preserve user messages verbatim (they contain task intent).
-        // Only truncate assistant/tool messages which can be very long.
-        const truncated = m.role === "user"
-            ? content
-            : content.length > 2000 ? content.slice(0, 2000) + "..." : content;
-        return `[${m.role}]: ${truncated}`;
-    }), "", "## Output Format", "Respond with a concise summary covering all 10 sections above. Use markdown headers.", "Keep the total summary under 1000 words. Focus on actionable information and exact user requests.");
-    return sections.join("\n");
-}
-/**
- * Phase 2.2: Head/Tail protected summarization.
- *
- * Protects: system messages + first exchange + last N messages.
- * Compresses: middle section via LLM summarization.
- */
-export class HeadTailProtectedStrategy {
-    config;
-    constructor(config) {
-        this.config = {
-            protectedHeadExchanges: config.protectedHeadExchanges,
-            protectedTailMessages: config.protectedTailMessages,
-            summarize: config.summarize,
-            estimateTokens: config.estimateTokens ?? defaultEstimateTokens,
-            taskContext: config.taskContext,
-        };
-    }
-    compress(messages, _budget) {
-        // Sync fallback: just pass through (cannot call LLM synchronously)
-        return { messages, droppedCount: 0, strategy: "head-tail-protected" };
-    }
-    async compressAsync(messages, budget) {
-        const start = Date.now();
-        const { system, nonSystem } = splitSystemMessages(messages);
-        // Check if compression is needed
-        const totalTokens = messages.reduce((sum, m) => sum + this.config.estimateTokens(m), 0);
-        if (totalTokens <= budget) {
-            return { messages, droppedCount: 0, strategy: "head-tail-protected" };
-        }
-        // Identify protected head: first N user+assistant exchanges
-        let headEnd = 0;
-        let exchangeCount = 0;
-        for (let i = 0; i < nonSystem.length; i++) {
-            if (nonSystem[i].role === "user")
-                exchangeCount++;
-            if (exchangeCount > this.config.protectedHeadExchanges)
-                break;
-            headEnd = i + 1;
-        }
-        // Protected tail — scale with conversation length (40% of messages, min configured)
-        const dynamicTail = Math.max(this.config.protectedTailMessages, Math.floor(nonSystem.length * 0.4));
-        const tailStart = Math.max(headEnd, nonSystem.length - dynamicTail);
-        // If there's nothing to compress in the middle, pass through
-        if (tailStart <= headEnd) {
-            return { messages, droppedCount: 0, strategy: "head-tail-protected" };
-        }
-        const headMessages = nonSystem.slice(0, headEnd);
-        const middleMessages = nonSystem.slice(headEnd, tailStart);
-        const tailMessages = nonSystem.slice(tailStart);
-        // Summarize middle section via LLM
-        const instruction = buildStructuredSummaryPrompt(middleMessages, {
-            taskContext: this.config.taskContext,
-        });
-        const summary = await this.config.summarize(middleMessages, instruction);
-        const summaryMessage = {
-            role: "system",
-            content: `[Conversation summary — ${middleMessages.length} messages compressed]\n\n${summary}`,
-        };
-        const resultMessages = [
-            ...system,
-            ...headMessages,
-            summaryMessage,
-            ...tailMessages,
-        ];
-        const latencyMs = Date.now() - start;
-        const tokensAfter = resultMessages.reduce((sum, m) => sum + this.config.estimateTokens(m), 0);
-        return {
-            messages: resultMessages,
-            droppedCount: middleMessages.length,
-            strategy: "head-tail-protected",
-            metrics: {
-                tokensBefore: totalTokens,
-                tokensAfter,
-                compressionRatio: totalTokens > 0 ? tokensAfter / totalTokens : 1,
-                latencyMs,
-                usedLlm: true,
-                cacheInvalidated: true,
-            },
-        };
-    }
-}
-/**
- * Phase 2.3: Incremental (partial) compaction.
- *
- * Only summarizes the oldest messages beyond the preserve window.
- * Avoids repeatedly re-summarizing already-compressed content.
- * If a previous summary marker exists, only new old messages are compressed.
- */
-export class IncrementalCompactStrategy {
-    config;
-    constructor(config) {
-        this.config = {
-            preserveRecentCount: config.preserveRecentCount,
-            summarize: config.summarize,
-            estimateTokens: config.estimateTokens ?? defaultEstimateTokens,
-        };
-    }
-    compress(messages, _budget) {
-        return { messages, droppedCount: 0, strategy: "incremental-compact" };
-    }
-    async compressAsync(messages, budget) {
-        const start = Date.now();
-        const { system, nonSystem } = splitSystemMessages(messages);
-        // Find existing summary marker
-        const existingSummaryIdx = system.findIndex((m) => typeof m.content === "string" && m.content.startsWith("[Conversation summary"));
-        const existingSummary = existingSummaryIdx >= 0 ? system[existingSummaryIdx] : undefined;
-        const systemWithoutOldSummary = existingSummaryIdx >= 0
-            ? [...system.slice(0, existingSummaryIdx), ...system.slice(existingSummaryIdx + 1)]
-            : system;
-        // How many messages to preserve
-        const preserveStart = Math.max(0, nonSystem.length - this.config.preserveRecentCount);
-        if (preserveStart <= 0) {
-            return { messages, droppedCount: 0, strategy: "incremental-compact" };
-        }
-        const totalTokens = messages.reduce((sum, m) => sum + this.config.estimateTokens(m), 0);
-        if (totalTokens <= budget) {
-            return { messages, droppedCount: 0, strategy: "incremental-compact" };
-        }
-        const oldMessages = nonSystem.slice(0, preserveStart);
-        const recentMessages = nonSystem.slice(preserveStart);
-        // Build summary instruction including existing summary context
-        const contextPrefix = existingSummary && typeof existingSummary.content === "string"
-            ? `Previous summary:\n${existingSummary.content}\n\nNew messages to integrate:`
-            : undefined;
-        const instruction = buildStructuredSummaryPrompt(oldMessages, { taskContext: contextPrefix });
-        const summary = await this.config.summarize(oldMessages, instruction);
-        const summaryMessage = {
-            role: "system",
-            content: `[Conversation summary — ${oldMessages.length} messages compressed]\n\n${summary}`,
-        };
-        const resultMessages = [...systemWithoutOldSummary, summaryMessage, ...recentMessages];
-        const latencyMs = Date.now() - start;
-        const tokensAfter = resultMessages.reduce((sum, m) => sum + this.config.estimateTokens(m), 0);
-        return {
-            messages: resultMessages,
-            droppedCount: oldMessages.length,
-            strategy: "incremental-compact",
-            metrics: {
-                tokensBefore: totalTokens,
-                tokensAfter,
-                compressionRatio: totalTokens > 0 ? tokensAfter / totalTokens : 1,
-                latencyMs,
-                usedLlm: true,
-                cacheInvalidated: true,
-            },
-        };
-    }
-}
-/**
- * Phase 3: Cache-aware wrapper.
- *
- * Wraps any strategy and tracks whether compression invalidated the
- * provider prompt cache. System prompt prefix stability is preserved
- * by never modifying system[0] (the original system prompt).
- */
-export class CacheAwareCompressionStrategy {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    compress(messages, budget) {
-        const beforeHash = computeMessagePrefixHash(messages);
-        const result = this.config.inner.compress(messages, budget);
-        const afterHash = computeMessagePrefixHash(result.messages);
-        const cacheInvalidated = beforeHash !== afterHash && result.droppedCount > 0;
-        if (cacheInvalidated) {
-            this.config.onCacheInvalidated?.({ droppedCount: result.droppedCount, strategy: result.strategy });
-        }
-        return {
-            ...result,
-            metrics: {
-                ...(result.metrics ?? {
-                    tokensBefore: 0, tokensAfter: 0, compressionRatio: 0, latencyMs: 0, usedLlm: false,
-                }),
-                cacheInvalidated,
-            },
-        };
-    }
-    async compressAsync(messages, budget) {
-        const beforeHash = computeMessagePrefixHash(messages);
-        const result = isAsyncCompressionStrategy(this.config.inner)
-            ? await this.config.inner.compressAsync(messages, budget)
-            : this.config.inner.compress(messages, budget);
-        const afterHash = computeMessagePrefixHash(result.messages);
-        const cacheInvalidated = beforeHash !== afterHash && result.droppedCount > 0;
-        if (cacheInvalidated) {
-            this.config.onCacheInvalidated?.({ droppedCount: result.droppedCount, strategy: result.strategy });
-        }
-        return {
-            ...result,
-            metrics: {
-                ...(result.metrics ?? {
-                    tokensBefore: 0, tokensAfter: 0, compressionRatio: 0, latencyMs: 0, usedLlm: false,
-                }),
-                cacheInvalidated,
-            },
-        };
-    }
-}
-export const DEFAULT_ADAPTIVE_BUDGET_CONFIG = {
-    modelContextWindow: 128_000,
-    targetUsageRatio: 0.75,
-    minBudget: 16_000,
-    maxBudget: 120_000,
-};
-/**
- * Compute the adaptive token budget for a given model + message history.
- *
- * Adjusts based on model context window, and uses the target ratio
- * so compression triggers before hitting the hard limit.
- */
-export function computeAdaptiveBudget(config = {}) {
-    const c = { ...DEFAULT_ADAPTIVE_BUDGET_CONFIG, ...config };
-    const target = Math.floor(c.modelContextWindow * c.targetUsageRatio);
-    return Math.max(c.minBudget, Math.min(target, c.maxBudget));
-}
-export function selectCompressionTier(currentTokens, budget) {
-    const ratio = currentTokens / budget;
-    if (ratio <= 0.8)
-        return "none";
-    if (ratio <= 1.0)
-        return "trim-only";
-    if (ratio <= 1.5)
-        return "sliding-window";
-    return "llm-summarize";
-}
-export class CompressionMetricsCollector {
-    events = [];
-    maxEvents;
-    constructor(maxEvents = 100) {
-        this.maxEvents = maxEvents;
-    }
-    record(event) {
-        this.events.push(event);
-        if (this.events.length > this.maxEvents) {
-            this.events.shift();
-        }
-    }
-    snapshot() {
-        const total = this.events.length;
-        if (total === 0) {
-            return {
-                totalCompressions: 0,
-                totalLlmCalls: 0,
-                totalCacheInvalidations: 0,
-                averageCompressionRatio: 1,
-                averageLatencyMs: 0,
-                totalTokensSaved: 0,
-                recentEvents: [],
-            };
-        }
-        let sumRatio = 0;
-        let sumLatency = 0;
-        let tokensSaved = 0;
-        let llmCalls = 0;
-        let cacheInvalidations = 0;
-        for (const e of this.events) {
-            sumRatio += e.tokensBefore > 0 ? e.tokensAfter / e.tokensBefore : 1;
-            sumLatency += e.latencyMs;
-            tokensSaved += Math.max(0, e.tokensBefore - e.tokensAfter);
-            if (e.usedLlm)
-                llmCalls++;
-            if (e.cacheInvalidated)
-                cacheInvalidations++;
-        }
-        return {
-            totalCompressions: total,
-            totalLlmCalls: llmCalls,
-            totalCacheInvalidations: cacheInvalidations,
-            averageCompressionRatio: sumRatio / total,
-            averageLatencyMs: sumLatency / total,
-            totalTokensSaved: tokensSaved,
-            recentEvents: this.events.slice(-10),
-        };
-    }
-    reset() {
-        this.events.length = 0;
-    }
-}
-/**
- * Registry for context engines. Enforces single-active constraint.
- */
-export class ContextEngineRegistry {
-    engines = new Map();
-    activeId;
-    register(engine) {
-        this.engines.set(engine.id, engine);
-    }
-    activate(id) {
-        if (!this.engines.has(id))
-            return false;
-        this.activeId = id;
-        return true;
-    }
-    getActive() {
-        return this.activeId ? this.engines.get(this.activeId) : undefined;
-    }
-    listEngines() {
-        return Array.from(this.engines.values()).map((e) => ({
-            id: e.id,
-            label: e.label,
-            active: e.id === this.activeId,
-        }));
-    }
-}
-// ── Helpers ─────────────────────────────────────────────────
-function splitSystemMessages(messages) {
-    const system = [];
-    const nonSystem = [];
-    for (const msg of messages) {
-        if (msg.role === "system")
-            system.push(msg);
-        else
-            nonSystem.push(msg);
-    }
-    return { system, nonSystem };
-}
-function defaultEstimateTokens(msg) {
-    const text = typeof msg.content === "string"
-        ? msg.content
-        : msg.content != null
-            ? JSON.stringify(msg.content)
-            : "";
-    return Math.ceil(text.length / 4);
-}
-/**
- * Simple hash of the first few messages' role+content prefix.
- * Used to detect whether compression changed the prompt prefix
- * (which would invalidate provider prompt caching).
- */
-function computeMessagePrefixHash(messages) {
-    const prefixCount = Math.min(messages.length, 5);
-    const parts = [];
-    for (let i = 0; i < prefixCount; i++) {
-        const m = messages[i];
-        const content = typeof m.content === "string" ? m.content.slice(0, 200) : "";
-        parts.push(`${m.role}:${content}`);
-    }
-    return parts.join("|");
-}
-// ════════════════════════════════════════════════════════════
-// CC Parity Fix #2 — MicroCompact Strategy
-// ════════════════════════════════════════════════════════════
-/**
- * Tools whose old results can be selectively cleared (truncated)
- * without losing critical conversational context.
- * CC parity: microCompact.ts COMPACTABLE_TOOLS set.
- */
-const MICRO_COMPACT_TOOLS = new Set([
-    "file_read", "read", "Read",
-    "bash", "shell", "Bash",
-    "grep", "search", "Grep", "grep_search",
-    "glob", "Glob", "file_search",
-    "web_search", "WebSearch",
-    "web_fetch", "WebFetch",
-    "file_edit", "edit", "Edit",
-    "file_write", "write", "Write",
-]);
-/**
- * MicroCompact — selective clearing of old compactable tool results.
- *
- * CC parity: microCompact.ts
- *
- * For tool result messages from COMPACTABLE_TOOLS, if the message is
- * "old enough" (not in the most recent N messages), replace its content
- * with a compact "[result cleared]" marker. This preserves the tool call
- * structure (so the LLM knows what was called) but reclaims token budget.
- *
- * This is a lighter alternative to full summarization — it runs BEFORE
- * LLM summarization as a first-pass reduction.
- */
-export class MicroCompactStrategy {
-    preserveRecentCount;
-    estimateTokens;
-    constructor(
-    /** Number of recent messages to preserve (don't clear) */
-    preserveRecentCount = 20, 
-    /** Token estimator */
-    estimateTokens = defaultEstimateTokens) {
-        this.preserveRecentCount = preserveRecentCount;
-        this.estimateTokens = estimateTokens;
-    }
-    compress(messages, _budget) {
-        // Don't micro-compact if conversation is short
-        if (messages.length <= this.preserveRecentCount) {
-            return { messages, droppedCount: 0, strategy: "micro-compact" };
-        }
-        const cutoff = messages.length - this.preserveRecentCount;
-        let clearedCount = 0;
-        let tokensSaved = 0;
-        const result = messages.map((msg, idx) => {
-            // Only clear old tool results from compactable tools
-            if (idx >= cutoff)
-                return msg;
-            if (msg.role !== "tool")
-                return msg;
-            if (typeof msg.content !== "string")
-                return msg;
-            if (!msg.name || !MICRO_COMPACT_TOOLS.has(msg.name))
-                return msg;
-            // Only clear if the content is substantial (>200 chars)
-            if (msg.content.length <= 200)
-                return msg;
-            const savedTokens = this.estimateTokens(msg);
-            tokensSaved += savedTokens;
-            clearedCount++;
-            return {
-                ...msg,
-                content: `[result cleared — ${msg.content.length} chars]`,
-            };
-        });
-        return {
-            messages: result,
-            droppedCount: clearedCount,
-            strategy: "micro-compact",
-            metrics: clearedCount > 0 ? {
-                tokensBefore: 0,
-                tokensAfter: 0,
-                compressionRatio: 0,
-                latencyMs: 0,
-                usedLlm: false,
-                cacheInvalidated: false,
-            } : undefined,
-        };
-    }
-}
-/**
- * Extract file paths that were recently read/edited from the conversation.
- * Looks at tool calls and results for file path arguments.
- */
-export function extractRecentFilePaths(messages) {
-    const paths = new Map(); // path → last-seen index
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        // Check tool_calls for file paths
-        if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
-            for (const tc of msg.tool_calls) {
-                const name = tc.function?.name ?? "";
-                if (/read|edit|write|file/i.test(name) && tc.function?.arguments) {
-                    try {
-                        const args = JSON.parse(tc.function.arguments);
-                        const filePath = (args.path ?? args.filePath ?? args.file_path ?? args.file);
-                        if (filePath && typeof filePath === "string") {
-                            paths.set(filePath, i);
-                        }
-                    }
-                    catch { /* ignore parse errors */ }
-                }
-            }
-        }
-        // Check tool result names
-        if (msg.role === "tool" && msg.name && /read|edit|write|file/i.test(msg.name)) {
-            // The tool_call_id links back to the call — we already captured the path above
-        }
-    }
-    // Sort by most recently seen (last-seen index descending)
-    return [...paths.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .map(([path]) => path);
-}
-/**
- * Re-inject recently-used file contents after compaction.
- *
- * Call this AFTER compression but BEFORE sending to the LLM.
- * Appends file content as system messages at the end of the
- * system message block.
- */
-export async function postCompactFileRecovery(compressedMessages, originalMessages, config) {
-    const estimateTokens = config.estimateTokens ?? ((text) => Math.ceil(text.length / 4));
-    // Find file paths from the ORIGINAL conversation that may have been dropped
-    const recentPaths = extractRecentFilePaths(originalMessages);
-    if (recentPaths.length === 0)
-        return compressedMessages;
-    // Check which paths are still present in the compressed messages
-    const compressedContent = compressedMessages
-        .map(m => typeof m.content === "string" ? m.content : "")
-        .join("\n");
-    const missingPaths = recentPaths.filter(p => !compressedContent.includes(p));
-    if (missingPaths.length === 0)
-        return compressedMessages;
-    // Re-inject up to maxFiles files within maxTokenBudget
-    let tokenBudget = config.maxTokenBudget;
-    const injected = [];
-    let injectedCount = 0;
-    for (const filePath of missingPaths) {
-        if (injectedCount >= config.maxFiles)
-            break;
-        if (tokenBudget <= 0)
-            break;
-        const content = await config.readFile(filePath);
-        if (!content)
-            continue;
-        const tokens = estimateTokens(content);
-        if (tokens > tokenBudget)
-            continue; // Skip files that exceed remaining budget
-        tokenBudget -= tokens;
-        injectedCount++;
-        injected.push({
-            role: "system",
-            content: `[Post-compact file recovery: ${filePath}]\n\n${content}`,
-        });
-    }
-    if (injected.length === 0)
-        return compressedMessages;
-    // Insert recovered files after the last system message
-    const result = [...compressedMessages];
-    let lastSystemIdx = -1;
-    for (let i = 0; i < result.length; i++) {
-        if (result[i].role === "system")
-            lastSystemIdx = i;
-    }
-    result.splice(lastSystemIdx + 1, 0, ...injected);
-    return result;
-}
-/**
- * Remove messages whose tool_call_id or name matches the removedIds set.
- * If no removedIds are pending, this is a no-op.
- */
-export function snipCompactIfNeeded(messages, removedIds, estimateTokens = defaultEstimateTokens) {
-    if (removedIds.size === 0) {
-        return { messages, tokensFreed: 0, removedCount: 0 };
-    }
-    let tokensFreed = 0;
-    let removedCount = 0;
-    const result = [];
-    for (const msg of messages) {
-        const id = msg.tool_call_id ?? "";
-        if (id && removedIds.has(id)) {
-            tokensFreed += estimateTokens(msg);
-            removedCount++;
-            removedIds.delete(id); // consume the id
-            continue;
-        }
-        result.push(msg);
-    }
-    const boundaryMessage = removedCount > 0
-        ? { role: "system", content: `[${removedCount} messages removed by snip]` }
-        : undefined;
-    return { messages: result, tokensFreed, removedCount, boundaryMessage };
-}