@phuetz/code-buddy 1.6.1 → 2.1.0

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

@@ -12,16 +12,23 @@
  * - Content-type-aware Compression
  * - Key Information Preservation
  */
+import { truncateOutput } from '../utils/bounded-output.js';
+import { createHash } from 'node:crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 import { redactSecrets } from '../fleet/privacy-lint.js';
-import { createTokenCounter } from './token-counter.js';
+import { createTokenCounter, estimateImageUrlTokens } 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 { repairToolCallPairs } from './transcript-repair.js';
+import { writeJsonAtomicSync } from '../utils/atomic-write.js';
+import { EnhancedContextCompressor, isFailedToolResultContent, } from './enhanced-compression.js';
 import { ImportanceScorer } from './importance-scorer.js';
 import { computeAutoCompactThreshold } from './auto-compact-threshold.js';
+import { isContextZoomEnabled, SegmentArchive } from './segment-archive.js';
+import { getGlobalEventBus } from '../events/event-bus.js';
+import { getUserHooksManager } from '../hooks/user-hooks.js';
 // Lazy import memory monitor to avoid circular dependencies
 let memoryMonitorModule = null;
 async function getMemoryMonitorModule() {
@@ -30,6 +37,54 @@ async function getMemoryMonitorModule() {
     }
     return memoryMonitorModule;
 }
+/**
+ * Typed compaction failure. `ok: false` tells the caller the provider call
+ * must not proceed with a silently truncated or over-budget transcript.
+ */
+export class ContextCompactionError extends Error {
+    ok = false;
+    code;
+    tokens;
+    limit;
+    constructor(code, tokens, limit, message) {
+        super(message ?? ContextCompactionError.defaultMessage(code, tokens, limit));
+        this.name = 'ContextCompactionError';
+        this.code = code;
+        this.tokens = tokens;
+        this.limit = limit;
+    }
+    static defaultMessage(code, tokens, limit) {
+        if (code === 'CURRENT_REQUEST_EXCEEDS_BUDGET') {
+            return (`Current user request exceeds the context budget ` +
+                `(${tokens} tokens > ${limit} token limit). ` +
+                `The request was not sent to the model because it cannot fit even alone.`);
+        }
+        if (code === 'CURRENT_REQUEST_DROPPED') {
+            return (`Current user request was dropped during context compaction. ` +
+                `The request was not sent to the model.`);
+        }
+        return (`Context compaction could not fit the conversation under the token limit ` +
+            `(${tokens} tokens > ${limit} token limit). The request was not sent to the model.`);
+    }
+}
+export function findLastUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message?.role === 'user')
+            return message;
+    }
+    return undefined;
+}
+export function isIntactUserMessage(candidate, original) {
+    if (candidate === original)
+        return true;
+    if (candidate.role !== 'user' || original.role !== 'user')
+        return false;
+    return JSON.stringify(candidate.content) === JSON.stringify(original.content);
+}
+function preparedContainsLastUser(prepared, lastUser) {
+    return prepared.some(message => isIntactUserMessage(message, lastUser));
+}
 /**
  * Advanced Context Manager with multiple compression strategies
  */
@@ -52,6 +107,10 @@ export class ContextManagerV2 {
     _importanceScorer = null;
     /** Pluggable context engine (Native Engine v2026.3.7 alignment) */
     contextEngine = null;
+    /** A slash `/compact` request is consumed by the next real compaction. */
+    manualCompactionRequested = false;
+    /** Durable recovery store for opt-in hierarchical context summaries. */
+    segmentArchive;
     // Memory metrics for monitoring
     /** Maximum number of summaries to keep (prevents unbounded growth) */
     static MAX_SUMMARIES = 50;
@@ -70,7 +129,7 @@ export class ContextManagerV2 {
      * 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
+     * counts + serialized tool-call size. Any mutation of content or tool_calls
      * invalidates the cache. The scan is microseconds vs ~20–50 ms for a
      * full tiktoken recount.
      */
@@ -94,13 +153,26 @@ export class ContextManagerV2 {
         enableWarnings: true,
         enableEnhancedCompression: true, // Enable by default
     };
-    constructor(config = {}) {
+    constructor(config = {}, segmentArchive = new SegmentArchive()) {
         this.config = { ...ContextManagerV2.DEFAULT_CONFIG, ...config };
+        if (config.model && config.maxContextTokens === undefined) {
+            const toolConfig = getModelToolConfig(config.model);
+            if (toolConfig.contextWindow) {
+                this.config.maxContextTokens = toolConfig.contextWindow;
+                if (config.responseReserveTokens === undefined) {
+                    this.config.responseReserveTokens = Math.floor(toolConfig.contextWindow * 0.125);
+                }
+                if (config.autoCompactThreshold === undefined) {
+                    this.config.autoCompactThreshold = Math.min(200_000, toolConfig.contextWindow);
+                }
+            }
+        }
         this.tokenCounter = createTokenCounter(this.config.model);
         this.sessionId = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.segmentArchive = segmentArchive;
         // Initialize enhanced compressor if enabled
         if (this.config.enableEnhancedCompression) {
-            this.enhancedCompressor = new EnhancedContextCompressor(this.tokenCounter, this.config.enhancedCompressionConfig);
+            this.enhancedCompressor = new EnhancedContextCompressor(this.tokenCounter, this.config.enhancedCompressionConfig, this.segmentArchive);
         }
     }
     /**
@@ -117,20 +189,41 @@ export class ContextManagerV2 {
     getContextEngine() {
         return this.contextEngine;
     }
+    /** Active logical conversation identifier used by context_expand. */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /** Request an explicit compaction on the next context preparation. */
+    requestManualCompaction() {
+        this.manualCompactionRequested = true;
+    }
     /**
      * Raw message preparation — used by DefaultContextEngine to delegate
      * back to the built-in compression pipeline without infinite recursion.
      */
-    prepareMessagesRaw(messages) {
+    prepareMessagesRaw(messages, options = {}) {
+        this.rejectIfCurrentRequestExceedsBudget(messages);
         const stats = this.getStats(messages);
+        const automaticCompaction = this.shouldAutoCompact(messages);
         const shouldSoftCompact = this.config.enableSummarization &&
             this.effectiveLimit <= 1000 &&
             messages.length > this.config.recentMessagesCount * 2;
-        const shouldCompact = this.shouldAutoCompact(messages) || stats.isNearLimit || shouldSoftCompact;
+        const requestedCompaction = this.manualCompactionRequested || options.reason !== undefined;
+        const shouldCompact = requestedCompaction || automaticCompaction || stats.isNearLimit || shouldSoftCompact;
         if (!shouldCompact) {
             this.lastTokenCount = stats.totalTokens;
+            this.assertLastUserPreserved(messages, messages);
             return messages;
         }
+        const reason = options.reason ?? (this.manualCompactionRequested ? 'manual' : 'auto');
+        this.manualCompactionRequested = false;
+        const preCompact = {
+            reason,
+            tokensBefore: stats.totalTokens,
+            messagesBefore: messages.length,
+        };
+        getGlobalEventBus().emit('context:pre_compact', preCompact);
+        const preservedContext = getUserHooksManager(this.config.workingDirectory ?? process.cwd()).runPreCompact(preCompact);
         let compacted;
         if (this.config.enableEnhancedCompression && this.enhancedCompressor) {
             compacted = this.prepareMessagesEnhanced(messages, stats);
@@ -138,6 +231,9 @@ export class ContextManagerV2 {
         else {
             compacted = this.prepareMessagesLegacy(messages, stats);
         }
+        compacted = this.injectPreservedContext(compacted, preservedContext);
+        this.assertLastUserPreserved(messages, compacted);
+        this.assertFitsTokenLimit(compacted);
         const newStats = this.getStats(compacted);
         if (newStats.totalTokens < stats.totalTokens) {
             try {
@@ -151,8 +247,33 @@ export class ContextManagerV2 {
                 logger.warn('Failed to fork run on compaction:', { error: String(err) });
             }
         }
+        // Re-arm warning thresholds we've dropped below so they can fire again.
+        this.rearmWarningsAfterCompaction(stats, compacted);
+        getGlobalEventBus().emit('context:post_compact', {
+            ...preCompact,
+            tokensAfter: newStats.totalTokens,
+            messagesAfter: compacted.length,
+        });
         return compacted;
     }
+    injectPreservedContext(messages, preservedContext) {
+        if (!preservedContext)
+            return messages;
+        const block = `<preserved_context>\n${preservedContext}\n</preserved_context>`;
+        const summaryIndex = messages.findIndex(message => message.role === 'system' &&
+            typeof message.content === 'string' &&
+            /summary|summarized/i.test(message.content));
+        const index = summaryIndex >= 0 ? summaryIndex : messages.findIndex(message => message.role === 'system');
+        if (index < 0) {
+            return [{ role: 'system', content: block }, ...messages];
+        }
+        const target = messages[index];
+        if (!target || typeof target.content !== 'string')
+            return messages;
+        return messages.map((message, messageIndex) => messageIndex === index
+            ? { ...message, content: `${target.content}\n${block}` }
+            : message);
+    }
     /**
      * Get the effective token limit (accounting for response reserve + estimation safety margin)
      * The 5% safety margin compensates for token counting estimation drift.
@@ -161,6 +282,61 @@ export class ContextManagerV2 {
         const raw = this.config.maxContextTokens - this.config.responseReserveTokens;
         return Math.floor(raw * 0.95);
     }
+    /**
+     * The current user request is inviolable. If it cannot fit even alone,
+     * fail before any provider call rather than answering a truncated prompt.
+     */
+    rejectIfCurrentRequestExceedsBudget(messages) {
+        const lastUser = findLastUserMessage(messages);
+        if (!lastUser)
+            return;
+        const tokens = this.countTokens([lastUser]);
+        if (tokens > this.effectiveLimit) {
+            throw new ContextCompactionError('CURRENT_REQUEST_EXCEEDS_BUDGET', tokens, this.effectiveLimit);
+        }
+    }
+    assertLastUserPreserved(original, prepared) {
+        const lastUser = findLastUserMessage(original);
+        if (!lastUser)
+            return;
+        if (preparedContainsLastUser(prepared, lastUser))
+            return;
+        throw new ContextCompactionError('CURRENT_REQUEST_EXCEEDS_BUDGET', this.countTokens([lastUser]), this.effectiveLimit, 'Current user request was dropped during context compaction. The request was not sent to the model.');
+    }
+    assertFitsTokenLimit(prepared) {
+        const tokens = this.countTokens(prepared);
+        if (tokens <= this.effectiveLimit)
+            return;
+        throw new ContextCompactionError('COMPACTION_EXCEEDS_LIMIT', tokens, this.effectiveLimit);
+    }
+    /** Diagnostics must describe the transcript actually sent, not a rejected attempt. */
+    recordLegacyCompressionResult(messages, originalTokens) {
+        const finalTokens = this.countTokens(messages);
+        this.lastEnhancedResult = {
+            compressed: originalTokens > finalTokens,
+            messages,
+            tokensReduced: originalTokens - finalTokens,
+            strategy: 'sliding_window',
+            metrics: {
+                originalTokens,
+                finalTokens,
+                compressionRatio: originalTokens / Math.max(1, finalTokens),
+                messagesRemoved: 0,
+                messagesSummarized: this.summaries.length > 0 ? 1 : 0,
+                toolResultsTruncated: 0,
+                compressionTimeMs: 0,
+                estimatedRetention: finalTokens / Math.max(1, originalTokens),
+                strategiesApplied: ['legacy_auto_compact'],
+            },
+            preservedInfo: {
+                decisions: [],
+                errors: [],
+                modifiedFiles: [],
+                codeSnippets: [],
+                toolCalls: [],
+            },
+        };
+    }
     /**
      * Count tokens in messages
      */
@@ -171,31 +347,22 @@ export class ContextManagerV2 {
         // Map CodeBuddyMessage to the format expected by TokenCounter
         const tokenMessages = messages.map(msg => ({
             role: msg.role,
-            content: typeof msg.content === 'string' ? msg.content : null,
+            content: typeof msg.content === 'string' || Array.isArray(msg.content) ? msg.content : null,
             tool_calls: 'tool_calls' in msg ? msg.tool_calls : undefined,
         }));
-        return this.tokenCounter.countMessageTokens(tokenMessages);
+        const imageTokens = messages.reduce((total, message) => total + estimateImageUrlTokens(message.content), 0);
+        return this.tokenCounter.countMessageTokens(tokenMessages) + imageTokens;
     }
     /**
-     * Compute a cheap fingerprint of the messages array for cache invalidation.
-     * Covers additions, in-place content mutation, and tool_call changes.
+     * Compute a content fingerprint of the messages array for cache invalidation.
+     * Length-only keys collide for different text/token distributions (and for
+     * different tool arguments of equal size), so hash the complete serialized
+     * provider transcript before reusing a token count.
      */
     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}`;
+        const serialized = JSON.stringify(messages);
+        const digest = createHash('sha256').update(serialized).digest('base64url');
+        return `${messages.length}:${serialized.length}:${digest}`;
     }
     /**
      * Get context statistics
@@ -290,46 +457,48 @@ export class ContextManagerV2 {
      * Implements auto-compact like mistral-vibe's AutoCompactMiddleware
      * Now supports enhanced compression with key info preservation
      */
-    prepareMessages(messages) {
+    prepareMessages(messages, options = {}) {
+        this.rejectIfCurrentRequestExceedsBudget(messages);
         // Delegate to pluggable context engine if registered (Native Engine v2026.3.7)
         if (this.contextEngine) {
+            // Helper to restore any dropped system messages and ensure valid tool pairs
+            const finalizeEngineMessages = (assembled) => {
+                let output = assembled;
+                const originalSystem = messages.filter(m => m.role === 'system');
+                const existingSystemContents = new Set(output.filter(m => m.role === 'system').map(m => m.content));
+                const missingSystem = originalSystem.filter(m => !existingSystemContents.has(m.content));
+                if (missingSystem.length > 0) {
+                    output = [...missingSystem, ...output];
+                }
+                output = repairToolCallPairs(output);
+                this.assertLastUserPreserved(messages, output);
+                this.assertFitsTokenLimit(output);
+                this.lastTokenCount = this.countTokens(output);
+                return output;
+            };
             // 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;
+                return finalizeEngineMessages(result.messages);
             }
             // Non-owning engine: run built-in compaction first, then assemble
-            const compacted = this.prepareMessagesRaw(messages);
+            const compacted = this.prepareMessagesRaw(messages, options);
             const result = this.contextEngine.assemble(compacted, this.effectiveLimit);
-            this.lastTokenCount = result.tokenCount;
-            return result.messages;
+            const finalized = finalizeEngineMessages(result.messages);
+            this.assertLastUserPreserved(messages, finalized);
+            this.assertFitsTokenLimit(finalized);
+            this.lastTokenCount = this.countTokens(finalized);
+            return finalized;
         }
         // Default pipeline (no engine registered)
-        return this.prepareMessagesRaw(messages);
+        return this.prepareMessagesRaw(messages, options);
     }
     /**
      * @deprecated Use prepareMessages() — this is kept for backwards compatibility
      */
     _prepareMessagesInternal(messages) {
-        const stats = this.getStats(messages);
-        const shouldSoftCompact = this.config.enableSummarization &&
-            this.effectiveLimit <= 1000 &&
-            messages.length > this.config.recentMessagesCount * 2;
-        // Check for auto-compact threshold (like mistral-vibe)
-        const shouldCompact = this.shouldAutoCompact(messages) || stats.isNearLimit || shouldSoftCompact;
-        // If within limits and below auto-compact threshold, return as-is
-        if (!shouldCompact) {
-            this.lastTokenCount = stats.totalTokens;
-            return messages;
-        }
-        // Use enhanced compression if available
-        if (this.config.enableEnhancedCompression && this.enhancedCompressor) {
-            return this.prepareMessagesEnhanced(messages, stats);
-        }
-        // Fall back to legacy compression
-        return this.prepareMessagesLegacy(messages, stats);
+        return this.prepareMessagesRaw(messages);
     }
     /**
      * Prepare messages using enhanced compression with key info preservation
@@ -340,8 +509,6 @@ export class ContextManagerV2 {
         }
         // Use enhanced compression
         const result = this.enhancedCompressor.compress(messages, this.effectiveLimit, this.sessionId);
-        // Store result for later access
-        this.lastEnhancedResult = result;
         // Guardrail: if enhanced compression cannot produce a usable result,
         // fall back to legacy deterministic strategies.
         const finalTokens = result.metrics.finalTokens;
@@ -351,20 +518,33 @@ export class ContextManagerV2 {
             this.effectiveLimit <= 1000 &&
             messages.length > this.config.recentMessagesCount * 2 &&
             result.messages.length >= messages.length;
+        const lastUser = findLastUserMessage(messages);
+        const lostLastUser = !!lastUser && !preparedContainsLastUser(result.messages, lastUser);
         const shouldFallback = (messages.length > 0 && result.messages.length === 0) ||
             (stats.totalTokens > this.effectiveLimit && finalTokens > this.effectiveLimit) ||
             (!result.compressed && stats.totalTokens > this.effectiveLimit) ||
             lostToolMessages ||
+            lostLastUser ||
             shouldPreferLegacySummarization;
         if (shouldFallback) {
             logger.debug('Enhanced compression fallback to legacy strategy');
             return this.prepareMessagesLegacy(messages, stats);
         }
+        const recounted = this.countTokens(result.messages);
+        this.lastEnhancedResult = {
+            ...result,
+            tokensReduced: stats.totalTokens - recounted,
+            metrics: {
+                ...result.metrics,
+                finalTokens: recounted,
+                compressionRatio: stats.totalTokens / Math.max(1, recounted),
+            },
+        };
         // Track metrics
         if (result.compressed) {
-            const tokensReduced = result.tokensReduced;
+            const tokensReduced = this.lastEnhancedResult.tokensReduced;
             logger.info(`Enhanced compression: Reduced ${tokensReduced.toLocaleString()} tokens ` +
-                `(${stats.totalTokens.toLocaleString()} -> ${result.metrics.finalTokens.toLocaleString()}) ` +
+                `(${stats.totalTokens.toLocaleString()} -> ${recounted.toLocaleString()}) ` +
                 `using ${result.metrics.strategiesApplied.join(', ')}`);
             // Log preserved key information
             const preserved = result.preservedInfo;
@@ -381,24 +561,36 @@ export class ContextManagerV2 {
             this.totalTokensSaved += tokensReduced;
             this.lastCompressionTime = new Date();
         }
-        this.lastTokenCount = finalTokens;
+        this.lastTokenCount = recounted;
         return result.messages;
     }
     /**
      * Legacy compression (original implementation)
      */
     prepareMessagesLegacy(messages, stats) {
-        // Extract system message if present
-        const systemMsg = messages.find(m => m.role === 'system');
+        // Extract ALL leading system messages, not just the first: the context
+        // pipeline injects several (workspace, lessons, decisions, code_graph,
+        // todo). The old `find(...)` kept one and `filter(role !== system)`
+        // silently dropped the rest — losing injected guidance on compaction.
+        const systemMsgs = messages.filter(m => m.role === 'system');
         const conversationMsgs = messages.filter(m => m.role !== 'system');
-        // Apply compression strategies
-        let optimizedMsgs = this.applyStrategies(conversationMsgs);
-        // Reconstruct with system message
-        if (systemMsg) {
-            optimizedMsgs = [systemMsg, ...optimizedMsgs];
+        const lastUser = findLastUserMessage(conversationMsgs);
+        const systemTokens = this.countTokens(systemMsgs);
+        const conversationBudget = this.effectiveLimit - systemTokens;
+        // Apply compression strategies against the room left after system prompts.
+        let optimizedMsgs = this.applyStrategies(conversationMsgs, lastUser, conversationBudget, systemMsgs.length > 0);
+        if (lastUser && !preparedContainsLastUser(optimizedMsgs, lastUser)) {
+            optimizedMsgs = this.reinsertLastUser(optimizedMsgs, conversationMsgs, lastUser);
+        }
+        // Reconstruct with the system messages first, order preserved.
+        if (systemMsgs.length > 0) {
+            optimizedMsgs = [...systemMsgs, ...optimizedMsgs];
         }
-        // Track token reduction for metrics
+        // Track token reduction for metrics — only if the result actually fits.
         const newStats = this.getStats(optimizedMsgs);
+        if (newStats.totalTokens > this.effectiveLimit) {
+            throw new ContextCompactionError('COMPACTION_EXCEEDS_LIMIT', newStats.totalTokens, this.effectiveLimit);
+        }
         const tokensReduced = stats.totalTokens - newStats.totalTokens;
         if (tokensReduced > 0) {
             logger.info(`Auto-compact: Reduced ${tokensReduced.toLocaleString()} tokens (${stats.totalTokens.toLocaleString()} -> ${newStats.totalTokens.toLocaleString()})`);
@@ -407,39 +599,53 @@ export class ContextManagerV2 {
             this.totalTokensSaved += tokensReduced;
             this.lastCompressionTime = new Date();
         }
+        this.recordLegacyCompressionResult(optimizedMsgs, stats.totalTokens);
         this.lastTokenCount = newStats.totalTokens;
         return optimizedMsgs;
     }
     /**
      * Apply compression strategies in order of priority
      */
-    applyStrategies(messages) {
+    applyStrategies(messages, pinnedLastUser, tokenLimit = this.effectiveLimit, hasOriginalSystem = true) {
         let result = [...messages];
         let currentTokens = this.countTokens(result);
         const shouldSoftSummarize = this.config.enableSummarization &&
             this.effectiveLimit <= 1000 &&
             result.length > this.config.recentMessagesCount * 2;
         // Strategy 1: Keep only recent messages (Sliding Window)
-        if (currentTokens > this.effectiveLimit) {
-            result = this.applySlidingWindow(result);
+        if (currentTokens > tokenLimit) {
+            result = this.applySlidingWindow(result, hasOriginalSystem);
             currentTokens = this.countTokens(result);
         }
         // Strategy 2: Truncate tool results (they can be verbose)
-        if (currentTokens > this.effectiveLimit) {
+        if (currentTokens > tokenLimit) {
             result = this.truncateToolResults(result);
             currentTokens = this.countTokens(result);
         }
         // Strategy 3: Summarize old conversations
-        if ((currentTokens > this.effectiveLimit || shouldSoftSummarize) && this.config.enableSummarization) {
-            result = this.applySummarization(result);
+        if ((currentTokens > tokenLimit || shouldSoftSummarize) && this.config.enableSummarization) {
+            result = this.applySummarization(result, hasOriginalSystem);
             currentTokens = this.countTokens(result);
         }
         // Strategy 4: Hard truncation as last resort
-        if (currentTokens > this.effectiveLimit) {
-            result = this.hardTruncate(result);
+        if (currentTokens > tokenLimit) {
+            result = this.hardTruncate(result, pinnedLastUser, tokenLimit);
         }
         return result;
     }
+    /**
+     * Put the intact current user request back after strategies that dropped it
+     * (e.g. a short recent window that only kept trailing tool results).
+     */
+    reinsertLastUser(compacted, originalConversation, lastUser) {
+        const originalIndex = originalConversation.lastIndexOf(lastUser);
+        const following = originalIndex >= 0
+            ? new Set(originalConversation.slice(originalIndex + 1))
+            : new Set();
+        const trailing = compacted.filter(message => following.has(message));
+        const head = compacted.filter(message => !following.has(message));
+        return [...head, lastUser, ...trailing];
+    }
     /**
      * Get or create the importance scorer (lazy-loaded).
      */
@@ -453,7 +659,7 @@ export class ContextManagerV2 {
      * Strategy 1: Sliding Window - Keep N most recent messages
      * Uses ImportanceScorer to preserve high-importance messages outside the window.
      */
-    applySlidingWindow(messages) {
+    applySlidingWindow(messages, hasOriginalSystem = true) {
         const keepCount = this.config.recentMessagesCount;
         if (messages.length <= keepCount) {
             return messages;
@@ -465,20 +671,25 @@ export class ContextManagerV2 {
         // For messages outside the window, keep any with score > 0.8 (high importance)
         const oldMessages = messages.slice(0, -keepCount);
         const importantOldMessages = [];
+        const removedMessages = [];
         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);
             }
+            else if (oldMessage !== undefined) {
+                removedMessages.push(oldMessage);
+            }
         }
-        // Create a summary marker for removed messages
+        // Create a summary marker for removed messages only if system messages originally existed
         const removedCount = messages.length - keepCount - importantOldMessages.length;
         const parts = [];
-        if (removedCount > 0) {
+        if (removedCount > 0 && hasOriginalSystem) {
+            const marker = `[Previous ${removedCount} messages summarized due to context limits]`;
             parts.push({
                 role: 'system',
-                content: `[Previous ${removedCount} messages summarized due to context limits]`,
+                content: this.withSegmentMarker(marker, removedMessages),
             });
         }
         return [...parts, ...importantOldMessages, ...recentMessages];
@@ -493,8 +704,7 @@ export class ContextManagerV2 {
                 if (msg.content.length > MAX_TOOL_RESULT_LENGTH) {
                     return {
                         ...msg,
-                        content: msg.content.substring(0, MAX_TOOL_RESULT_LENGTH) +
-                            '\n... [truncated for context limits]',
+                        content: truncateOutput(msg.content, MAX_TOOL_RESULT_LENGTH),
                     };
                 }
             }
@@ -505,7 +715,7 @@ export class ContextManagerV2 {
      * Strategy 3: Summarize older messages
      * Based on Recursive Summarization (arxiv:2308.15022)
      */
-    applySummarization(messages) {
+    applySummarization(messages, hasOriginalSystem = true) {
         const keepRecent = Math.min(this.config.recentMessagesCount, messages.length);
         if (messages.length <= keepRecent) {
             return messages;
@@ -530,19 +740,47 @@ export class ContextManagerV2 {
             this.summaries.splice(0, removeCount);
             logger.debug(`Cleaned up ${removeCount} old summaries to prevent memory growth`);
         }
-        // Create summary message
+        // Keep the extractive summary, but do not invent a system role when the
+        // original transcript had none (same contract as applySlidingWindow).
         const summaryMessage = {
-            role: 'system',
-            content: `[Conversation Summary]\n${summaryContent}`,
+            role: hasOriginalSystem ? 'system' : 'user',
+            content: this.withSegmentMarker(`[Conversation Summary]\n${summaryContent}`, oldMessages),
         };
         return [summaryMessage, ...recentMessages];
     }
+    withSegmentMarker(summary, originalMessages) {
+        if (!isContextZoomEnabled())
+            return summary;
+        const segmentId = this.segmentArchive.archive(this.sessionId, originalMessages, summary);
+        return segmentId ? `[segment:${segmentId}] ${summary}` : summary;
+    }
     /**
      * Create a condensed summary of messages
      * This is a simple extractive summary - for production, use LLM-based summarization
      */
     createSummary(messages) {
+        // Bounds for the "failed tool attempts" section carried through the
+        // extractive summary — keep it small so it never bloats the budget.
+        const MAX_PRESERVED_TOOL_FAILURES = 5;
+        const MAX_TOOL_FAILURE_CHARS = 200;
         const summaryParts = [];
+        // Attribute a failed tool_result to the tool that produced it by mapping
+        // tool_call_id -> function name from the assistant tool_calls.
+        const toolNameById = new Map();
+        for (const msg of messages) {
+            if (msg.role === 'assistant' && 'tool_calls' in msg && Array.isArray(msg.tool_calls)) {
+                for (const tc of msg.tool_calls) {
+                    if (tc && tc.type === 'function' && typeof tc.id === 'string') {
+                        toolNameById.set(tc.id, tc.function.name);
+                    }
+                }
+            }
+        }
+        // Manus AI error preservation: failed tool attempts must SURVIVE extractive
+        // compaction so the agent doesn't blindly retry them. Keep ONLY failures
+        // (successful tool_results would be noise) — the successes' role:'tool'
+        // messages are otherwise dropped here, which is exactly what we want.
+        const failedAttempts = [];
         for (const msg of messages) {
             if (msg.role === 'user' && typeof msg.content === 'string') {
                 // Extract key user requests (first 100 chars)
@@ -554,23 +792,41 @@ export class ContextManagerV2 {
                 const truncated = msg.content.substring(0, 100);
                 summaryParts.push(`Assistant: ${truncated}${msg.content.length > 100 ? '...' : ''}`);
             }
+            else if (msg.role === 'tool' && typeof msg.content === 'string') {
+                if (isFailedToolResultContent(msg.content)) {
+                    const id = msg.tool_call_id;
+                    const name = (id ? toolNameById.get(id) : undefined) ?? 'tool';
+                    const snippet = msg.content.replace(/\s+/g, ' ').trim().slice(0, MAX_TOOL_FAILURE_CHARS);
+                    failedAttempts.push(`- ${name}: ${snippet}`);
+                }
+            }
         }
-        // Limit summary to target size based on compression ratio
+        // Limit conversation lines to target size based on compression ratio.
         const maxSummaryItems = Math.ceil(messages.length / this.config.compressionRatio);
-        return summaryParts.slice(0, maxSummaryItems).join('\n');
+        const lines = summaryParts.slice(0, maxSummaryItems);
+        // Append the bounded failed-tool-attempts section AFTER the slice so a long
+        // conversation can't push it out — the whole point is that failures survive.
+        if (failedAttempts.length > 0) {
+            lines.push('Failed tool attempts (do not retry):');
+            lines.push(...failedAttempts.slice(-MAX_PRESERVED_TOOL_FAILURES));
+        }
+        return lines.join('\n');
     }
     /**
      * Strategy 4: Hard truncation as last resort
      */
-    hardTruncate(messages) {
+    hardTruncate(messages, pinnedLastUser, tokenLimit = this.effectiveLimit) {
         let result = [...messages];
         let currentTokens = this.countTokens(result);
         // Remove oldest messages, preserving tool-call/tool-result pairs
-        while (currentTokens > this.effectiveLimit && result.length > 2) {
+        while (currentTokens > tokenLimit && result.length > 2) {
             const first = result[0];
             // result.length > 2 (loop guard above) guarantees result[0] exists; guard for type-safety
             if (first === undefined)
                 break;
+            if (pinnedLastUser && isIntactUserMessage(first, pinnedLastUser)) {
+                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));
@@ -592,9 +848,11 @@ export class ContextManagerV2 {
             }
             currentTokens = this.countTokens(result);
         }
-        // If still over limit, truncate message content
-        if (currentTokens > this.effectiveLimit) {
+        // If still over limit, truncate message content — never the current user request.
+        if (currentTokens > tokenLimit) {
             result = result.map(msg => {
+                if (pinnedLastUser && isIntactUserMessage(msg, pinnedLastUser))
+                    return msg;
                 if (typeof msg.content === 'string' && msg.content.length > 200) {
                     return {
                         ...msg,
@@ -680,13 +938,93 @@ export class ContextManagerV2 {
     resetWarnings() {
         this.triggeredWarnings.clear();
     }
+    /**
+     * Export conversation-owned caches and compression recovery state.
+     * Configuration, tokenizer instances, and the pluggable engine stay on the
+     * host agent; mutable data that could reveal another session does not.
+     */
+    exportConversationState() {
+        return structuredClone({
+            summaries: this.summaries,
+            systemMessage: this.systemMessage,
+            triggeredWarnings: [...this.triggeredWarnings],
+            lastTokenCount: this.lastTokenCount,
+            lastEnhancedResult: this.lastEnhancedResult,
+            sessionId: this.sessionId,
+            peakMessageCount: this.peakMessageCount,
+            compressionCount: this.compressionCount,
+            totalTokensSaved: this.totalTokensSaved,
+            lastCompressionTime: this.lastCompressionTime,
+            snapshotCount: this.snapshotCount,
+            enhancedCompression: this.enhancedCompressor?.exportConversationState() ?? null,
+        });
+    }
+    /** Restore a logical conversation and always invalidate derived token stats. */
+    importConversationState(state) {
+        const cloned = structuredClone(state);
+        this.summaries = cloned.summaries;
+        this.systemMessage = cloned.systemMessage;
+        this.triggeredWarnings = new Set(cloned.triggeredWarnings);
+        this.lastTokenCount = cloned.lastTokenCount;
+        this.lastEnhancedResult = cloned.lastEnhancedResult;
+        this.sessionId = cloned.sessionId;
+        this.peakMessageCount = cloned.peakMessageCount;
+        this.compressionCount = cloned.compressionCount;
+        this.totalTokensSaved = cloned.totalTokensSaved;
+        this.lastCompressionTime = cloned.lastCompressionTime;
+        this.snapshotCount = cloned.snapshotCount;
+        this._cachedStatsFingerprint = '';
+        this._cachedStatsTokenCount = 0;
+        if (this.enhancedCompressor && cloned.enhancedCompression) {
+            this.enhancedCompressor.importConversationState(cloned.enhancedCompression);
+        }
+        else {
+            this.enhancedCompressor?.clearArchives();
+        }
+    }
+    /**
+     * After a compaction reduces context usage, re-arm any warning threshold we've
+     * now dropped BELOW so it can fire again when usage climbs back up. Without
+     * this, `triggeredWarnings` only ever grew, so a threshold warned at most once
+     * per conversation — on a long session with multiple compaction cycles the
+     * user stopped getting context warnings exactly when they matter most.
+     */
+    rearmWarningsAfterCompaction(before, compacted) {
+        const after = this.getStats(compacted);
+        if (after.totalTokens >= before.totalTokens)
+            return; // compaction didn't reduce usage
+        for (const threshold of [...this.triggeredWarnings]) {
+            if (threshold > after.usagePercent)
+                this.triggeredWarnings.delete(threshold);
+        }
+    }
     /**
      * Update configuration
      */
     updateConfig(config) {
         this.config = { ...this.config, ...config };
         if (config.model) {
+            if (config.maxContextTokens === undefined) {
+                const toolConfig = getModelToolConfig(config.model);
+                if (toolConfig.contextWindow) {
+                    this.config.maxContextTokens = toolConfig.contextWindow;
+                    if (config.responseReserveTokens === undefined) {
+                        this.config.responseReserveTokens = Math.floor(toolConfig.contextWindow * 0.125);
+                    }
+                    if (config.autoCompactThreshold === undefined) {
+                        this.config.autoCompactThreshold = Math.min(200_000, toolConfig.contextWindow);
+                    }
+                }
+            }
             this.tokenCounter = createTokenCounter(config.model);
+            if (this.config.enableEnhancedCompression) {
+                this.enhancedCompressor = new EnhancedContextCompressor(this.tokenCounter, this.config.enhancedCompressionConfig, this.segmentArchive);
+            }
+            // The stats cache is keyed only by message shape (length/content/tool
+            // calls), not the tokenizer — so a model swap that keeps the same
+            // messages would otherwise return a stale count from the OLD tokenizer.
+            this._cachedStatsFingerprint = '';
+            this._cachedStatsTokenCount = 0;
         }
     }
     /**
@@ -704,6 +1042,8 @@ export class ContextManagerV2 {
         this.summaries = [];
         this.triggeredWarnings.clear();
         this.lastTokenCount = 0;
+        this.lastEnhancedResult = null;
+        this.enhancedCompressor?.clearArchives();
     }
     /**
      * Get last token count (useful for tracking auto-compact effectiveness)
@@ -751,7 +1091,11 @@ export class ContextManagerV2 {
      */
     forceCleanup() {
         const summariesRemoved = this.summaries.length;
-        const tokensFreed = this.summaries.reduce((total, s) => total + s.tokenCount, 0);
+        const summaryTokens = this.summaries.reduce((total, s) => total + s.tokenCount, 0);
+        const archiveTokens = this.lastEnhancedResult?.fullContextArchive?.tokenCount
+            ?? this.lastEnhancedResult?.metrics.originalTokens
+            ?? 0;
+        const tokensFreed = summaryTokens + archiveTokens;
         // Clear all summaries
         this.summaries = [];
         // Reset metrics that can be recalculated
@@ -761,6 +1105,9 @@ export class ContextManagerV2 {
         if (this.enhancedCompressor) {
             this.enhancedCompressor.clearArchives();
         }
+        // Drop the strong reference to the last full context — listArchives()
+        // alone does not make the heap-held transcript collectable.
+        this.lastEnhancedResult = null;
         logger.info(`Force cleanup: removed ${summariesRemoved} summaries, freed ~${tokensFreed} tokens`);
         return { summariesRemoved, tokensFreed };
     }
@@ -881,7 +1228,7 @@ export class ContextManagerV2 {
     setEnhancedCompressionEnabled(enabled) {
         this.config.enableEnhancedCompression = enabled;
         if (enabled && !this.enhancedCompressor) {
-            this.enhancedCompressor = new EnhancedContextCompressor(this.tokenCounter, this.config.enhancedCompressionConfig);
+            this.enhancedCompressor = new EnhancedContextCompressor(this.tokenCounter, this.config.enhancedCompressionConfig, this.segmentArchive);
             logger.info('Enhanced compression enabled');
         }
         else if (!enabled) {
@@ -956,7 +1303,7 @@ export class ContextManagerV2 {
         try {
             const dir = path.join(workDir, '.codebuddy');
             fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(path.join(dir, 'context-snapshot.json'), JSON.stringify(snapshot, null, 2), 'utf8');
+            writeJsonAtomicSync(path.join(dir, 'context-snapshot.json'), snapshot, { mode: 0o600 });
         }
         catch (err) {
             logger.debug('Context snapshot write failed', { error: String(err) });
@@ -1016,7 +1363,7 @@ export class ContextManagerV2 {
 /**
  * Create a context manager with auto-detection of model limits
  */
-export function createContextManager(model, maxTokens) {
+export function createContextManager(model, maxTokens, workingDirectory) {
     // Use getModelToolConfig for glob-pattern matching (covers grok-3*, grok-4*, claude-*, etc.)
     const toolConfig = getModelToolConfig(model);
     const detectedLimit = maxTokens || toolConfig.contextWindow || 8192;
@@ -1024,6 +1371,12 @@ export function createContextManager(model, maxTokens) {
         model,
         maxContextTokens: detectedLimit,
         responseReserveTokens: Math.floor(detectedLimit * 0.125), // 12.5% reserve
+        // The absolute auto-compact gate (mistral-vibe style, default 200K) was
+        // DEAD for every sub-200K model: the default exceeded the whole window,
+        // so shouldAutoCompact() could never fire on it. Clamp it to the window;
+        // for ≥200K-window models (grok 2M…) the 200K cap keeps its meaning.
+        autoCompactThreshold: Math.min(200_000, detectedLimit),
+        ...(workingDirectory ? { workingDirectory } : {}),
     });
 }
 // Singleton for simple usage