@phuetz/code-buddy 0.4.0 → 1.0.0

package/dist/context/context-manager-v2.js

@@ -14,7 +14,11 @@
  */
 import { createTokenCounter } from './token-counter.js';
 import { logger } from '../utils/logger.js';
+import { getModelToolConfig } from '../config/model-tools.js';
+import { RunStore } from '../observability/run-store.js';
 import { EnhancedContextCompressor, } from './enhanced-compression.js';
+import { ImportanceScorer } from './importance-scorer.js';
+import { computeAutoCompactThreshold } from './auto-compact-threshold.js';
 // Lazy import memory monitor to avoid circular dependencies
 let memoryMonitorModule = null;
 async function getMemoryMonitorModule() {
@@ -41,6 +45,10 @@ export class ContextManagerV2 {
     lastEnhancedResult = null;
     /** Session ID for archiving */
     sessionId;
+    /** Lazy-loaded importance scorer for sliding window decisions */
+    _importanceScorer = null;
+    /** Pluggable context engine (Native Engine v2026.3.7 alignment) */
+    contextEngine = null;
     // Memory metrics for monitoring
     /** Maximum number of summaries to keep (prevents unbounded growth) */
     static MAX_SUMMARIES = 50;
@@ -50,6 +58,20 @@ export class ContextManagerV2 {
     compressionCount = 0;
     /** Total tokens saved by compression */
     totalTokensSaved = 0;
+    /** Cached token count for getStats() */
+    _cachedStatsTokenCount = 0;
+    /**
+     * Content-aware cache key for getStats().
+     *
+     * Previously this was `messages.length` alone, which produced stale hits
+     * when messages were mutated in place (common: tool results populated,
+     * assistant content sanitized, tool_calls appended). Now we compute a
+     * cheap O(N) fingerprint over the array: length + sum of content char
+     * counts + total tool_calls count. Any mutation of content or tool_calls
+     * invalidates the cache. The scan is microseconds vs ~20–50 ms for a
+     * full tiktoken recount.
+     */
+    _cachedStatsFingerprint = '';
     /** Last compression timestamp */
     lastCompressionTime = null;
     // Default configuration based on research recommendations
@@ -74,6 +96,56 @@ export class ContextManagerV2 {
             this.enhancedCompressor = new EnhancedContextCompressor(this.tokenCounter, this.config.enhancedCompressionConfig);
         }
     }
+    /**
+     * Register a pluggable context engine (Native Engine v2026.3.7 alignment).
+     * When set, prepareMessages() delegates to engine.assemble().
+     */
+    setContextEngine(engine) {
+        this.contextEngine = engine;
+        logger.info(`Context engine registered: ${engine.id}`);
+    }
+    /**
+     * Get the active context engine (or null for default behavior)
+     */
+    getContextEngine() {
+        return this.contextEngine;
+    }
+    /**
+     * Raw message preparation — used by DefaultContextEngine to delegate
+     * back to the built-in compression pipeline without infinite recursion.
+     */
+    prepareMessagesRaw(messages) {
+        const stats = this.getStats(messages);
+        const shouldSoftCompact = this.config.enableSummarization &&
+            this.effectiveLimit <= 1000 &&
+            messages.length > this.config.recentMessagesCount * 2;
+        const shouldCompact = this.shouldAutoCompact(messages) || stats.isNearLimit || shouldSoftCompact;
+        if (!shouldCompact) {
+            this.lastTokenCount = stats.totalTokens;
+            return messages;
+        }
+        let compacted;
+        if (this.config.enableEnhancedCompression && this.enhancedCompressor) {
+            compacted = this.prepareMessagesEnhanced(messages, stats);
+        }
+        else {
+            compacted = this.prepareMessagesLegacy(messages, stats);
+        }
+        const newStats = this.getStats(compacted);
+        if (newStats.totalTokens < stats.totalTokens) {
+            try {
+                const runStore = RunStore.getInstance();
+                const activeRunId = runStore.getCurrentRunId();
+                if (activeRunId) {
+                    runStore.forkRun(activeRunId, 'compaction');
+                }
+            }
+            catch (err) {
+                logger.warn('Failed to fork run on compaction:', { error: String(err) });
+            }
+        }
+        return compacted;
+    }
     /**
      * Get the effective token limit (accounting for response reserve + estimation safety margin)
      * The 5% safety margin compensates for token counting estimation drift.
@@ -97,11 +169,41 @@ export class ContextManagerV2 {
         }));
         return this.tokenCounter.countMessageTokens(tokenMessages);
     }
+    /**
+     * Compute a cheap fingerprint of the messages array for cache invalidation.
+     * Covers additions, in-place content mutation, and tool_call changes.
+     */
+    computeStatsFingerprint(messages) {
+        let contentLen = 0;
+        let toolCallsCount = 0;
+        for (const msg of messages) {
+            if (typeof msg.content === 'string') {
+                contentLen += msg.content.length;
+            }
+            else if (Array.isArray(msg.content)) {
+                // Multimodal content: count JSON length as a rough signal
+                contentLen += JSON.stringify(msg.content).length;
+            }
+            if ('tool_calls' in msg && Array.isArray(msg.tool_calls)) {
+                toolCallsCount += msg.tool_calls.length;
+            }
+        }
+        return `${messages.length}:${contentLen}:${toolCallsCount}`;
+    }
     /**
      * Get context statistics
      */
     getStats(messages) {
-        const totalTokens = this.countTokens(messages);
+        let totalTokens;
+        const fingerprint = this.computeStatsFingerprint(messages);
+        if (fingerprint === this._cachedStatsFingerprint) {
+            totalTokens = this._cachedStatsTokenCount;
+        }
+        else {
+            totalTokens = this.countTokens(messages);
+            this._cachedStatsTokenCount = totalTokens;
+            this._cachedStatsFingerprint = fingerprint;
+        }
         const maxTokens = this.effectiveLimit;
         const usagePercent = (totalTokens / maxTokens) * 100;
         // Track peak message count for memory metrics
@@ -118,6 +220,62 @@ export class ContextManagerV2 {
             isCritical: usagePercent > 90,
         };
     }
+    /**
+     * Get a breakdown of context budget usage per layer.
+     * Useful for diagnosing which layer consumes the most context.
+     */
+    getContextBudgetBreakdown(messages) {
+        const layers = {
+            system: 0,
+            lessons: 0,
+            decisions: 0,
+            code_graph: 0,
+            tool_results: 0,
+            user_messages: 0,
+            assistant_messages: 0,
+            other: 0,
+        };
+        for (const msg of messages) {
+            const content = typeof msg.content === 'string' ? msg.content : '';
+            const chars = content.length;
+            if (msg.role === 'system') {
+                if (content.includes('<lessons_context>'))
+                    layers.lessons = (layers.lessons ?? 0) + chars;
+                else if (content.includes('<decisions_context>'))
+                    layers.decisions = (layers.decisions ?? 0) + chars;
+                else if (content.includes('code_graph'))
+                    layers.code_graph = (layers.code_graph ?? 0) + chars;
+                else
+                    layers.system = (layers.system ?? 0) + chars;
+            }
+            else if (msg.role === 'tool') {
+                layers.tool_results = (layers.tool_results ?? 0) + chars;
+            }
+            else if (msg.role === 'user') {
+                layers.user_messages = (layers.user_messages ?? 0) + chars;
+            }
+            else if (msg.role === 'assistant') {
+                layers.assistant_messages = (layers.assistant_messages ?? 0) + chars;
+            }
+            else {
+                layers.other = (layers.other ?? 0) + chars;
+            }
+        }
+        const totalChars = Object.values(layers).reduce((a, b) => a + b, 0);
+        const totalTokens = this.countTokens(messages);
+        const result = {};
+        for (const [layer, chars] of Object.entries(layers)) {
+            if (chars === 0)
+                continue;
+            const proportion = totalChars > 0 ? chars / totalChars : 0;
+            result[layer] = {
+                chars,
+                tokens: Math.round(totalTokens * proportion),
+                percent: Math.round(proportion * 100),
+            };
+        }
+        return result;
+    }
     /**
      * Prepare messages for API call, managing context as needed
      * Returns optimized message array that fits within token limits
@@ -126,6 +284,28 @@ export class ContextManagerV2 {
      * Now supports enhanced compression with key info preservation
      */
     prepareMessages(messages) {
+        // Delegate to pluggable context engine if registered (Native Engine v2026.3.7)
+        if (this.contextEngine) {
+            // ownsCompaction: engine controls compaction — skip built-in auto-compact,
+            // delegate directly to engine.assemble() (Native Engine v2026.3.13-1)
+            if (this.contextEngine.ownsCompaction) {
+                const result = this.contextEngine.assemble(messages, this.effectiveLimit);
+                this.lastTokenCount = result.tokenCount;
+                return result.messages;
+            }
+            // Non-owning engine: run built-in compaction first, then assemble
+            const compacted = this.prepareMessagesRaw(messages);
+            const result = this.contextEngine.assemble(compacted, this.effectiveLimit);
+            this.lastTokenCount = result.tokenCount;
+            return result.messages;
+        }
+        // Default pipeline (no engine registered)
+        return this.prepareMessagesRaw(messages);
+    }
+    /**
+     * @deprecated Use prepareMessages() — this is kept for backwards compatibility
+     */
+    _prepareMessagesInternal(messages) {
         const stats = this.getStats(messages);
         const shouldSoftCompact = this.config.enableSummarization &&
             this.effectiveLimit <= 1000 &&
@@ -253,23 +433,48 @@ export class ContextManagerV2 {
         }
         return result;
     }
+    /**
+     * Get or create the importance scorer (lazy-loaded).
+     */
+    get importanceScorer() {
+        if (!this._importanceScorer) {
+            this._importanceScorer = new ImportanceScorer();
+        }
+        return this._importanceScorer;
+    }
     /**
      * Strategy 1: Sliding Window - Keep N most recent messages
+     * Uses ImportanceScorer to preserve high-importance messages outside the window.
      */
     applySlidingWindow(messages) {
         const keepCount = this.config.recentMessagesCount;
         if (messages.length <= keepCount) {
             return messages;
         }
-        // Keep the most recent messages
+        // Score all messages using the importance scorer
+        const scores = this.importanceScorer.scoreMessages(messages);
+        // Always keep the most recent messages
         const recentMessages = messages.slice(-keepCount);
+        // For messages outside the window, keep any with score > 0.8 (high importance)
+        const oldMessages = messages.slice(0, -keepCount);
+        const importantOldMessages = [];
+        for (let i = 0; i < oldMessages.length; i++) {
+            const score = scores[i];
+            const oldMessage = oldMessages[i];
+            if (oldMessage !== undefined && (score?.score ?? 0) > 0.8) {
+                importantOldMessages.push(oldMessage);
+            }
+        }
         // Create a summary marker for removed messages
-        const removedCount = messages.length - keepCount;
-        const summaryMarker = {
-            role: 'system',
-            content: `[Previous ${removedCount} messages summarized due to context limits]`,
-        };
-        return [summaryMarker, ...recentMessages];
+        const removedCount = messages.length - keepCount - importantOldMessages.length;
+        const parts = [];
+        if (removedCount > 0) {
+            parts.push({
+                role: 'system',
+                content: `[Previous ${removedCount} messages summarized due to context limits]`,
+            });
+        }
+        return [...parts, ...importantOldMessages, ...recentMessages];
     }
     /**
      * Strategy 2: Truncate verbose tool results
@@ -353,10 +558,31 @@ export class ContextManagerV2 {
     hardTruncate(messages) {
         let result = [...messages];
         let currentTokens = this.countTokens(result);
-        // Remove oldest messages one by one until within limits
+        // Remove oldest messages, preserving tool-call/tool-result pairs
         while (currentTokens > this.effectiveLimit && result.length > 2) {
-            // Keep at least 2 messages (1 user + 1 assistant minimum)
-            result = result.slice(1);
+            const first = result[0];
+            // result.length > 2 (loop guard above) guarantees result[0] exists; guard for type-safety
+            if (first === undefined)
+                break;
+            // If removing an assistant message with tool_calls, also remove its paired tool results
+            if (first.role === 'assistant' && 'tool_calls' in first && Array.isArray(first.tool_calls)) {
+                const toolCallIds = new Set((first.tool_calls).map(tc => tc.id));
+                // Remove the assistant message + all paired tool results
+                result = result.filter((msg, idx) => {
+                    if (idx === 0)
+                        return false; // remove the assistant message
+                    if (msg.role === 'tool' && toolCallIds.has(msg.tool_call_id ?? ''))
+                        return false;
+                    return true;
+                });
+            }
+            else if (first.role === 'tool') {
+                // Orphaned tool result (its assistant was already removed) — safe to drop
+                result = result.slice(1);
+            }
+            else {
+                result = result.slice(1);
+            }
             currentTokens = this.countTokens(result);
         }
         // If still over limit, truncate message content
@@ -414,11 +640,31 @@ export class ContextManagerV2 {
         return { warn: false, message: '' };
     }
     /**
-     * Check if auto-compact should be triggered
-     * Returns true if token count exceeds autoCompactThreshold
+     * Check if auto-compact should be triggered.
+     *
+     * CC17: Supports percentage-based threshold via autoCompactPercent config
+     * or CODEBUDDY_AUTOCOMPACT_PCT env var. Falls back to absolute token threshold.
      */
     shouldAutoCompact(messages) {
         const stats = this.getStats(messages);
+        // Phase post-audit V1.3: opt-in adaptive buffer (per-model lookup)
+        // Subtracts a model-specific buffer from maxContextTokens before
+        // applying optional percent. Default off — backward compat with
+        // the existing percent/threshold path below.
+        if (this.config.useAdaptiveBuffer) {
+            const envPctAdaptive = process.env.CODEBUDDY_AUTOCOMPACT_PCT;
+            const pctAdaptive = this.config.autoCompactPercent ?? (envPctAdaptive ? parseFloat(envPctAdaptive) : undefined);
+            const threshold = computeAutoCompactThreshold(this.config.maxContextTokens, this.config.model, pctAdaptive !== undefined && !isNaN(pctAdaptive) ? { percent: pctAdaptive } : undefined);
+            return stats.totalTokens >= threshold;
+        }
+        // CC17: Check percentage-based threshold first
+        const envPct = process.env.CODEBUDDY_AUTOCOMPACT_PCT;
+        const pct = this.config.autoCompactPercent ?? (envPct ? parseFloat(envPct) : undefined);
+        if (pct !== undefined && !isNaN(pct) && pct > 0 && pct <= 100) {
+            const threshold = Math.floor(this.config.maxContextTokens * (pct / 100));
+            return stats.totalTokens >= threshold;
+        }
+        // Fallback: absolute token threshold
         return stats.totalTokens >= this.config.autoCompactThreshold;
     }
     /**
@@ -680,20 +926,9 @@ export class ContextManagerV2 {
  * Create a context manager with auto-detection of model limits
  */
 export function createContextManager(model, maxTokens) {
-    // Default context limits for common models
-    const MODEL_LIMITS = {
-        'gpt-4': 8192,
-        'gpt-4-turbo': 128000,
-        'gpt-3.5-turbo': 4096,
-        'claude-3': 200000,
-        'llama3.2': 131072,
-        'llama3.1': 131072,
-        'mistral': 32768,
-        'qwen2.5': 32768,
-        // Local models often have lower limits
-        'default': 4096,
-    };
-    const detectedLimit = maxTokens || MODEL_LIMITS[model] || MODEL_LIMITS['default'];
+    // Use getModelToolConfig for glob-pattern matching (covers grok-3*, grok-4*, claude-*, etc.)
+    const toolConfig = getModelToolConfig(model);
+    const detectedLimit = maxTokens || toolConfig.contextWindow || 8192;
     return new ContextManagerV2({
         model,
         maxContextTokens: detectedLimit,

package/dist/context/cross-encoder-reranker.js

@@ -147,7 +147,10 @@ class CrossEncoderScorer {
         for (const pattern of functionPatterns) {
             let match;
             while ((match = pattern.exec(query)) !== null) {
-                queryIdentifiers.add(match[1].toLowerCase());
+                const captured = match[1];
+                if (captured !== undefined) {
+                    queryIdentifiers.add(captured.toLowerCase());
+                }
             }
         }
         // Also add plain words that look like identifiers
@@ -367,13 +370,20 @@ export class CrossEncoderReranker extends EventEmitter {
             return { results: initialResults, stats };
         }
         // Apply MMR
-        const selected = [initialResults[0]];
-        const remaining = initialResults.slice(1);
+        const [first, ...remaining] = initialResults;
+        // length > 1 guaranteed above, so first is defined; guard to satisfy the type system
+        if (first === undefined) {
+            return { results: initialResults, stats };
+        }
+        const selected = [first];
         while (selected.length < this.config.topK && remaining.length > 0) {
             let bestIndex = -1;
             let bestMMRScore = -Infinity;
             for (let i = 0; i < remaining.length; i++) {
                 const candidate = remaining[i];
+                if (candidate === undefined) {
+                    continue;
+                }
                 // Calculate max similarity to already selected
                 let maxSimilarity = 0;
                 for (const sel of selected) {
@@ -388,7 +398,11 @@ export class CrossEncoderReranker extends EventEmitter {
                 }
             }
             if (bestIndex >= 0) {
-                selected.push(remaining[bestIndex]);
+                const best = remaining[bestIndex];
+                if (best === undefined) {
+                    break;
+                }
+                selected.push(best);
                 remaining.splice(bestIndex, 1);
             }
             else {

package/dist/context/default-context-engine.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DefaultContextEngine — Extracts existing ContextManagerV2 logic into the ContextEngine interface
+ *
+ * This is the built-in engine that delegates to ContextManagerV2's compression strategies.
+ * When no plugin registers a custom engine, this is used as the fallback.
+ */
+import type { CodeBuddyMessage } from '../codebuddy/client.js';
+import type { ContextEngine, ContextMeta, AssembleResult } from './context-engine.js';
+import type { ContextManagerV2 } from './context-manager-v2.js';
+/**
+ * Default context engine that wraps ContextManagerV2's existing pipeline
+ */
+export declare class DefaultContextEngine implements ContextEngine {
+    readonly id = "default";
+    readonly ownsCompaction = false;
+    private manager;
+    /**
+     * Bind the context manager instance (called during registration)
+     */
+    setManager(manager: ContextManagerV2): void;
+    bootstrap(_config: Record<string, unknown>): Promise<void>;
+    ingest(messages: CodeBuddyMessage[], _meta: ContextMeta): CodeBuddyMessage[];
+    assemble(messages: CodeBuddyMessage[], budget: number): AssembleResult;
+    compact(messages: CodeBuddyMessage[], _targetTokens: number): CodeBuddyMessage[];
+    afterTurn(_messages: CodeBuddyMessage[], _response: CodeBuddyMessage): void;
+    prepareSubagentSpawn(messages: CodeBuddyMessage[], role: string): CodeBuddyMessage[];
+    onSubagentEnded(_agentId: string, _messages: CodeBuddyMessage[], _result?: string): void;
+}

package/dist/context/default-context-engine.js

@@ -0,0 +1,60 @@
+/**
+ * DefaultContextEngine — Extracts existing ContextManagerV2 logic into the ContextEngine interface
+ *
+ * This is the built-in engine that delegates to ContextManagerV2's compression strategies.
+ * When no plugin registers a custom engine, this is used as the fallback.
+ */
+import { logger } from '../utils/logger.js';
+/**
+ * Default context engine that wraps ContextManagerV2's existing pipeline
+ */
+export class DefaultContextEngine {
+    id = 'default';
+    ownsCompaction = false;
+    manager = null;
+    /**
+     * Bind the context manager instance (called during registration)
+     */
+    setManager(manager) {
+        this.manager = manager;
+    }
+    async bootstrap(_config) {
+        logger.debug('DefaultContextEngine bootstrapped');
+    }
+    ingest(messages, _meta) {
+        // Default: pass through unchanged — ContextManagerV2 handles ingestion internally
+        return messages;
+    }
+    assemble(messages, budget) {
+        if (!this.manager) {
+            return { messages, tokenCount: 0 };
+        }
+        // Delegate to the existing prepareMessages pipeline
+        const prepared = this.manager.prepareMessagesRaw(messages);
+        const tokenCount = this.manager.countTokens(prepared);
+        return { messages: prepared, tokenCount };
+    }
+    compact(messages, _targetTokens) {
+        if (!this.manager) {
+            return messages;
+        }
+        // Force compression via prepareMessages (which triggers compact when needed)
+        return this.manager.prepareMessagesRaw(messages);
+    }
+    afterTurn(_messages, _response) {
+        // Default: no-op — agent-executor handles post-turn logic (ICM storage, etc.)
+    }
+    prepareSubagentSpawn(messages, role) {
+        // Default: provide recent context subset based on role
+        const systemMsgs = messages.filter(m => m.role === 'system');
+        const conversationMsgs = messages.filter(m => m.role !== 'system');
+        // Explorer gets less context, worker gets more
+        const contextSize = role === 'explorer' ? 10 : 20;
+        const recentMsgs = conversationMsgs.slice(-contextSize);
+        return [...systemMsgs, ...recentMsgs];
+    }
+    onSubagentEnded(_agentId, _messages, _result) {
+        // Default: no-op — host agent handles sub-agent result merging
+    }
+}
+//# sourceMappingURL=default-context-engine.js.map

package/dist/context/enhanced-compression.d.ts

@@ -11,7 +11,7 @@
  */
 import { CodeBuddyMessage } from '../codebuddy/client.js';
 import { TokenCounter } from './token-counter.js';
-import { EnhancedCompressionResult, SlidingWindowConfig, SummarizationConfig } from './types.js';
+import { ClassifiedMessage, EnhancedCompressionResult, SlidingWindowConfig, SummarizationConfig } from './types.js';
 /**
  * Configuration for the enhanced compression engine.
  */
@@ -79,7 +79,7 @@ export declare class EnhancedContextCompressor {
     /**
      * Classify all messages by content type and importance.
      */
-    private classifyMessages;
+    classifyMessages(messages: CodeBuddyMessage[]): Map<number, ClassifiedMessage>;
     /**
      * Detect the content type of a message.
      */

package/dist/context/enhanced-compression.js

@@ -175,9 +175,10 @@ export class EnhancedContextCompressor {
         const importantOldMessages = [];
         const oldMessageCount = messages.length - windowSize;
         for (let i = 0; i < oldMessageCount; i++) {
+            const msg = messages[i];
             const classInfo = classified.get(i);
-            if (classInfo && classInfo.preserve) {
-                importantOldMessages.push(messages[i]);
+            if (msg && classInfo && classInfo.preserve) {
+                importantOldMessages.push(msg);
             }
         }
         // Get overlap messages (transition zone)
@@ -341,9 +342,12 @@ export class EnhancedContextCompressor {
         let currentTokens = 0;
         // Process from most recent backwards
         for (let i = messages.length - 1; i >= 0; i--) {
-            const msgTokens = this.countTokens([messages[i]]);
+            const msg = messages[i];
+            if (!msg)
+                continue;
+            const msgTokens = this.countTokens([msg]);
             if (currentTokens + msgTokens <= tokenLimit) {
-                result.unshift(messages[i]);
+                result.unshift(msg);
                 currentTokens += msgTokens;
             }
             else {
@@ -359,6 +363,8 @@ export class EnhancedContextCompressor {
         const result = new Map();
         for (let i = 0; i < messages.length; i++) {
             const msg = messages[i];
+            if (!msg)
+                continue;
             const contentType = this.detectContentType(msg);
             const importance = this.calculateImportance(msg, i, messages.length, contentType);
             const preserve = importance >= this.config.preservationThreshold ||
@@ -449,12 +455,16 @@ export class EnhancedContextCompressor {
         };
         for (let index = 0; index < messages.length; index++) {
             const msg = messages[index];
+            if (!msg)
+                continue;
             const content = typeof msg.content === 'string' ? msg.content : '';
             const now = new Date();
             // Extract file operations
             const fileOpMatches = Array.from(content.matchAll(KEY_INFO_PATTERNS.fileOperation));
             for (const match of fileOpMatches) {
                 const path = match[2];
+                if (path === undefined)
+                    continue;
                 const opText = match[0].toLowerCase();
                 let operation = 'edit';
                 if (opText.includes('creat') || opText.includes('writ'))
@@ -466,8 +476,11 @@ export class EnhancedContextCompressor {
             // Extract errors
             const errorMatches = Array.from(content.matchAll(KEY_INFO_PATTERNS.errorMessage));
             for (const match of errorMatches) {
+                const errorText = match[1];
+                if (errorText === undefined)
+                    continue;
                 keyInfo.errors.push({
-                    message: match[1].trim(),
+                    message: errorText.trim(),
                     timestamp: now,
                     index,
                 });
@@ -475,8 +488,11 @@ export class EnhancedContextCompressor {
             // Extract decisions
             const decisionMatches = Array.from(content.matchAll(KEY_INFO_PATTERNS.decision));
             for (const match of decisionMatches) {
+                const decisionText = match[1];
+                if (decisionText === undefined)
+                    continue;
                 keyInfo.decisions.push({
-                    message: match[1].trim(),
+                    message: decisionText.trim(),
                     timestamp: now,
                     index,
                 });
@@ -497,8 +513,11 @@ export class EnhancedContextCompressor {
             const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
             const codeMatches = Array.from(content.matchAll(codeBlockRegex));
             for (const match of codeMatches) {
+                const snippet = match[2];
+                if (snippet === undefined)
+                    continue;
                 keyInfo.codeSnippets.push({
-                    content: match[2].slice(0, 500), // Limit size
+                    content: snippet.slice(0, 500), // Limit size
                     language: match[1] || undefined,
                     index,
                 });
@@ -515,7 +534,7 @@ export class EnhancedContextCompressor {
         for (const msg of messages) {
             if (msg.role === 'user' && typeof msg.content === 'string') {
                 // Extract first line as topic indicator
-                const firstLine = msg.content.split('\n')[0].slice(0, 100);
+                const firstLine = (msg.content.split('\n')[0] ?? '').slice(0, 100);
                 if (firstLine !== currentTopic) {
                     currentTopic = firstLine;
                     flows.push(`- User asked: ${firstLine}${msg.content.length > 100 ? '...' : ''}`);
@@ -547,7 +566,7 @@ export class EnhancedContextCompressor {
         const topics = new Set();
         for (const msg of messages) {
             if (msg.role === 'user' && typeof msg.content === 'string') {
-                const topic = msg.content.split('\n')[0].slice(0, 50);
+                const topic = (msg.content.split('\n')[0] ?? '').slice(0, 50);
                 if (topic.length > 10)
                     topics.add(topic);
             }