@codebolt/agent 6.0.0 → 6.1.2

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

@@ -0,0 +1,34 @@
+/**
+ * Layer 2: Micro Compact
+ *
+ * Three sub-mechanisms for clearing old tool results:
+ *   2a. Time-based: clear old tool results after inactivity gap, keeps N most recent.
+ *   2b. Count-based: Clear when registered results exceed threshold.
+ *   2c. Budget-based: truncate largest results when total exceeds budget.
+ *
+ * Key properties:
+ * - Cheaper than collapse/auto (no LLM call, just content replacement)
+ * - Time-based fires when cache is cold (long gap = server cache expired)
+ * - Count-based fires when tool result count exceeds threshold
+ * - Both preserve the most recent N tool results
+ */
+import { type CompactionContext, type CompactionLayer, type CompactionLayerKind } from './types';
+export interface MicroCompactOptions {
+    gapThresholdMinutes?: number;
+    keepRecent?: number;
+    compactableTools?: string[];
+    tokenBudget?: number;
+    enableLogging?: boolean;
+}
+export declare class MicroCompact implements CompactionLayer {
+    readonly name: CompactionLayerKind;
+    private readonly options;
+    constructor(options?: MicroCompactOptions);
+    shouldApply(ctx: CompactionContext): boolean;
+    apply(ctx: CompactionContext): Promise<CompactionContext>;
+    reset(): void;
+    private evaluateTimeTrigger;
+    private collectCompactableToolIds;
+    private clearOldToolResults;
+    private estimateToolResultTokens;
+}

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

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Layer 2: Micro Compact
+ *
+ * Three sub-mechanisms for clearing old tool results:
+ *   2a. Time-based: clear old tool results after inactivity gap, keeps N most recent.
+ *   2b. Count-based: Clear when registered results exceed threshold.
+ *   2c. Budget-based: truncate largest results when total exceeds budget.
+ *
+ * Key properties:
+ * - Cheaper than collapse/auto (no LLM call, just content replacement)
+ * - Time-based fires when cache is cold (long gap = server cache expired)
+ * - Count-based fires when tool result count exceeds threshold
+ * - Both preserve the most recent N tool results
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicroCompact = void 0;
+const types_1 = require("./types");
+const CLEAR_PLACEHOLDER = '[Old tool result content cleared]';
+const DEFAULT_GAP_THRESHOLD_MINUTES = 60;
+const DEFAULT_KEEP_RECENT = 5;
+const DEFAULT_COMPACTABLE_TOOLS = [
+    'read_file', 'write_file', 'edit_file', 'list_directory',
+    'search_files', 'execute_command', 'shell', 'bash',
+    'glob', 'grep', 'web_search', 'web_fetch',
+];
+class MicroCompact {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        this.name = 'micro';
+        this.options = {
+            gapThresholdMinutes: (_a = options === null || options === void 0 ? void 0 : options.gapThresholdMinutes) !== null && _a !== void 0 ? _a : DEFAULT_GAP_THRESHOLD_MINUTES,
+            keepRecent: (_b = options === null || options === void 0 ? void 0 : options.keepRecent) !== null && _b !== void 0 ? _b : DEFAULT_KEEP_RECENT,
+            compactableTools: new Set((_c = options === null || options === void 0 ? void 0 : options.compactableTools) !== null && _c !== void 0 ? _c : DEFAULT_COMPACTABLE_TOOLS),
+            tokenBudget: (_d = options === null || options === void 0 ? void 0 : options.tokenBudget) !== null && _d !== void 0 ? _d : 50000,
+            enableLogging: (_e = options === null || options === void 0 ? void 0 : options.enableLogging) !== null && _e !== void 0 ? _e : false,
+        };
+    }
+    shouldApply(ctx) {
+        const messages = ctx.messages;
+        if (!messages || messages.length === 0)
+            return false;
+        // Time-based trigger
+        if (this.evaluateTimeTrigger(messages))
+            return true;
+        // Count-based trigger
+        if (this.collectCompactableToolIds(messages).length > this.options.keepRecent)
+            return true;
+        // Budget-based trigger
+        if (this.estimateToolResultTokens(messages) > this.options.tokenBudget)
+            return true;
+        return false;
+    }
+    async apply(ctx) {
+        const messages = ctx.messages;
+        const timeTrigger = this.evaluateTimeTrigger(messages);
+        const allIds = this.collectCompactableToolIds(messages);
+        const keepRecent = Math.max(1, this.options.keepRecent);
+        const keepSet = new Set(allIds.slice(-keepRecent));
+        const subMechanism = timeTrigger ? 'time_based' : 'count_based';
+        const { result, tokensSaved } = this.clearOldToolResults(messages, keepSet);
+        if (tokensSaved === 0) {
+            return ctx;
+        }
+        const boundary = {
+            layer: 'micro',
+            tokensFreed: tokensSaved,
+            messagesRemoved: 0,
+            timestamp: new Date().toISOString(),
+        };
+        if (this.options.enableLogging) {
+            console.log(`[MicroCompact] ${subMechanism}: cleared tool results, ~${tokensSaved} tokens freed`);
+        }
+        return {
+            ...ctx,
+            messages: result,
+            compactionHistory: [...(ctx.compactionHistory || []), boundary],
+        };
+    }
+    reset() {
+        // Stateless across turns
+    }
+    // ─── Private Helpers ──────────────────────────────────────────────
+    evaluateTimeTrigger(messages) {
+        var _a, _b;
+        let lastAssistant;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (((_a = messages[i]) === null || _a === void 0 ? void 0 : _a.role) === 'assistant') {
+                lastAssistant = messages[i];
+                break;
+            }
+        }
+        if (!lastAssistant)
+            return null;
+        const timestamp = (_b = lastAssistant.timestamp) !== null && _b !== void 0 ? _b : lastAssistant.created_at;
+        if (!timestamp)
+            return null;
+        const gapMs = Date.now() - new Date(timestamp).getTime();
+        const gapMinutes = gapMs / 60000;
+        if (!Number.isFinite(gapMinutes) || gapMinutes < this.options.gapThresholdMinutes) {
+            return null;
+        }
+        return { gapMinutes };
+    }
+    collectCompactableToolIds(messages) {
+        var _a, _b;
+        const ids = [];
+        for (const msg of messages) {
+            if ((msg === null || msg === void 0 ? void 0 : msg.role) === 'assistant' && Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block && typeof block === 'object' &&
+                        block.type === 'tool_use' &&
+                        this.options.compactableTools.has(block.name)) {
+                        ids.push(block.id);
+                    }
+                }
+            }
+            if ((msg === null || msg === void 0 ? void 0 : msg.role) === 'assistant' && Array.isArray(msg.tool_calls)) {
+                for (const tc of msg.tool_calls) {
+                    if (tc && this.options.compactableTools.has((_b = (_a = tc.function) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : tc.name)) {
+                        ids.push(tc.id);
+                    }
+                }
+            }
+        }
+        return ids;
+    }
+    clearOldToolResults(messages, keepSet) {
+        const clearSet = new Set(this.collectCompactableToolIds(messages).filter(id => !keepSet.has(id)));
+        if (clearSet.size === 0) {
+            return { result: messages, tokensSaved: 0 };
+        }
+        let tokensSaved = 0;
+        const estimator = new types_1.TokenEstimator();
+        const result = messages.map(msg => {
+            var _a;
+            if (msg.role === 'tool' || msg.tool_call_id) {
+                const toolCallId = msg.tool_call_id;
+                if (clearSet.has(toolCallId)) {
+                    const originalContent = typeof msg.content === 'string'
+                        ? msg.content : JSON.stringify((_a = msg.content) !== null && _a !== void 0 ? _a : '');
+                    tokensSaved += estimator.estimate(originalContent);
+                    return { ...msg, content: CLEAR_PLACEHOLDER };
+                }
+            }
+            if (msg.role === 'user' && Array.isArray(msg.content)) {
+                let touched = false;
+                const newContent = msg.content.map((block) => {
+                    var _a, _b;
+                    if (block &&
+                        (block.type === 'tool_result' || block.type === 'function_response') &&
+                        clearSet.has((_a = block.tool_use_id) !== null && _a !== void 0 ? _a : block.tool_call_id)) {
+                        const originalContent = typeof block.content === 'string'
+                            ? block.content : JSON.stringify((_b = block.content) !== null && _b !== void 0 ? _b : '');
+                        tokensSaved += estimator.estimate(originalContent);
+                        touched = true;
+                        return { ...block, content: CLEAR_PLACEHOLDER };
+                    }
+                    return block;
+                });
+                if (!touched)
+                    return msg;
+                return { ...msg, content: newContent };
+            }
+            return msg;
+        });
+        return { result, tokensSaved };
+    }
+    estimateToolResultTokens(messages) {
+        var _a, _b, _c;
+        const estimator = new types_1.TokenEstimator();
+        let total = 0;
+        for (const msg of messages) {
+            if (msg.role === 'tool' || msg.tool_call_id) {
+                const toolName = (_a = msg.name) !== null && _a !== void 0 ? _a : '';
+                if (this.options.compactableTools.has(toolName)) {
+                    const content = typeof msg.content === 'string'
+                        ? msg.content : JSON.stringify((_b = msg.content) !== null && _b !== void 0 ? _b : '');
+                    total += estimator.estimate(content);
+                }
+            }
+            if (msg.role === 'user' && Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block && (block.type === 'tool_result' || block.type === 'function_response')) {
+                        const content = typeof block.content === 'string'
+                            ? block.content : JSON.stringify((_c = block.content) !== null && _c !== void 0 ? _c : '');
+                        total += estimator.estimate(content);
+                    }
+                }
+            }
+        }
+        return total;
+    }
+}
+exports.MicroCompact = MicroCompact;

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

@@ -0,0 +1,15 @@
+/**
+ * Post-Compact Cleanup
+ *
+ * Resets ALL tracking state after any compaction event.
+ * Called after both auto-compact and manual /compact to free memory
+ * held by tracking structures that are invalidated by compaction.
+ */
+import type { CompactionLayerKind, CompactionLayer } from './types';
+export interface PostCompactCleanupOptions {
+    enableLogging?: boolean;
+}
+export declare class PostCompactCleanup {
+    constructor(_options?: PostCompactCleanupOptions);
+    runCleanup(layers: Map<CompactionLayerKind, CompactionLayer>, appliedLayers: CompactionLayerKind[]): void;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Post-Compact Cleanup
+ *
+ * Resets ALL tracking state after any compaction event.
+ * Called after both auto-compact and manual /compact to free memory
+ * held by tracking structures that are invalidated by compaction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostCompactCleanup = void 0;
+class PostCompactCleanup {
+    constructor(_options) { }
+    runCleanup(layers, appliedLayers) {
+        for (const layerName of appliedLayers) {
+            const layer = layers.get(layerName);
+            if (layer) {
+                try {
+                    layer.reset();
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        // Always reset reactive compact even if not applied
+        const reactive = layers.get('reactive');
+        if (reactive && !appliedLayers.includes('reactive')) {
+            try {
+                reactive.reset();
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+}
+exports.PostCompactCleanup = PostCompactCleanup;

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

@@ -0,0 +1,65 @@
+/**
+ * Layer 5: Reactive Compact
+ *
+ * Emergency compaction triggered by API errors (413 prompt-too-long,
+ * media-size errors). This is the last line of defense when all proactive
+ * layers fail to keep the context under the limit.
+ *
+ * Key properties:
+ * - Only fires on real API errors after proactive measures fail
+ * - Single-shot per turn (prevents spiral: error -> compact -> error -> compact)
+ * - Tries: strip images -> strip older messages -> full compact
+ * - Withholds error from consumers until recovery succeeds or exhausts
+ */
+import type { MessageObject } from '@codebolt/types/sdk';
+import { type CompactionContext, type CompactionLayer, type CompactionLayerKind } from './types';
+export interface ReactiveCompactOptions {
+    /** Max retry attempts per turn (default: 1) */
+    retryLimit?: number;
+    /** Model token limit (default: 128000) */
+    modelTokenLimit?: number;
+    /** Enable logging (default: false) */
+    enableLogging?: boolean;
+}
+export interface ReactiveRecoveryResult {
+    recovered: boolean;
+    messages: MessageObject[];
+    reason: string;
+    tokensBefore: number;
+    tokensAfter: number;
+}
+export declare class ReactiveCompact implements CompactionLayer {
+    readonly name: CompactionLayerKind;
+    private readonly options;
+    private hasAttemptedThisTurn;
+    private retryCount;
+    constructor(options?: ReactiveCompactOptions);
+    shouldApply(_ctx: CompactionContext): boolean;
+    apply(_ctx: CompactionContext): Promise<CompactionContext>;
+    reset(): void;
+    /**
+     * Reset per-turn guard (call at the start of each turn).
+     */
+    resetForTurn(): void;
+    /**
+     * Check if an error message indicates a recoverable context error.
+     */
+    isRecoverableError(errorMessage: string): boolean;
+    /**
+     * Check if an error is a media/size error (images, PDFs, etc.)
+     */
+    isMediaSizeError(error: unknown): boolean;
+    /**
+     * Attempt to recover from a context overflow error.
+     * Single-shot per turn to prevent death spirals.
+     *
+     * Recovery strategy:
+     *   1. Strip images and retry (for media errors)
+     *   2. Strip oldest messages (keep recent context)
+     *   3. Force full compact if available
+     */
+    tryRecoverFromError(ctx: CompactionContext, error: unknown): Promise<ReactiveRecoveryResult>;
+    private stripImages;
+    private stripOldestMessages;
+    private forceCompact;
+}

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

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * Layer 5: Reactive Compact
+ *
+ * Emergency compaction triggered by API errors (413 prompt-too-long,
+ * media-size errors). This is the last line of defense when all proactive
+ * layers fail to keep the context under the limit.
+ *
+ * Key properties:
+ * - Only fires on real API errors after proactive measures fail
+ * - Single-shot per turn (prevents spiral: error -> compact -> error -> compact)
+ * - Tries: strip images -> strip older messages -> full compact
+ * - Withholds error from consumers until recovery succeeds or exhausts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactiveCompact = void 0;
+const types_1 = require("./types");
+/** Error patterns that indicate context overflow */
+const CONTEXT_ERROR_PATTERNS = [
+    /prompt too long/i,
+    /context length/i,
+    /maximum context/i,
+    /context window/i,
+    /too many tokens/i,
+    /token limit/i,
+    /request too large/i,
+    /input is too long/i,
+    /reduced_image_max_pixels/i,
+    /image.*too large/i,
+];
+/** Messages to always preserve during reactive compact */
+const MIN_PRESERVED_MESSAGES = 6;
+class ReactiveCompact {
+    constructor(options) {
+        var _a, _b, _c;
+        this.name = 'reactive';
+        this.hasAttemptedThisTurn = false;
+        this.retryCount = 0;
+        this.options = {
+            retryLimit: (_a = options === null || options === void 0 ? void 0 : options.retryLimit) !== null && _a !== void 0 ? _a : 1,
+            modelTokenLimit: (_b = options === null || options === void 0 ? void 0 : options.modelTokenLimit) !== null && _b !== void 0 ? _b : 128000,
+            enableLogging: (_c = options === null || options === void 0 ? void 0 : options.enableLogging) !== null && _c !== void 0 ? _c : false,
+        };
+    }
+    shouldApply(_ctx) {
+        // Reactive only fires when explicitly triggered by an error
+        // via tryRecoverFromError(), not proactively
+        return false;
+    }
+    async apply(_ctx) {
+        // Reactive compact is not applied proactively
+        return _ctx;
+    }
+    reset() {
+        this.hasAttemptedThisTurn = false;
+        this.retryCount = 0;
+    }
+    /**
+     * Reset per-turn guard (call at the start of each turn).
+     */
+    resetForTurn() {
+        this.hasAttemptedThisTurn = false;
+    }
+    /**
+     * Check if an error message indicates a recoverable context error.
+     */
+    isRecoverableError(errorMessage) {
+        return CONTEXT_ERROR_PATTERNS.some(pattern => pattern.test(errorMessage));
+    }
+    /**
+     * Check if an error is a media/size error (images, PDFs, etc.)
+     */
+    isMediaSizeError(error) {
+        if (!error)
+            return false;
+        const msg = error instanceof Error
+            ? error.message
+            : typeof error === 'string'
+                ? error
+                : String(error);
+        return (/image.*too large/i.test(msg) ||
+            /reduced_image_max_pixels/i.test(msg) ||
+            /media.*size/i.test(msg) ||
+            /too many images/i.test(msg));
+    }
+    /**
+     * Attempt to recover from a context overflow error.
+     * Single-shot per turn to prevent death spirals.
+     *
+     * Recovery strategy:
+     *   1. Strip images and retry (for media errors)
+     *   2. Strip oldest messages (keep recent context)
+     *   3. Force full compact if available
+     */
+    async tryRecoverFromError(ctx, error) {
+        const estimator = new types_1.TokenEstimator();
+        const messages = [...ctx.messages];
+        const tokensBefore = estimator.estimateForMessages(messages);
+        // Single-shot guard
+        if (this.hasAttemptedThisTurn) {
+            return {
+                recovered: false,
+                messages,
+                reason: 'Already attempted reactive compact this turn',
+                tokensBefore,
+                tokensAfter: tokensBefore,
+            };
+        }
+        // Check retry limit
+        if (this.retryCount >= this.options.retryLimit) {
+            return {
+                recovered: false,
+                messages,
+                reason: `Reactive compact retry limit reached (${this.options.retryLimit})`,
+                tokensBefore,
+                tokensAfter: tokensBefore,
+            };
+        }
+        this.hasAttemptedThisTurn = true;
+        this.retryCount++;
+        // Strategy 1: Strip images (for media-size errors)
+        if (this.isMediaSizeError(error)) {
+            const stripped = this.stripImages(messages);
+            const tokensAfter = estimator.estimateForMessages(stripped);
+            if (tokensAfter < tokensBefore) {
+                if (this.options.enableLogging) {
+                    console.log(`[ReactiveCompact] Stripped images: ${tokensBefore} -> ${tokensAfter} tokens`);
+                }
+                return {
+                    recovered: true,
+                    messages: stripped,
+                    reason: 'Stripped oversized images',
+                    tokensBefore,
+                    tokensAfter,
+                };
+            }
+        }
+        // Strategy 2: Strip oldest messages (aggressive)
+        const aggressiveResult = this.stripOldestMessages(messages);
+        if (aggressiveResult) {
+            const tokensAfter = estimator.estimateForMessages(aggressiveResult);
+            const threshold = this.options.modelTokenLimit * 0.7;
+            if (tokensAfter < threshold) {
+                if (this.options.enableLogging) {
+                    console.log(`[ReactiveCompact] Stripped old messages: ${tokensBefore} -> ${tokensAfter} tokens`);
+                }
+                return {
+                    recovered: true,
+                    messages: aggressiveResult,
+                    reason: 'Stripped oldest messages',
+                    tokensBefore,
+                    tokensAfter,
+                };
+            }
+        }
+        // Strategy 3: Force compact - summarize everything aggressively
+        const forceResult = await this.forceCompact(messages);
+        if (forceResult) {
+            const tokensAfter = estimator.estimateForMessages(forceResult);
+            if (tokensAfter < tokensBefore * 0.8) {
+                if (this.options.enableLogging) {
+                    console.log(`[ReactiveCompact] Force compact: ${tokensBefore} -> ${tokensAfter} tokens`);
+                }
+                return {
+                    recovered: true,
+                    messages: forceResult,
+                    reason: 'Force compacted conversation',
+                    tokensBefore,
+                    tokensAfter,
+                };
+            }
+        }
+        return {
+            recovered: false,
+            messages,
+            reason: 'All reactive recovery strategies exhausted',
+            tokensBefore,
+            tokensAfter: tokensBefore,
+        };
+    }
+    // ─── Private Helpers ──────────────────────────────────────────────
+    stripImages(messages) {
+        return messages.map(msg => {
+            if (!msg || typeof msg.content !== 'object' || !Array.isArray(msg.content)) {
+                return msg;
+            }
+            const filtered = msg.content.filter((block) => {
+                if (!block)
+                    return true;
+                if (block.type === 'image_url' ||
+                    block.type === 'image' ||
+                    (block.type === 'text' &&
+                        typeof block.text === 'string' &&
+                        block.text.startsWith('data:image'))) {
+                    return false;
+                }
+                return true;
+            });
+            if (filtered.length === msg.content.length) {
+                return msg;
+            }
+            if (filtered.length < msg.content.length) {
+                filtered.push({
+                    type: 'text',
+                    text: `[${msg.content.length - filtered.length} image(s) removed due to size limits]`,
+                });
+            }
+            return { ...msg, content: filtered };
+        });
+    }
+    stripOldestMessages(messages) {
+        const systemMessages = messages.filter(m => (m === null || m === void 0 ? void 0 : m.role) === 'system');
+        const nonSystemMessages = messages.filter(m => (m === null || m === void 0 ? void 0 : m.role) !== 'system');
+        if (nonSystemMessages.length <= MIN_PRESERVED_MESSAGES) {
+            return null;
+        }
+        const recentMessages = nonSystemMessages.slice(-MIN_PRESERVED_MESSAGES);
+        const strippedCount = nonSystemMessages.length - MIN_PRESERVED_MESSAGES;
+        return [
+            ...systemMessages,
+            {
+                role: 'user',
+                content: `[Emergency context reduction: ${strippedCount} older messages removed due to context overflow. The current task context is preserved below.]`,
+            },
+            {
+                role: 'assistant',
+                content: 'Understood. I will work with the available context.',
+            },
+            ...recentMessages,
+        ];
+    }
+    async forceCompact(messages) {
+        var _a, _b, _c, _d, _e;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const codebolt = require('@codebolt/codeboltjs');
+            const systemMessages = messages.filter(m => (m === null || m === void 0 ? void 0 : m.role) === 'system');
+            const nonSystemMessages = messages.filter(m => (m === null || m === void 0 ? void 0 : m.role) !== 'system');
+            if (nonSystemMessages.length <= MIN_PRESERVED_MESSAGES) {
+                return null;
+            }
+            const toSummarize = nonSystemMessages.slice(0, -MIN_PRESERVED_MESSAGES);
+            const toKeep = nonSystemMessages.slice(-MIN_PRESERVED_MESSAGES);
+            const historyText = toSummarize
+                .map((msg, i) => {
+                var _a;
+                const content = typeof msg.content === 'string'
+                    ? msg.content
+                    : JSON.stringify((_a = msg.content) !== null && _a !== void 0 ? _a : '');
+                const truncated = content.length > 500
+                    ? content.slice(0, 250) + '...[truncated]...' + content.slice(-250)
+                    : content;
+                return `[${i}] ${msg.role}: ${truncated}`;
+            })
+                .join('\n');
+            const prompt = `Emergency context compression. Create a very concise summary preserving only:
+1. The user's original task/request
+2. Key files being worked on (paths)
+3. Current state and next step
+4. Any critical errors/blockers
+
+Conversation:
+${historyText}`;
+            const response = await codebolt.llm.inference({
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'Create an extremely concise summary. Focus on actionable facts only.',
+                    },
+                    { role: 'user', content: prompt },
+                ],
+            });
+            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 null;
+            }
+            return [
+                ...systemMessages,
+                {
+                    role: 'user',
+                    content: `[Emergency context recovery. Previous conversation summary:\n\n${summary}]\n\nRecent context continues below.`,
+                },
+                {
+                    role: 'assistant',
+                    content: 'Understood. I have the compressed context and will continue.',
+                },
+                ...toKeep,
+            ];
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.ReactiveCompact = ReactiveCompact;

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

@@ -0,0 +1,31 @@
+/**
+ * Layer 1: Snip Compact
+ *
+ * Proactively removes older messages from the model-facing view each turn.
+ * Keeps them in the conversation for scrollback/UI purposes, but removes
+ * them from what gets sent to the LLM.
+ *
+ * Key properties:
+ * - Runs every turn, proactively
+ * - tokensFreed is plumbed to autocompact so its threshold check is accurate
+ * - Cheapest compaction layer (no LLM call, just array slicing)
+ */
+import { type CompactionContext, type CompactionLayer, type CompactionLayerKind } from './types';
+export interface SnipCompactOptions {
+    /** Number of recent turns to protect (default: 4) */
+    protectedTurns?: number;
+    /** Max fraction of messages to remove (default: 0.4) */
+    maxSnipFraction?: number;
+    /** Enable logging (default: false) */
+    enableLogging?: boolean;
+}
+export declare class SnipCompact implements CompactionLayer {
+    readonly name: CompactionLayerKind;
+    private readonly options;
+    constructor(options?: SnipCompactOptions);
+    shouldApply(ctx: CompactionContext): boolean;
+    apply(ctx: CompactionContext): Promise<CompactionContext>;
+    reset(): void;
+    private findTurnStarts;
+    private isToolResponse;
+}