@compilr-dev/agents 0.0.1

package/dist/context/manager.js

@@ -0,0 +1,770 @@
+/**
+ * ContextManager - Manages agent context windows
+ *
+ * Handles token tracking, compaction, summarization, and filtering
+ * to keep agent context within limits while preserving important information.
+ *
+ * @example
+ * ```typescript
+ * const contextManager = new ContextManager({
+ *   provider,
+ *   maxContextTokens: 200000,
+ * });
+ *
+ * // Check if action needed
+ * if (contextManager.needsSummarization()) {
+ *   await contextManager.summarize(messages);
+ * }
+ * ```
+ */
+/**
+ * Default budget allocation
+ */
+export const DEFAULT_BUDGET_ALLOCATION = {
+    system: 0.05, // 5% for system prompt
+    recentMessages: 0.4, // 40% for recent conversation
+    toolResults: 0.25, // 25% for tool outputs
+    history: 0.3, // 30% for older context
+};
+/**
+ * Default context configuration
+ */
+export const DEFAULT_CONTEXT_CONFIG = {
+    maxContextTokens: 200000, // Claude's context window
+    budget: { ...DEFAULT_BUDGET_ALLOCATION },
+    verbosity: {
+        fullThreshold: 0.5, // Full output below 50%
+        normalThreshold: 0.8, // Normal output below 80%
+        abbreviatedThreshold: 0.95, // Abbreviated below 95%, minimal above
+    },
+    filtering: {
+        maxToolResultTokens: 80000,
+        maxFileLines: 500,
+        maxErrorLines: 50,
+    },
+    compaction: {
+        triggerInterval: 20,
+        triggerThreshold: 0.5,
+        preserveRecentTurns: 10,
+        minTokensToCompact: 1000,
+    },
+    summarization: {
+        warningThreshold: 0.8,
+        triggerThreshold: 0.9,
+        emergencyThreshold: 0.95,
+        preserveRecentMessages: 6,
+        emergencyPreserveMessages: 4,
+        summaryMaxTokens: 2000,
+        maxRounds: 3,
+        targetUtilization: 0.7,
+    },
+};
+/**
+ * ContextManager tracks and manages context window usage
+ */
+export class ContextManager {
+    provider;
+    config;
+    onEvent;
+    cachedTokenCount = 0;
+    turnCount = 0;
+    compactionCount = 0;
+    summarizationCount = 0;
+    lastCompactionTurn = 0;
+    // Budget tracking - tokens used per category
+    categoryUsage = {
+        system: 0,
+        recentMessages: 0,
+        toolResults: 0,
+        history: 0,
+    };
+    constructor(options) {
+        this.provider = options.provider;
+        this.config = this.mergeConfig(options.config);
+        this.onEvent = options.onEvent;
+    }
+    /**
+     * Merge partial config with defaults
+     */
+    mergeConfig(partial) {
+        if (!partial) {
+            return {
+                ...DEFAULT_CONTEXT_CONFIG,
+                budget: { ...DEFAULT_CONTEXT_CONFIG.budget },
+                verbosity: { ...DEFAULT_CONTEXT_CONFIG.verbosity },
+                filtering: { ...DEFAULT_CONTEXT_CONFIG.filtering },
+                compaction: { ...DEFAULT_CONTEXT_CONFIG.compaction },
+                summarization: { ...DEFAULT_CONTEXT_CONFIG.summarization },
+            };
+        }
+        return {
+            maxContextTokens: partial.maxContextTokens ?? DEFAULT_CONTEXT_CONFIG.maxContextTokens,
+            budget: { ...DEFAULT_CONTEXT_CONFIG.budget, ...partial.budget },
+            verbosity: { ...DEFAULT_CONTEXT_CONFIG.verbosity, ...partial.verbosity },
+            filtering: { ...DEFAULT_CONTEXT_CONFIG.filtering, ...partial.filtering },
+            compaction: { ...DEFAULT_CONTEXT_CONFIG.compaction, ...partial.compaction },
+            summarization: { ...DEFAULT_CONTEXT_CONFIG.summarization, ...partial.summarization },
+        };
+    }
+    /**
+     * Emit a context event
+     */
+    emit(event) {
+        this.onEvent?.(event);
+    }
+    /**
+     * Count tokens in messages using the provider
+     */
+    async countTokens(messages) {
+        if (this.provider.countTokens) {
+            return this.provider.countTokens(messages);
+        }
+        // Fallback: rough estimate based on character count
+        let charCount = 0;
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                charCount += msg.content.length;
+            }
+            else {
+                for (const block of msg.content) {
+                    switch (block.type) {
+                        case 'text':
+                            charCount += block.text.length;
+                            break;
+                        case 'tool_use':
+                            charCount += JSON.stringify(block.input).length;
+                            break;
+                        case 'tool_result':
+                            charCount += block.content.length;
+                            break;
+                    }
+                }
+            }
+        }
+        return Math.ceil(charCount / 4);
+    }
+    /**
+     * Update token count for messages
+     */
+    async updateTokenCount(messages) {
+        this.cachedTokenCount = await this.countTokens(messages);
+        return this.cachedTokenCount;
+    }
+    /**
+     * Get current token count (cached)
+     */
+    getTokenCount() {
+        return this.cachedTokenCount;
+    }
+    /**
+     * Get context utilization (0.0 - 1.0)
+     */
+    getUtilization() {
+        return this.cachedTokenCount / this.config.maxContextTokens;
+    }
+    /**
+     * Get maximum context tokens
+     */
+    getMaxTokens() {
+        return this.config.maxContextTokens;
+    }
+    /**
+     * Increment turn count (call after each assistant response)
+     */
+    incrementTurn() {
+        this.turnCount++;
+    }
+    /**
+     * Check if compaction is needed
+     */
+    needsCompaction() {
+        // Check turn-based trigger
+        const turnsSinceCompaction = this.turnCount - this.lastCompactionTurn;
+        if (turnsSinceCompaction >= this.config.compaction.triggerInterval) {
+            return true;
+        }
+        // Check utilization-based trigger
+        if (this.getUtilization() >= this.config.compaction.triggerThreshold) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if summarization is needed (more aggressive than compaction)
+     */
+    needsSummarization() {
+        return this.getUtilization() >= this.config.summarization.triggerThreshold;
+    }
+    /**
+     * Check if content should be filtered before adding
+     */
+    shouldFilter(tokenCount) {
+        return tokenCount > this.config.filtering.maxToolResultTokens;
+    }
+    /**
+     * Get context statistics
+     */
+    getStats(messageCount) {
+        return {
+            currentTokens: this.cachedTokenCount,
+            maxTokens: this.config.maxContextTokens,
+            utilization: this.getUtilization(),
+            messageCount,
+            turnCount: this.turnCount,
+            compactionCount: this.compactionCount,
+            summarizationCount: this.summarizationCount,
+        };
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    // ==========================================================================
+    // Budget System (Novel Technique #1)
+    // ==========================================================================
+    /**
+     * Get budget information for a specific category
+     */
+    getCategoryBudget(category) {
+        const allocated = this.config.budget[category];
+        const allocatedTokens = Math.floor(this.config.maxContextTokens * allocated);
+        const used = this.categoryUsage[category];
+        const remaining = Math.max(0, allocatedTokens - used);
+        const utilization = allocatedTokens > 0 ? used / allocatedTokens : 0;
+        return {
+            allocated,
+            allocatedTokens,
+            used,
+            remaining,
+            utilization,
+        };
+    }
+    /**
+     * Get budget information for all categories
+     */
+    getAllBudgets() {
+        return {
+            system: this.getCategoryBudget('system'),
+            recentMessages: this.getCategoryBudget('recentMessages'),
+            toolResults: this.getCategoryBudget('toolResults'),
+            history: this.getCategoryBudget('history'),
+        };
+    }
+    /**
+     * Update token usage for a category
+     */
+    updateCategoryUsage(category, tokens) {
+        this.categoryUsage[category] = tokens;
+        // Update total cached count
+        this.cachedTokenCount = Object.values(this.categoryUsage).reduce((a, b) => a + b, 0);
+    }
+    /**
+     * Add tokens to a category
+     */
+    addToCategory(category, tokens) {
+        this.categoryUsage[category] += tokens;
+        this.cachedTokenCount += tokens;
+    }
+    /**
+     * Check if a specific category needs compaction
+     */
+    categoryNeedsCompaction(category) {
+        const budget = this.getCategoryBudget(category);
+        return budget.utilization >= this.config.compaction.triggerThreshold;
+    }
+    /**
+     * Compact only a specific category
+     *
+     * This is more targeted than full compaction - only affects messages
+     * in the specified category, leaving others untouched.
+     */
+    async compactCategory(messages, category, saveToFile) {
+        const tokensBefore = await this.countTokens(messages);
+        const messagesBefore = messages.length;
+        const filesCreated = [];
+        let compactedIndex = 0;
+        const compactedMessages = [];
+        for (const msg of messages) {
+            // Determine if this message belongs to the target category
+            const msgCategory = this.categorizeMessage(msg);
+            if (msgCategory !== category) {
+                // Not our category, keep as-is
+                compactedMessages.push(msg);
+                continue;
+            }
+            // Compact this message
+            if (typeof msg.content === 'string') {
+                const tokens = Math.ceil(msg.content.length / 4);
+                if (tokens >= this.config.compaction.minTokensToCompact) {
+                    const filePath = await saveToFile(msg.content, compactedIndex++);
+                    filesCreated.push(filePath);
+                    compactedMessages.push({
+                        ...msg,
+                        content: `[Content saved to ${filePath}]`,
+                    });
+                }
+                else {
+                    compactedMessages.push(msg);
+                }
+            }
+            else {
+                // Handle content blocks
+                const compactedBlocks = [];
+                for (const block of msg.content) {
+                    if (block.type === 'tool_result' && category === 'toolResults') {
+                        const tokens = Math.ceil(block.content.length / 4);
+                        if (tokens >= this.config.compaction.minTokensToCompact) {
+                            const filePath = await saveToFile(block.content, compactedIndex++);
+                            filesCreated.push(filePath);
+                            compactedBlocks.push({
+                                ...block,
+                                content: `[Content saved to ${filePath}]`,
+                            });
+                        }
+                        else {
+                            compactedBlocks.push(block);
+                        }
+                    }
+                    else {
+                        compactedBlocks.push(block);
+                    }
+                }
+                compactedMessages.push({ ...msg, content: compactedBlocks });
+            }
+        }
+        const tokensAfter = await this.countTokens(compactedMessages);
+        // Update category usage
+        const tokensSaved = tokensBefore - tokensAfter;
+        this.categoryUsage[category] = Math.max(0, this.categoryUsage[category] - tokensSaved);
+        this.cachedTokenCount = tokensAfter;
+        this.compactionCount++;
+        this.lastCompactionTurn = this.turnCount;
+        const result = {
+            messagesBefore,
+            messagesAfter: compactedMessages.length,
+            tokensBefore,
+            tokensAfter,
+            filesCreated,
+        };
+        this.emit({ type: 'context_compacted', result });
+        return { messages: compactedMessages, result };
+    }
+    /**
+     * Determine which category a message belongs to
+     */
+    categorizeMessage(msg) {
+        if (msg.role === 'system') {
+            return 'system';
+        }
+        // Check if message contains tool results
+        if (typeof msg.content !== 'string') {
+            for (const block of msg.content) {
+                if (block.type === 'tool_result') {
+                    return 'toolResults';
+                }
+            }
+        }
+        // For now, treat all user/assistant messages as recentMessages
+        // The caller should track which are recent vs history
+        return 'recentMessages';
+    }
+    // ==========================================================================
+    // Pre-flight Checks (Novel Technique #2)
+    // ==========================================================================
+    /**
+     * Estimate tokens for a string content
+     */
+    estimateTokens(content) {
+        return Math.ceil(content.length / 4);
+    }
+    /**
+     * Check if content can be added to a category
+     *
+     * Returns a pre-flight result with recommendations for action.
+     */
+    canAddContent(estimatedTokens, category) {
+        const budget = this.getCategoryBudget(category);
+        // Calculate what utilization would be after adding
+        const projectedCategoryUsage = budget.used + estimatedTokens;
+        const projectedCategoryUtilization = projectedCategoryUsage / budget.allocatedTokens;
+        const projectedTotalTokens = this.cachedTokenCount + estimatedTokens;
+        const projectedTotalUtilization = projectedTotalTokens / this.config.maxContextTokens;
+        // Case 1: Content exceeds total context capacity
+        if (projectedTotalUtilization > 1.0) {
+            return {
+                allowed: false,
+                requiresAction: true,
+                action: 'reject',
+                estimatedTokens,
+                budgetRemaining: budget.remaining,
+                recommendation: `Content (~${String(estimatedTokens)} tokens) exceeds available context space. Consider truncating or saving to file.`,
+            };
+        }
+        // Case 2: Would trigger emergency summarization
+        if (projectedTotalUtilization >= this.config.summarization.emergencyThreshold) {
+            return {
+                allowed: false,
+                requiresAction: true,
+                action: 'summarize',
+                estimatedTokens,
+                budgetRemaining: budget.remaining,
+                recommendation: `Adding content would trigger emergency summarization. Consider compacting first.`,
+            };
+        }
+        // Case 3: Category budget exceeded
+        if (projectedCategoryUtilization > 1.0) {
+            return {
+                allowed: false,
+                requiresAction: true,
+                action: 'compact',
+                category,
+                estimatedTokens,
+                budgetRemaining: budget.remaining,
+                recommendation: `Category '${category}' budget would be exceeded. Compact this category first.`,
+            };
+        }
+        // Case 4: Category approaching limit (>80% of category budget)
+        if (projectedCategoryUtilization > 0.8) {
+            return {
+                allowed: true,
+                requiresAction: false,
+                estimatedTokens,
+                budgetRemaining: budget.remaining,
+                recommendation: `Category '${category}' approaching limit (${String(Math.round(projectedCategoryUtilization * 100))}%).`,
+            };
+        }
+        // Case 5: All good
+        return {
+            allowed: true,
+            requiresAction: false,
+            estimatedTokens,
+            budgetRemaining: budget.remaining,
+        };
+    }
+    // ==========================================================================
+    // Graceful Degradation (Novel Technique #3)
+    // ==========================================================================
+    /**
+     * Get current verbosity level based on context utilization
+     *
+     * Tools should adapt their output based on this level.
+     */
+    getVerbosityLevel() {
+        const utilization = this.getUtilization();
+        if (utilization < this.config.verbosity.fullThreshold) {
+            return 'full';
+        }
+        if (utilization < this.config.verbosity.normalThreshold) {
+            return 'normal';
+        }
+        if (utilization < this.config.verbosity.abbreviatedThreshold) {
+            return 'abbreviated';
+        }
+        return 'minimal';
+    }
+    /**
+     * Check if we're in minimal mode (critical context pressure)
+     */
+    isMinimalMode() {
+        return this.getVerbosityLevel() === 'minimal';
+    }
+    /**
+     * Check if emergency summarization is needed
+     */
+    needsEmergencySummarization() {
+        return this.getUtilization() >= this.config.summarization.emergencyThreshold;
+    }
+    // ==========================================================================
+    // Content Filtering
+    // ==========================================================================
+    /**
+     * Filter large content before adding to context
+     *
+     * Returns the filtered content and metadata about what was done.
+     * The caller is responsible for saving to file if needed.
+     */
+    filterContent(content, type) {
+        const originalLength = content.length;
+        const lines = content.split('\n');
+        let maxLines;
+        switch (type) {
+            case 'file':
+                maxLines = this.config.filtering.maxFileLines;
+                break;
+            case 'error':
+                maxLines = this.config.filtering.maxErrorLines;
+                break;
+            default: {
+                // For tool results, check token count estimate
+                const estimatedTokens = Math.ceil(content.length / 4);
+                if (estimatedTokens <= this.config.filtering.maxToolResultTokens) {
+                    return { content, filtered: false, originalLength };
+                }
+                // Truncate to roughly maxToolResultTokens
+                const maxChars = this.config.filtering.maxToolResultTokens * 4;
+                const truncated = content.slice(0, maxChars);
+                return {
+                    content: truncated + '\n\n[Content truncated - see file for full output]',
+                    filtered: true,
+                    originalLength,
+                };
+            }
+        }
+        if (lines.length <= maxLines) {
+            return { content, filtered: false, originalLength };
+        }
+        // For files and errors, show first half and last half
+        const halfLines = Math.floor(maxLines / 2);
+        const firstPart = lines.slice(0, halfLines);
+        const lastPart = lines.slice(-halfLines);
+        const omitted = lines.length - maxLines;
+        const filteredContent = [
+            ...firstPart,
+            '',
+            `[... ${String(omitted)} lines omitted ...]`,
+            '',
+            ...lastPart,
+        ].join('\n');
+        return {
+            content: filteredContent,
+            filtered: true,
+            originalLength,
+        };
+    }
+    /**
+     * Compact old messages by replacing large content with file references
+     *
+     * This is a placeholder - actual implementation requires file system access
+     * which will be provided by the Agent or CLI layer.
+     */
+    async compact(messages, saveToFile) {
+        const tokensBefore = await this.countTokens(messages);
+        const messagesBefore = messages.length;
+        const filesCreated = [];
+        // Preserve recent messages
+        const preserveCount = this.config.compaction.preserveRecentTurns * 2; // 2 messages per turn
+        const oldMessages = messages.slice(0, -preserveCount);
+        const recentMessages = messages.slice(-preserveCount);
+        const compactedOld = [];
+        let compactedIndex = 0;
+        for (const msg of oldMessages) {
+            if (typeof msg.content === 'string') {
+                // Check if string content is large enough to compact
+                const tokens = Math.ceil(msg.content.length / 4);
+                if (tokens >= this.config.compaction.minTokensToCompact) {
+                    const filePath = await saveToFile(msg.content, compactedIndex++);
+                    filesCreated.push(filePath);
+                    compactedOld.push({
+                        ...msg,
+                        content: `[Content saved to ${filePath}]`,
+                    });
+                }
+                else {
+                    compactedOld.push(msg);
+                }
+            }
+            else {
+                // Check content blocks for large tool results
+                const compactedBlocks = [];
+                for (const block of msg.content) {
+                    if (block.type === 'tool_result') {
+                        const tokens = Math.ceil(block.content.length / 4);
+                        if (tokens >= this.config.compaction.minTokensToCompact) {
+                            const filePath = await saveToFile(block.content, compactedIndex++);
+                            filesCreated.push(filePath);
+                            compactedBlocks.push({
+                                ...block,
+                                content: `[Content saved to ${filePath}]`,
+                            });
+                        }
+                        else {
+                            compactedBlocks.push(block);
+                        }
+                    }
+                    else {
+                        compactedBlocks.push(block);
+                    }
+                }
+                compactedOld.push({ ...msg, content: compactedBlocks });
+            }
+        }
+        const compactedMessages = [...compactedOld, ...recentMessages];
+        const tokensAfter = await this.countTokens(compactedMessages);
+        this.compactionCount++;
+        this.lastCompactionTurn = this.turnCount;
+        this.cachedTokenCount = tokensAfter;
+        const result = {
+            messagesBefore,
+            messagesAfter: compactedMessages.length,
+            tokensBefore,
+            tokensAfter,
+            filesCreated,
+        };
+        this.emit({ type: 'context_compacted', result });
+        return { messages: compactedMessages, result };
+    }
+    /**
+     * Summarize conversation history
+     *
+     * This is a placeholder - actual implementation requires LLM call
+     * which will be orchestrated by the Agent layer.
+     */
+    async summarize(messages, generateSummary) {
+        const originalTokens = await this.countTokens(messages);
+        // Find system message (preserve it)
+        const systemMessage = messages.find((m) => m.role === 'system');
+        // Preserve recent messages
+        const preserveCount = this.config.summarization.preserveRecentMessages;
+        const toSummarize = messages.filter((m) => m.role !== 'system').slice(0, -preserveCount);
+        const recentMessages = messages.filter((m) => m.role !== 'system').slice(-preserveCount);
+        // Generate summary
+        const summary = await generateSummary(toSummarize);
+        // Build new message list
+        const summarizedMessages = [];
+        if (systemMessage) {
+            summarizedMessages.push(systemMessage);
+        }
+        // Add summary as a user message
+        summarizedMessages.push({
+            role: 'user',
+            content: `[Previous conversation summary]\n\n${summary}\n\n[End of summary - conversation continues below]`,
+        });
+        // Add assistant acknowledgment
+        summarizedMessages.push({
+            role: 'assistant',
+            content: 'I understand. I have the context from our previous conversation. How can I continue helping you?',
+        });
+        // Add recent messages
+        summarizedMessages.push(...recentMessages);
+        const summaryTokens = await this.countTokens(summarizedMessages);
+        this.summarizationCount++;
+        this.cachedTokenCount = summaryTokens;
+        const result = {
+            originalTokens,
+            summaryTokens,
+            messagesPreserved: preserveCount,
+            summary,
+            rounds: 1,
+            emergency: false,
+        };
+        this.emit({ type: 'context_summarized', result });
+        return { messages: summarizedMessages, result };
+    }
+    /**
+     * Summarize with support for multiple rounds and emergency mode
+     *
+     * Will perform multiple summarization rounds if needed to reach target utilization.
+     * Throws ContextOverflowError if unable to reduce context sufficiently.
+     */
+    async summarizeWithRetry(messages, generateSummary, options) {
+        const emergency = options?.emergency ?? this.needsEmergencySummarization();
+        const maxRounds = options?.maxRounds ?? this.config.summarization.maxRounds;
+        const targetUtilization = options?.targetUtilization ?? this.config.summarization.targetUtilization;
+        let currentMessages = messages;
+        let rounds = 0;
+        let lastResult;
+        while (rounds < maxRounds) {
+            rounds++;
+            // Determine preserve count based on emergency mode and round
+            let preserveCount;
+            if (emergency || rounds > 1) {
+                // More aggressive: fewer preserved messages each round
+                preserveCount = Math.max(2, this.config.summarization.emergencyPreserveMessages - (rounds - 1) * 2);
+            }
+            else {
+                preserveCount = this.config.summarization.preserveRecentMessages;
+            }
+            // Find system message
+            const systemMessage = currentMessages.find((m) => m.role === 'system');
+            // Separate messages
+            const nonSystemMessages = currentMessages.filter((m) => m.role !== 'system');
+            const toSummarize = nonSystemMessages.slice(0, -preserveCount);
+            const recentMessages = nonSystemMessages.slice(-preserveCount);
+            // Generate summary
+            const summary = await generateSummary(toSummarize);
+            // Build new message list
+            const summarizedMessages = [];
+            if (systemMessage) {
+                summarizedMessages.push(systemMessage);
+            }
+            summarizedMessages.push({
+                role: 'user',
+                content: `[Previous conversation summary${rounds > 1 ? ` (round ${String(rounds)})` : ''}]\n\n${summary}\n\n[End of summary]`,
+            });
+            summarizedMessages.push({
+                role: 'assistant',
+                content: 'I understand. I have the context from our previous conversation.',
+            });
+            summarizedMessages.push(...recentMessages);
+            const summaryTokens = await this.countTokens(summarizedMessages);
+            this.cachedTokenCount = summaryTokens;
+            lastResult = {
+                originalTokens: await this.countTokens(messages),
+                summaryTokens,
+                messagesPreserved: preserveCount,
+                summary,
+                rounds,
+                emergency,
+            };
+            currentMessages = summarizedMessages;
+            // Check if we've reached target
+            if (this.getUtilization() <= targetUtilization) {
+                break;
+            }
+        }
+        // Ensure we have a result (should always be true if maxRounds > 0)
+        if (!lastResult) {
+            // This shouldn't happen, but handle gracefully
+            lastResult = {
+                originalTokens: await this.countTokens(messages),
+                summaryTokens: this.cachedTokenCount,
+                messagesPreserved: 0,
+                summary: '',
+                rounds: 0,
+                emergency,
+            };
+        }
+        this.summarizationCount++;
+        this.emit({ type: 'context_summarized', result: lastResult });
+        return { messages: currentMessages, result: lastResult };
+    }
+    /**
+     * Check context and emit warning if needed
+     */
+    checkAndWarn() {
+        const utilization = this.getUtilization();
+        if (utilization >= this.config.summarization.triggerThreshold) {
+            this.emit({
+                type: 'context_warning',
+                utilization,
+                threshold: this.config.summarization.triggerThreshold,
+            });
+        }
+        else if (utilization >= this.config.compaction.triggerThreshold) {
+            this.emit({
+                type: 'context_warning',
+                utilization,
+                threshold: this.config.compaction.triggerThreshold,
+            });
+        }
+    }
+    /**
+     * Reset context manager state (for new conversations)
+     */
+    reset() {
+        this.cachedTokenCount = 0;
+        this.turnCount = 0;
+        this.compactionCount = 0;
+        this.summarizationCount = 0;
+        this.lastCompactionTurn = 0;
+        // Reset category usage
+        this.categoryUsage = {
+            system: 0,
+            recentMessages: 0,
+            toolResults: 0,
+            history: 0,
+        };
+    }
+}