@codebolt/agent 6.0.0 → 6.0.1

package/dist/unified/services/compaction/autoCompact.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * Layer 4: Auto Compact
+ *
+ * Full conversation summary via LLM when approaching the context window limit.
+ * Two sub-paths:
+ *   4a. Session memory compaction (using continuously-extracted memory)
+ *   4b. Legacy full summary (sends conversation to LLM for detailed summary)
+ *
+ * Key properties:
+ * - Triggers at effectiveContextWindow - bufferTokens (default 13K)
+ * - Circuit breaker: stops after N consecutive failures
+ * - Produces a CompactBoundaryMessage for boundary tracking
+ * - Post-compact cleanup resets all tracking state
+ * - When context collapse is active, auto-compact is suppressed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoCompact = void 0;
+const types_1 = require("./types");
+/** Tokens below context window to trigger proactive auto-compact */
+const DEFAULT_AUTOCOMPACT_BUFFER = 13000;
+/** Max consecutive failures before circuit breaker trips */
+const DEFAULT_MAX_CONSECUTIVE_FAILURES = 3;
+/** Default model token limit */
+const DEFAULT_MODEL_TOKEN_LIMIT = 128000;
+class AutoCompact {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        this.name = 'auto';
+        this.consecutiveFailures = 0;
+        this.options = {
+            bufferTokens: (_a = options === null || options === void 0 ? void 0 : options.bufferTokens) !== null && _a !== void 0 ? _a : DEFAULT_AUTOCOMPACT_BUFFER,
+            maxConsecutiveFailures: (_b = options === null || options === void 0 ? void 0 : options.maxConsecutiveFailures) !== null && _b !== void 0 ? _b : DEFAULT_MAX_CONSECUTIVE_FAILURES,
+            modelTokenLimit: (_c = options === null || options === void 0 ? void 0 : options.modelTokenLimit) !== null && _c !== void 0 ? _c : DEFAULT_MODEL_TOKEN_LIMIT,
+            preserveThreshold: (_d = options === null || options === void 0 ? void 0 : options.preserveThreshold) !== null && _d !== void 0 ? _d : 0.3,
+            llmRole: (_e = options === null || options === void 0 ? void 0 : options.llmRole) !== null && _e !== void 0 ? _e : 'summarizer',
+            enableLogging: (_f = options === null || options === void 0 ? void 0 : options.enableLogging) !== null && _f !== void 0 ? _f : false,
+        };
+    }
+    shouldApply(ctx) {
+        // Don't auto-compact if context collapse is handling it
+        if (ctx.contextCollapseEnabled) {
+            return false;
+        }
+        // Circuit breaker
+        if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
+            return false;
+        }
+        // Check threshold
+        const estimator = new types_1.TokenEstimator();
+        const tokenCount = estimator.estimateForMessages(ctx.messages) - (ctx.snipTokensFreed || 0);
+        const threshold = this.options.modelTokenLimit - this.options.bufferTokens;
+        return tokenCount >= threshold;
+    }
+    async apply(ctx) {
+        const messages = ctx.messages;
+        const estimator = new types_1.TokenEstimator();
+        const originalTokens = estimator.estimateForMessages(messages) - (ctx.snipTokensFreed || 0);
+        try {
+            const result = await this.compactConversation(messages, ctx);
+            if (!result) {
+                this.consecutiveFailures++;
+                return ctx;
+            }
+            // Success — reset failure counter
+            this.consecutiveFailures = 0;
+            const newTokens = estimator.estimateForMessages(result);
+            const boundary = {
+                layer: 'auto',
+                tokensFreed: originalTokens - newTokens,
+                messagesRemoved: messages.length - result.length,
+                timestamp: new Date().toISOString(),
+                summaryIncluded: true,
+            };
+            this.tracking = {
+                compacted: true,
+                turnId: `auto-${Date.now()}`,
+                turnCounter: 0,
+                consecutiveFailures: 0,
+            };
+            if (this.options.enableLogging) {
+                console.log(`[AutoCompact] Compacted: ${originalTokens} -> ${newTokens} tokens (${boundary.tokensFreed} freed, ${boundary.messagesRemoved} messages removed)`);
+            }
+            return {
+                ...ctx,
+                messages: result,
+                compactionHistory: [...(ctx.compactionHistory || []), boundary],
+                autoCompactTracking: this.tracking,
+            };
+        }
+        catch (error) {
+            this.consecutiveFailures++;
+            if (this.options.enableLogging) {
+                console.error('[AutoCompact] Compaction failed:', error);
+            }
+            return ctx;
+        }
+    }
+    reset() {
+        this.consecutiveFailures = 0;
+        this.tracking = undefined;
+    }
+    getTracking() {
+        return this.tracking;
+    }
+    getConsecutiveFailures() {
+        return this.consecutiveFailures;
+    }
+    // ─── Core Compaction Logic ────────────────────────────────────────
+    async compactConversation(messages, ctx) {
+        const estimator = new types_1.TokenEstimator();
+        // Find split point: preserve the most recent portion of conversation
+        const splitIndex = this.findSplitIndex(messages);
+        if (splitIndex === 0) {
+            return null; // Nothing to compact
+        }
+        // Separate into history-to-compact and history-to-keep
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const historyToCompress = messages
+            .slice(0, splitIndex)
+            .filter(m => m.role !== 'system');
+        const preservedMessages = messages.slice(splitIndex);
+        if (historyToCompress.length === 0) {
+            return null;
+        }
+        // Generate summary
+        const summary = await this.generateSummary(historyToCompress);
+        if (!summary || summary.trim().length === 0) {
+            return null;
+        }
+        // Build post-compact message array
+        const postCompactMessages = [
+            ...systemMessages,
+            {
+                role: 'user',
+                content: `This session is being continued from a previous conversation that ran out of context. Below is a summary of the conversation so far.\n\n${summary}\n\nPlease continue from where the previous conversation left off. Do not ask the user to re-explain what they already told you — the summary above contains all the context you need.`,
+            },
+            {
+                role: 'assistant',
+                content: 'Understood. I have the summary of the previous conversation and will continue from where we left off.',
+            },
+            ...preservedMessages,
+        ];
+        // Verify compression was effective
+        const newTokens = estimator.estimateForMessages(postCompactMessages);
+        const originalTokens = estimator.estimateForMessages(messages) - (ctx.snipTokensFreed || 0);
+        if (newTokens >= originalTokens) {
+            if (this.options.enableLogging) {
+                console.warn(`[AutoCompact] Summary inflated token count: ${originalTokens} -> ${newTokens}`);
+            }
+            return null;
+        }
+        return postCompactMessages;
+    }
+    findSplitIndex(messages) {
+        var _a;
+        // Find turn boundaries (user messages that aren't tool responses)
+        const turnStarts = [];
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            if (!msg)
+                continue;
+            if (msg.role === 'user' &&
+                !msg.tool_call_id &&
+                !this.isToolResponse(msg)) {
+                turnStarts.push(i);
+            }
+        }
+        if (turnStarts.length <= 3) {
+            return 0; // Too few turns to compress
+        }
+        // Keep the last preserveThreshold fraction of turns
+        const turnsToKeep = Math.max(3, Math.ceil(turnStarts.length * this.options.preserveThreshold));
+        const turnsToRemove = turnStarts.length - turnsToKeep;
+        if (turnsToRemove <= 0) {
+            return 0;
+        }
+        // Adjust to avoid splitting in the middle of a tool-response chain
+        let splitIndex = (_a = turnStarts[turnsToRemove]) !== null && _a !== void 0 ? _a : messages.length;
+        // Walk forward to skip tool responses that belong to the previous turn
+        while (splitIndex < messages.length) {
+            const msg = messages[splitIndex];
+            if (!msg)
+                break;
+            if (msg.role === 'tool' || msg.tool_call_id) {
+                splitIndex++;
+                continue;
+            }
+            break;
+        }
+        return splitIndex;
+    }
+    async generateSummary(messages) {
+        var _a, _b, _c, _d, _e;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const codebolt = require('@codebolt/codeboltjs');
+            // Build compression prompt
+            const historyText = messages
+                .map((msg, i) => {
+                var _a;
+                const content = typeof msg.content === 'string'
+                    ? msg.content
+                    : JSON.stringify((_a = msg.content) !== null && _a !== void 0 ? _a : '');
+                // Truncate very long messages for the prompt
+                const truncated = content.length > 2000
+                    ? content.slice(0, 1000) +
+                        `\n...[${content.length - 2000} chars truncated]...\n` +
+                        content.slice(-1000)
+                    : content;
+                return `[${i + 1}] ${msg.role}: ${truncated}`;
+            })
+                .join('\n\n');
+            const prompt = `You are a conversation compression assistant. Create a detailed, structured summary that preserves ALL critical context so work can continue seamlessly.
+
+CONVERSATION HISTORY TO COMPRESS:
+${historyText}
+
+Generate the summary with ALL of the following sections:
+
+<summary>
+1. PRIMARY REQUEST
+[The user's original, complete request]
+
+2. TASK EVOLUTION
+[How the task evolved. Include key user instructions that changed direction]
+
+3. KEY TECHNICAL CONCEPTS
+[Architecture decisions, design patterns, algorithms, data structures, API contracts]
+
+4. FILES AND CODE
+[Every file that was read, created, or modified. Include file paths and key changes]
+
+5. PROBLEM SOLVING
+[Errors encountered and solutions applied]
+
+6. PENDING TASKS
+[Tasks mentioned but NOT yet completed]
+
+7. CURRENT WORK STATE
+[Exactly where the work left off]
+
+8. NEXT STEP
+[The most logical next action]
+</summary>
+
+CRITICAL RULES:
+- Preserve ALL file paths exactly
+- Preserve ALL code snippets, function names, error messages verbatim
+- Include the FULL original user request, not a paraphrase
+- Do not summarize away technical details
+- Focus on facts and specifics`;
+            const response = await codebolt.llm.inference({
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a precise conversation compression assistant. Be comprehensive but concise.',
+                    },
+                    { role: 'user', content: prompt },
+                ],
+            });
+            // Extract summary from response
+            let summary;
+            if (typeof ((_a = response === null || response === void 0 ? void 0 : response.completion) === null || _a === void 0 ? void 0 : _a.content) === 'string') {
+                summary = response.completion.content;
+            }
+            else if ((_e = (_d = (_c = (_b = response === null || response === void 0 ? void 0 : response.completion) === null || _b === void 0 ? void 0 : _b.choices) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.message) === null || _e === void 0 ? void 0 : _e.content) {
+                summary = response.completion.choices[0].message.content;
+            }
+            if (summary && summary.trim().length > 0) {
+                return summary.trim();
+            }
+            return '';
+        }
+        catch (error) {
+            console.error('[AutoCompact] Error generating summary:', error);
+            return '';
+        }
+    }
+    isToolResponse(msg) {
+        if (msg.role === 'tool')
+            return true;
+        if (msg.tool_call_id)
+            return true;
+        if (typeof msg.content === 'object' && msg.content !== null) {
+            if (Array.isArray(msg.content)) {
+                return msg.content.some((block) => block &&
+                    (block.type === 'tool_result' || block.type === 'function_response'));
+            }
+        }
+        return false;
+    }
+}
+exports.AutoCompact = AutoCompact;

package/dist/unified/services/compaction/compactionOrchestrator.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Compaction Orchestrator
+ *
+ * Coordinates the 5-layer defense-in-depth compaction system.
+ * Layers execute cheapest-first: snip -> micro -> collapse -> auto -> reactive
+ *
+ * The orchestrator:
+ *   1. Runs each layer's shouldApply() check
+ *   2. Applies layers in priority order
+ *   3. Passes each layer's savings to subsequent layers via CompactionContext
+ *   4. Runs post-compact cleanup after any layer is applied
+ *   5. Provides reactive recovery for API 413 errors
+ */
+import type { MessageObject } from '@codebolt/types/sdk';
+import { type CompactionBoundary, type CompactionLayerKind, type CompactionOrchestratorOptions } from './types';
+import { SnipCompact } from './snipCompact';
+import { MicroCompact } from './microCompact';
+import { ContextCollapse } from './contextCollapse';
+import { AutoCompact } from './autoCompact';
+import { ReactiveCompact } from './reactiveCompact';
+export interface CompactionPipelineResult {
+    /** Final messages after all applied layers */
+    messages: MessageObject[];
+    /** Total tokens freed across all layers */
+    totalTokensFreed: number;
+    /** Layers that were applied, in order */
+    layersApplied: CompactionLayerKind[];
+    /** Compaction boundaries for telemetry */
+    boundaries: CompactionBoundary[];
+    /** Whether any compaction occurred */
+    wasCompacted: boolean;
+}
+export declare class CompactionOrchestrator {
+    private readonly snip;
+    private readonly micro;
+    private readonly collapse;
+    private readonly auto;
+    private readonly reactive;
+    private readonly cleanup;
+    private readonly options;
+    /** Layer execution order (cheapest first) */
+    private readonly layerOrder;
+    private readonly layers;
+    constructor(options?: CompactionOrchestratorOptions);
+    /**
+     * Run the full compaction pipeline.
+     * Each layer is checked and applied in priority order.
+     * If any layer reduces messages, subsequent layers see the reduced set.
+     */
+    compact(messages: MessageObject[]): Promise<CompactionPipelineResult>;
+    /**
+     * Attempt reactive recovery from an API error.
+     * Only called when the proactive pipeline didn't prevent overflow.
+     */
+    recoverFromError(messages: MessageObject[], error: unknown): Promise<CompactionPipelineResult>;
+    /**
+     * Get the current auto-compact tracking state.
+     */
+    getAutoCompactTracking(): import("./autoCompact").AutoCompactTracking | undefined;
+    /**
+     * Get the number of consecutive auto-compact failures.
+     */
+    getConsecutiveFailures(): number;
+    /**
+     * Reset the reactive compact's per-turn guard.
+     * Call at the start of each new turn.
+     */
+    resetForTurn(): void;
+    /**
+     * Reset all compaction state.
+     */
+    resetAll(): void;
+    getSnipLayer(): SnipCompact;
+    getMicroLayer(): MicroCompact;
+    getCollapseLayer(): ContextCollapse;
+    getAutoLayer(): AutoCompact;
+    getReactiveLayer(): ReactiveCompact;
+}

package/dist/unified/services/compaction/compactionOrchestrator.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * Compaction Orchestrator
+ *
+ * Coordinates the 5-layer defense-in-depth compaction system.
+ * Layers execute cheapest-first: snip -> micro -> collapse -> auto -> reactive
+ *
+ * The orchestrator:
+ *   1. Runs each layer's shouldApply() check
+ *   2. Applies layers in priority order
+ *   3. Passes each layer's savings to subsequent layers via CompactionContext
+ *   4. Runs post-compact cleanup after any layer is applied
+ *   5. Provides reactive recovery for API 413 errors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompactionOrchestrator = void 0;
+const snipCompact_1 = require("./snipCompact");
+const microCompact_1 = require("./microCompact");
+const contextCollapse_1 = require("./contextCollapse");
+const autoCompact_1 = require("./autoCompact");
+const reactiveCompact_1 = require("./reactiveCompact");
+const postCompactCleanup_1 = require("./postCompactCleanup");
+const DEFAULT_MODEL_TOKEN_LIMIT = 128000;
+class CompactionOrchestrator {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        /** Layer execution order (cheapest first) */
+        this.layerOrder = [
+            'snip',
+            'micro',
+            'collapse',
+            'auto',
+        ];
+        this.options = {
+            modelTokenLimit: (_a = options === null || options === void 0 ? void 0 : options.modelTokenLimit) !== null && _a !== void 0 ? _a : DEFAULT_MODEL_TOKEN_LIMIT,
+            autoCompactEnabled: (_b = options === null || options === void 0 ? void 0 : options.autoCompactEnabled) !== null && _b !== void 0 ? _b : true,
+            contextCollapseEnabled: (_c = options === null || options === void 0 ? void 0 : options.contextCollapseEnabled) !== null && _c !== void 0 ? _c : false,
+            enableLogging: (_d = options === null || options === void 0 ? void 0 : options.enableLogging) !== null && _d !== void 0 ? _d : false,
+        };
+        this.snip = new snipCompact_1.SnipCompact({ enableLogging: this.options.enableLogging });
+        this.micro = new microCompact_1.MicroCompact({ enableLogging: this.options.enableLogging });
+        this.collapse = new contextCollapse_1.ContextCollapse({
+            modelTokenLimit: this.options.modelTokenLimit,
+            enableLogging: this.options.enableLogging,
+        });
+        this.auto = new autoCompact_1.AutoCompact({
+            modelTokenLimit: this.options.modelTokenLimit,
+            enableLogging: this.options.enableLogging,
+        });
+        this.reactive = new reactiveCompact_1.ReactiveCompact({
+            modelTokenLimit: this.options.modelTokenLimit,
+            enableLogging: this.options.enableLogging,
+        });
+        this.cleanup = new postCompactCleanup_1.PostCompactCleanup({
+            enableLogging: this.options.enableLogging,
+        });
+        const layerEntries = [
+            ['snip', this.snip],
+            ['micro', this.micro],
+            ['collapse', this.collapse],
+            ['auto', this.auto],
+            ['reactive', this.reactive],
+        ];
+        this.layers = new Map(layerEntries);
+    }
+    /**
+     * Run the full compaction pipeline.
+     * Each layer is checked and applied in priority order.
+     * If any layer reduces messages, subsequent layers see the reduced set.
+     */
+    async compact(messages) {
+        var _a;
+        let ctx = {
+            messages,
+            snipTokensFreed: 0,
+            contextCollapseEnabled: this.options.contextCollapseEnabled,
+            compactionHistory: [],
+            autoCompactTracking: {
+                compacted: false,
+                turnId: `turn-${Date.now()}`,
+                turnCounter: 0,
+                consecutiveFailures: 0,
+            },
+        };
+        const layersApplied = [];
+        const boundaries = [];
+        let totalTokensFreed = 0;
+        for (const layerName of this.layerOrder) {
+            // Skip auto-compact if disabled or if context collapse is handling it
+            if (layerName === 'auto' && !this.options.autoCompactEnabled)
+                continue;
+            if (layerName === 'auto' && this.options.contextCollapseEnabled)
+                continue;
+            if (layerName === 'collapse' && !this.options.contextCollapseEnabled)
+                continue;
+            const layer = this.layers.get(layerName);
+            if (!layer)
+                continue;
+            if (layer.shouldApply(ctx)) {
+                try {
+                    const prevLength = ctx.messages.length;
+                    ctx = await layer.apply(ctx);
+                    // Track what was applied
+                    if (ctx.messages.length !== prevLength || ctx.compactionHistory) {
+                        layersApplied.push(layerName);
+                        // Get the latest boundary
+                        const latestBoundary = (_a = ctx.compactionHistory) === null || _a === void 0 ? void 0 : _a.at(-1);
+                        if (latestBoundary) {
+                            boundaries.push(latestBoundary);
+                            totalTokensFreed += latestBoundary.tokensFreed;
+                        }
+                    }
+                }
+                catch (error) {
+                    if (this.options.enableLogging) {
+                        console.error(`[CompactionOrchestrator] Layer ${layerName} failed:`, error);
+                    }
+                }
+            }
+        }
+        // Run post-compact cleanup
+        if (layersApplied.length > 0) {
+            this.cleanup.runCleanup(this.layers, layersApplied);
+        }
+        const wasCompacted = layersApplied.length > 0;
+        if (wasCompacted && this.options.enableLogging) {
+            console.log(`[CompactionOrchestrator] Compacted: layers=[${layersApplied.join(',')}], tokensFreed=${totalTokensFreed}`);
+        }
+        return {
+            messages: ctx.messages,
+            totalTokensFreed,
+            layersApplied,
+            boundaries,
+            wasCompacted,
+        };
+    }
+    /**
+     * Attempt reactive recovery from an API error.
+     * Only called when the proactive pipeline didn't prevent overflow.
+     */
+    async recoverFromError(messages, error) {
+        const ctx = {
+            messages,
+            contextCollapseEnabled: this.options.contextCollapseEnabled,
+            compactionHistory: [],
+        };
+        // First try context collapse recovery (cheap: drain staged collapses)
+        if (this.options.contextCollapseEnabled) {
+            const collapseResult = this.collapse.recoverFromOverflow(messages);
+            if (collapseResult.committed > 0) {
+                return {
+                    messages: collapseResult.messages,
+                    totalTokensFreed: 0, // Already accounted for in collapse
+                    layersApplied: ['collapse'],
+                    boundaries: [{
+                            layer: 'collapse',
+                            tokensFreed: 0,
+                            messagesRemoved: 0,
+                            timestamp: new Date().toISOString(),
+                            committed: collapseResult.committed,
+                        }],
+                    wasCompacted: true,
+                };
+            }
+        }
+        // Fall through to reactive compact
+        const result = await this.reactive.tryRecoverFromError(ctx, error);
+        if (result.recovered) {
+            this.reactive.resetForTurn();
+            return {
+                messages: result.messages,
+                totalTokensFreed: result.tokensBefore - result.tokensAfter,
+                layersApplied: ['reactive'],
+                boundaries: [{
+                        layer: 'reactive',
+                        tokensFreed: result.tokensBefore - result.tokensAfter,
+                        messagesRemoved: 0,
+                        timestamp: new Date().toISOString(),
+                    }],
+                wasCompacted: true,
+            };
+        }
+        return {
+            messages,
+            totalTokensFreed: 0,
+            layersApplied: [],
+            boundaries: [],
+            wasCompacted: false,
+        };
+    }
+    /**
+     * Get the current auto-compact tracking state.
+     */
+    getAutoCompactTracking() {
+        return this.auto.getTracking();
+    }
+    /**
+     * Get the number of consecutive auto-compact failures.
+     */
+    getConsecutiveFailures() {
+        return this.auto.getConsecutiveFailures();
+    }
+    /**
+     * Reset the reactive compact's per-turn guard.
+     * Call at the start of each new turn.
+     */
+    resetForTurn() {
+        this.reactive.resetForTurn();
+    }
+    /**
+     * Reset all compaction state.
+     */
+    resetAll() {
+        for (const [, layer] of this.layers) {
+            try {
+                layer.reset();
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    // ─── Convenience Accessors ──────────────────────────────────────
+    getSnipLayer() { return this.snip; }
+    getMicroLayer() { return this.micro; }
+    getCollapseLayer() { return this.collapse; }
+    getAutoLayer() { return this.auto; }
+    getReactiveLayer() { return this.reactive; }
+}
+exports.CompactionOrchestrator = CompactionOrchestrator;

package/dist/unified/services/compaction/contextCollapse.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Layer 3: Context Collapse
+ *
+ * Incrementally archives messages into a collapse store with granular summaries.
+ * Unlike full auto-compact which produces one monolithic summary, context collapse
+ * preserves granular per-range summaries so more context is retained.
+ *
+ * Key properties:
+ * - Commits at ~90% of context window
+ * - Blocks at ~95% (hard limit)
+ * - Archives messages incrementally (not all at once)
+ * - Read-time projection over full history
+ * - Recovery: drains staged collapses on 413 errors (cheap)
+ * - When enabled, suppresses auto-compact to avoid racing
+ */
+import type { MessageObject } from '@codebolt/types/sdk';
+import { type CompactionContext, type CompactionLayer, type CompactionLayerKind } from './types';
+export interface ContextCollapseOptions {
+    /** Commit threshold as fraction of context window (default: 0.9) */
+    commitThreshold?: number;
+    /** Blocking threshold as fraction of context window (default: 0.95) */
+    blockingThreshold?: number;
+    /** Model token limit (default: 128000) */
+    modelTokenLimit?: number;
+    /** LLM role for granular summarization (default: 'summarizer') */
+    llmRole?: string;
+    /** Max summaries to keep in the collapse store (default: 20) */
+    maxSummaries?: number;
+    /** Enable logging (default: false) */
+    enableLogging?: boolean;
+}
+export declare class ContextCollapse implements CompactionLayer {
+    readonly name: CompactionLayerKind;
+    private readonly options;
+    /** The collapse store: ordered list of collapsed ranges */
+    private store;
+    /** Staged collapses waiting for API confirmation */
+    private staged;
+    constructor(options?: ContextCollapseOptions);
+    shouldApply(ctx: CompactionContext): boolean;
+    apply(ctx: CompactionContext): Promise<CompactionContext>;
+    /**
+     * Drain staged collapses on API 413 errors (recovery path).
+     * Confirms all staged entries into the permanent store.
+     */
+    drainStaged(): number;
+    /**
+     * Recovery from overflow: drain staged collapses and rebuild.
+     */
+    recoverFromOverflow(messages: MessageObject[]): {
+        messages: MessageObject[];
+        committed: number;
+    };
+    /**
+     * Check if at blocking threshold.
+     */
+    isAtBlockingLimit(messages: MessageObject[]): boolean;
+    reset(): void;
+    private findSplitPoint;
+    private buildSummaryMessages;
+    private generateGranularSummary;
+    private createStructuralSummary;
+}