byterover-cli 1.8.0 → 2.0.0

package/dist/agent/infra/llm/context/compaction/compaction-service.d.ts

@@ -20,18 +20,18 @@ export interface CompactionConfig {
      */
     protectedTurns?: number;
     /**
-     * Number of tokens to keep in tool outputs after pruning.
-     * Based on OpenCode's PRUNE_PROTECT constant.
-     * Default: 40000
+     * Fraction of the context window to keep in tool outputs after pruning (0.0 - 1.0).
+     * Computed against the actual context limit at prune time so it scales correctly
+     * across different model context window sizes.
+     * Default: 0.20 (20% — equals ~40K tokens on a 200K context model)
      */
-    pruneKeepTokens?: number;
+    pruneKeepPercent?: number;
     /**
-     * Minimum tokens that must be recoverable to perform pruning.
-     * Based on OpenCode's PRUNE_MINIMUM constant.
-     * If pruning would save less than this, skip it.
-     * Default: 20000
+     * Minimum fraction of the context window that must be recoverable to perform pruning (0.0 - 1.0).
+     * If pruning would save less than this fraction, the prune is skipped.
+     * Default: 0.10 (10% — equals ~20K tokens on a 200K context model)
      */
-    pruneMinimumTokens?: number;
+    pruneMinimumPercent?: number;
     /**
      * System prompt for generating compaction summaries.
      */
@@ -124,13 +124,15 @@ export declare class CompactionService {
     };
     /**
      * Prune old tool outputs to reduce context size.
-     * Keeps the most recent tool outputs up to the configured token limit.
-     * Only executes if minimum token threshold can be recovered.
+     * Keeps the most recent tool outputs up to a fraction of the context window.
+     * Only executes if the minimum recoverable fraction threshold is met.
      *
      * @param sessionId - The session to prune
+     * @param contextLimit - The model's actual context window size in tokens.
+     *   Used to compute absolute keep/minimum thresholds from the configured percentages.
      * @returns CompactionResult with count and tokens saved (or zeros if below threshold)
      */
-    pruneToolOutputs(sessionId: string): Promise<CompactionResult>;
+    pruneToolOutputs(sessionId: string, contextLimit: number): Promise<CompactionResult>;
 }
 /**
  * Factory function to create CompactionService.

package/dist/agent/infra/llm/context/compaction/compaction-service.js

@@ -33,8 +33,8 @@ export class CompactionService {
         this.config = {
             overflowThreshold: config?.overflowThreshold ?? 0.85,
             protectedTurns: config?.protectedTurns ?? 2,
-            pruneKeepTokens: config?.pruneKeepTokens ?? 40_000,
-            pruneMinimumTokens: config?.pruneMinimumTokens ?? 20_000,
+            pruneKeepPercent: config?.pruneKeepPercent ?? 0.2,
+            pruneMinimumPercent: config?.pruneMinimumPercent ?? 0.1,
             summaryPrompt: config?.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT,
         };
     }
@@ -51,7 +51,7 @@ export class CompactionService {
             return undefined;
         }
         if (overflowCheck.recommendation === 'prune') {
-            return this.pruneToolOutputs(sessionId);
+            return this.pruneToolOutputs(sessionId, contextLimit);
         }
         // For full compaction, we need the caller to generate the summary
         // via the LLM, then call createCompactionBoundary
@@ -110,13 +110,26 @@ export class CompactionService {
      */
     async generateSummary(generator, messages, taskId, model) {
         const { systemPrompt, userMessage } = this.getSummaryPromptParts();
+        // Bound messages to prevent the summary call itself from overflowing.
+        // Keep first 5 messages (initial context) + last 35 messages (recent work).
+        const MAX_MESSAGES_FOR_SUMMARY = 40;
+        const boundedMessages = messages.length > MAX_MESSAGES_FOR_SUMMARY
+            ? [
+                ...messages.slice(0, 5),
+                {
+                    content: `[${messages.length - MAX_MESSAGES_FOR_SUMMARY} messages omitted for summarization]`,
+                    role: 'system',
+                },
+                ...messages.slice(-(MAX_MESSAGES_FOR_SUMMARY - 5)),
+            ]
+            : messages;
         try {
             const response = await generator.generateContent({
                 config: {
                     maxTokens: 4096, // Reasonable limit for summaries
                     temperature: 0.3, // Lower temperature for more focused summaries
                 },
-                contents: [...messages, { content: userMessage, role: 'user' }],
+                contents: [...boundedMessages, { content: userMessage, role: 'user' }],
                 model,
                 systemPrompt,
                 taskId,
@@ -149,16 +162,20 @@ export class CompactionService {
     }
     /**
      * Prune old tool outputs to reduce context size.
-     * Keeps the most recent tool outputs up to the configured token limit.
-     * Only executes if minimum token threshold can be recovered.
+     * Keeps the most recent tool outputs up to a fraction of the context window.
+     * Only executes if the minimum recoverable fraction threshold is met.
      *
      * @param sessionId - The session to prune
+     * @param contextLimit - The model's actual context window size in tokens.
+     *   Used to compute absolute keep/minimum thresholds from the configured percentages.
      * @returns CompactionResult with count and tokens saved (or zeros if below threshold)
      */
-    async pruneToolOutputs(sessionId) {
+    async pruneToolOutputs(sessionId, contextLimit) {
+        const keepTokens = Math.floor(contextLimit * this.config.pruneKeepPercent);
+        const minimumTokens = Math.floor(contextLimit * this.config.pruneMinimumPercent);
         const result = await this.messageStorage.pruneToolOutputs({
-            keepTokens: this.config.pruneKeepTokens,
-            minimumTokens: this.config.pruneMinimumTokens,
+            keepTokens,
+            minimumTokens,
             protectedTurns: this.config.protectedTurns,
             sessionId,
         });

package/dist/agent/infra/llm/context/compression/reactive-overflow.js

@@ -159,21 +159,30 @@ export class ReactiveOverflowStrategy {
      * Format messages for the summary prompt.
      */
     formatMessagesForSummary(messages) {
+        const MAX_TOTAL_CHARS = 50_000;
+        const MAX_PER_MESSAGE_CHARS = 1000;
         const lines = [];
+        let totalChars = 0;
         for (const message of messages) {
+            if (totalChars >= MAX_TOTAL_CHARS) {
+                lines.push(`[... ${messages.length - lines.length} more messages truncated for summarization]`);
+                break;
+            }
             const role = this.formatRole(message.role);
             const content = this.extractTextContent(message);
-            // Truncate very long messages
-            const truncatedContent = content.length > 2000
-                ? `${content.slice(0, 2000)}... [truncated]`
+            // Truncate very long messages (capped at 1K chars to prevent overflow)
+            const truncatedContent = content.length > MAX_PER_MESSAGE_CHARS
+                ? `${content.slice(0, MAX_PER_MESSAGE_CHARS)}... [truncated]`
                 : content;
             if (truncatedContent) {
                 lines.push(`${role}: ${truncatedContent}`);
+                totalChars += truncatedContent.length;
             }
             // Include tool call information
             if (message.toolCalls && message.toolCalls.length > 0) {
                 const toolNames = message.toolCalls.map((tc) => tc.function.name).join(', ');
                 lines.push(`[Used tools: ${toolNames}]`);
+                totalChars += toolNames.length + 15;
             }
         }
         return lines.join('\n\n');

package/dist/agent/infra/llm/context/context-manager.d.ts

@@ -107,6 +107,16 @@ export declare class ContextManager<T> {
     private readonly mutex;
     /** Callback for persistence failure events */
     private readonly onPersistenceFailed?;
+    /**
+     * Whether in-memory messages have diverged from storage (e.g. after compression).
+     * When true, the next persist call falls back to full saveHistory().
+     */
+    private persistDirty;
+    /**
+     * Number of messages already persisted to storage.
+     * Used to determine whether appendMessage() or saveHistory() should be called.
+     */
+    private persistedCount;
     /** Retry configuration for persistence operations */
     private readonly persistenceRetry;
     private readonly sessionId;
@@ -146,7 +156,7 @@ export declare class ContextManager<T> {
      * @param toolName - Name of the tool being called
      * @param input - Parsed input arguments
      */
-    addToolCallPending(callId: string, toolName: string, input: Record<string, unknown>): void;
+    addToolCallPending(callId: string, toolName: string, input: Record<string, unknown>): Promise<void>;
     /**
      * Add a tool result message to the conversation.
      * Thread-safe: Uses mutex to protect shared state during parallel tool execution.
@@ -246,6 +256,26 @@ export declare class ContextManager<T> {
      * @returns True if history was loaded, false otherwise
      */
     initialize(): Promise<boolean>;
+    /**
+     * Mark old tool outputs as compacted in-memory.
+     * Traverses messages backwards, counting user turns. After `protectedTurns`
+     * user turns, replaces tool message content with a placeholder.
+     *
+     * This is a non-destructive alternative to `compressMessage()` — it reduces
+     * token usage without removing messages from the array.
+     *
+     * @param protectedTurns - Number of recent user turns to protect (default: 2)
+     * @returns Number of tool messages compacted
+     */
+    markToolOutputsCompacted(protectedTurns?: number): number;
+    /**
+     * Reload messages from storage, replacing in-memory state.
+     * Used after compaction boundary creation to discard pre-boundary messages.
+     *
+     * GranularHistoryStorage.loadHistory() already stops at compaction boundaries,
+     * so this effectively trims in-memory state to only post-boundary messages.
+     */
+    reloadFromStorage(): Promise<void>;
     /**
      * Update a tool call's state.
      * Used for transitioning through pending → running → completed/error.
@@ -253,7 +283,7 @@ export declare class ContextManager<T> {
      * @param callId - ID of the tool call to update
      * @param stateUpdate - New state
      */
-    updateToolCallState(callId: string, stateUpdate: ToolState): void;
+    updateToolCallState(callId: string, stateUpdate: ToolState): Promise<void>;
     /**
      * Add a ToolPart to a message at the given index.
      */
@@ -276,6 +306,10 @@ export declare class ContextManager<T> {
      * @returns Token count
      */
     private countTokens;
+    /**
+     * Execute a persistence operation with exponential backoff retry logic.
+     */
+    private executeWithRetry;
     /**
      * Find the index of the last assistant message.
      *
@@ -291,7 +325,7 @@ export declare class ContextManager<T> {
     private isSystemNoise;
     /**
      * Persist current conversation history to storage with retry logic.
-     * This is called automatically after each message is added.
+     * This is the full-save fallback path — saves the entire message array.
      *
      * Uses exponential backoff for retries:
      * - Attempt 1: immediate
@@ -303,6 +337,13 @@ export declare class ContextManager<T> {
      * @returns Promise that resolves when history is persisted (or all retries exhausted)
      */
     private persistHistory;
+    /**
+     * Persist a single message incrementally.
+     * Falls back to full saveHistory() if in-memory state has diverged from storage.
+     *
+     * @param message - The single message to persist
+     */
+    private persistMessage;
     /**
      * Sanitize tool result for storage.
      * Handles large outputs, binary data, circular references, etc.

package/dist/agent/infra/llm/context/context-manager.js

@@ -1,4 +1,5 @@
 import { getErrorMessage } from '../../../../server/utils/error-helpers.js';
+import { COMPACTED_TOOL_OUTPUT_PLACEHOLDER } from '../../../core/domain/storage/message-storage-types.js';
 import { NoOpLogger } from '../../../core/interfaces/i-logger.js';
 import { AsyncMutex } from './async-mutex.js';
 import { MiddleRemovalStrategy, OldestRemovalStrategy } from './compression/index.js';
@@ -30,6 +31,16 @@ export class ContextManager {
     mutex = new AsyncMutex();
     /** Callback for persistence failure events */
     onPersistenceFailed;
+    /**
+     * Whether in-memory messages have diverged from storage (e.g. after compression).
+     * When true, the next persist call falls back to full saveHistory().
+     */
+    persistDirty = false;
+    /**
+     * Number of messages already persisted to storage.
+     * Used to determine whether appendMessage() or saveHistory() should be called.
+     */
+    persistedCount = 0;
     /** Retry configuration for persistence operations */
     persistenceRetry;
     sessionId;
@@ -82,7 +93,7 @@ export class ContextManager {
         await this.mutex.withLock(async () => {
             this.messages.push(message);
             try {
-                await this.persistHistory();
+                await this.persistMessage(message);
             }
             catch (error) {
                 this.logger.error('Failed to persist history after assistant message', { error, sessionId: this.sessionId });
@@ -102,7 +113,7 @@ export class ContextManager {
         await this.mutex.withLock(async () => {
             this.messages.push(message);
             try {
-                await this.persistHistory();
+                await this.persistMessage(message);
             }
             catch (error) {
                 this.logger.error('Failed to persist history after system message', { error, sessionId: this.sessionId });
@@ -117,20 +128,22 @@ export class ContextManager {
      * @param toolName - Name of the tool being called
      * @param input - Parsed input arguments
      */
-    addToolCallPending(callId, toolName, input) {
-        const toolPart = {
-            callId,
-            state: { input, status: 'pending' },
-            toolName,
-            type: 'tool',
-        };
-        // Find the last assistant message and add the tool part
-        const lastAssistantIdx = this.findLastAssistantMessageIndex();
-        if (lastAssistantIdx === -1) {
-            this.logger.warn('No assistant message found to add tool call', { callId, sessionId: this.sessionId });
-            return;
-        }
-        this.addToolPartToMessage(lastAssistantIdx, toolPart);
+    async addToolCallPending(callId, toolName, input) {
+        await this.mutex.withLock(async () => {
+            const toolPart = {
+                callId,
+                state: { input, status: 'pending' },
+                toolName,
+                type: 'tool',
+            };
+            // Find the last assistant message and add the tool part
+            const lastAssistantIdx = this.findLastAssistantMessageIndex();
+            if (lastAssistantIdx === -1) {
+                this.logger.warn('No assistant message found to add tool call', { callId, sessionId: this.sessionId });
+                return;
+            }
+            this.addToolPartToMessage(lastAssistantIdx, toolPart);
+        });
     }
     /**
      * Add a tool result message to the conversation.
@@ -180,7 +193,7 @@ export class ContextManager {
             this.messages.push(message);
             // Persist within the lock to ensure ordering consistency
             try {
-                await this.persistHistory();
+                await this.persistMessage(message);
             }
             catch (error) {
                 this.logger.error('Failed to persist history after tool result', { error, sessionId: this.sessionId });
@@ -200,30 +213,35 @@ export class ContextManager {
             content,
             role: 'user',
         };
-        this.messages.push(message);
-        try {
-            await this.persistHistory();
-        }
-        catch (error) {
-            this.logger.error('Failed to persist history after user message', { error, sessionId: this.sessionId });
-        }
+        await this.mutex.withLock(async () => {
+            this.messages.push(message);
+            try {
+                await this.persistMessage(message);
+            }
+            catch (error) {
+                this.logger.error('Failed to persist history after user message', { error, sessionId: this.sessionId });
+            }
+        });
     }
     /**
      * Clear all messages from the conversation history.
      * Also clears persisted history if storage is enabled.
      */
     async clearHistory() {
-        this.messages = [];
-        // Clear persisted history if storage enabled
-        if (this.historyStorage) {
-            try {
-                await this.historyStorage.deleteHistory(this.sessionId);
-                // Debug logging removed for cleaner user experience
-            }
-            catch (error) {
-                this.logger.error('Failed to clear persisted history', { error, sessionId: this.sessionId });
+        await this.mutex.withLock(async () => {
+            this.messages = [];
+            this.persistedCount = 0;
+            this.persistDirty = false;
+            // Clear persisted history if storage enabled
+            if (this.historyStorage) {
+                try {
+                    await this.historyStorage.deleteHistory(this.sessionId);
+                }
+                catch (error) {
+                    this.logger.error('Failed to clear persisted history', { error, sessionId: this.sessionId });
+                }
             }
-        }
+        });
     }
     /**
      * Compress messages by removing oldest messages until total tokens fit within the budget.
@@ -239,7 +257,10 @@ export class ContextManager {
             totalTokens -= messageTokens[toRemoveIndex];
             toRemoveIndex += 1;
         }
-        this.messages = this.messages.slice(toRemoveIndex);
+        if (toRemoveIndex > 0) {
+            this.messages = this.messages.slice(toRemoveIndex);
+            this.persistDirty = true;
+        }
     }
     /**
      * Flush any pending history writes to storage.
@@ -358,12 +379,11 @@ export class ContextManager {
             const history = await this.historyStorage.loadHistory(this.sessionId);
             if (history && history.length > 0) {
                 this.messages = history;
+                this.persistedCount = history.length;
                 this.isInitialized = true;
-                // Debug logging removed for cleaner user experience
                 return true;
             }
             this.isInitialized = true;
-            // Debug logging removed for cleaner user experience
             return false;
         }
         catch (error) {
@@ -372,6 +392,64 @@ export class ContextManager {
             return false;
         }
     }
+    /**
+     * Mark old tool outputs as compacted in-memory.
+     * Traverses messages backwards, counting user turns. After `protectedTurns`
+     * user turns, replaces tool message content with a placeholder.
+     *
+     * This is a non-destructive alternative to `compressMessage()` — it reduces
+     * token usage without removing messages from the array.
+     *
+     * @param protectedTurns - Number of recent user turns to protect (default: 2)
+     * @returns Number of tool messages compacted
+     */
+    markToolOutputsCompacted(protectedTurns = 2) {
+        let userTurnCount = 0;
+        let compactedCount = 0;
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const message = this.messages[i];
+            if (message.role === 'user') {
+                userTurnCount++;
+            }
+            // Only compact tool messages beyond the protected turns
+            if (message.role === 'tool' && userTurnCount > protectedTurns) {
+                // Skip already-compacted messages
+                if (message.content === COMPACTED_TOOL_OUTPUT_PLACEHOLDER)
+                    continue;
+                this.messages[i] = {
+                    ...message,
+                    content: COMPACTED_TOOL_OUTPUT_PLACEHOLDER,
+                };
+                compactedCount++;
+            }
+        }
+        if (compactedCount > 0) {
+            this.persistDirty = true;
+        }
+        return compactedCount;
+    }
+    /**
+     * Reload messages from storage, replacing in-memory state.
+     * Used after compaction boundary creation to discard pre-boundary messages.
+     *
+     * GranularHistoryStorage.loadHistory() already stops at compaction boundaries,
+     * so this effectively trims in-memory state to only post-boundary messages.
+     */
+    async reloadFromStorage() {
+        if (!this.historyStorage)
+            return;
+        await this.mutex.withLock(async () => {
+            try {
+                const history = await this.historyStorage.loadHistory(this.sessionId);
+                this.messages = history ?? [];
+                this.persistedCount = this.messages.length;
+                this.persistDirty = false;
+            }
+            catch (error) {
+                this.logger.error('Failed to reload history from storage', { error, sessionId: this.sessionId });
+            }
+        });
+    }
     /**
      * Update a tool call's state.
      * Used for transitioning through pending → running → completed/error.
@@ -379,33 +457,35 @@ export class ContextManager {
      * @param callId - ID of the tool call to update
      * @param stateUpdate - New state
      */
-    updateToolCallState(callId, stateUpdate) {
-        // Find the tool part with this callId
-        for (let msgIdx = this.messages.length - 1; msgIdx >= 0; msgIdx--) {
-            const message = this.messages[msgIdx];
-            if (!Array.isArray(message.content))
-                continue;
-            for (let partIdx = 0; partIdx < message.content.length; partIdx++) {
-                const part = message.content[partIdx];
-                if (part.type === 'tool' && part.callId === callId) {
-                    // Update the tool part state
-                    const updatedPart = {
-                        ...part,
-                        state: stateUpdate,
-                    };
-                    // Create new content array with updated part
-                    const newContent = [...message.content];
-                    newContent[partIdx] = updatedPart;
-                    // Update the message
-                    this.messages[msgIdx] = {
-                        ...message,
-                        content: newContent,
-                    };
-                    return;
+    async updateToolCallState(callId, stateUpdate) {
+        await this.mutex.withLock(async () => {
+            // Find the tool part with this callId
+            for (let msgIdx = this.messages.length - 1; msgIdx >= 0; msgIdx--) {
+                const message = this.messages[msgIdx];
+                if (!Array.isArray(message.content))
+                    continue;
+                for (let partIdx = 0; partIdx < message.content.length; partIdx++) {
+                    const part = message.content[partIdx];
+                    if (part.type === 'tool' && part.callId === callId) {
+                        // Update the tool part state
+                        const updatedPart = {
+                            ...part,
+                            state: stateUpdate,
+                        };
+                        // Create new content array with updated part
+                        const newContent = [...message.content];
+                        newContent[partIdx] = updatedPart;
+                        // Update the message
+                        this.messages[msgIdx] = {
+                            ...message,
+                            content: newContent,
+                        };
+                        return;
+                    }
                 }
             }
-        }
-        this.logger.warn('Tool call not found for state update', { callId, sessionId: this.sessionId });
+            this.logger.warn('Tool call not found for state update', { callId, sessionId: this.sessionId });
+        });
     }
     // ==================== PRIVATE METHODS ====================
     /**
@@ -513,6 +593,43 @@ export class ContextManager {
             .join('\n');
         return this.tokenizer.countTokens(text);
     }
+    /**
+     * Execute a persistence operation with exponential backoff retry logic.
+     */
+    async executeWithRetry(operation) {
+        const { baseDelayMs, maxRetries, multiplier } = this.persistenceRetry;
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                await operation();
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < maxRetries) {
+                    const delay = baseDelayMs * multiplier ** (attempt - 1);
+                    this.logger.warn(`Persistence attempt ${attempt}/${maxRetries} failed, retrying in ${delay}ms`, {
+                        error: lastError.message,
+                        sessionId: this.sessionId,
+                    });
+                    // eslint-disable-next-line no-await-in-loop
+                    await this.sleep(delay);
+                }
+            }
+        }
+        this.logger.error(`Persistence failed after ${maxRetries} attempts`, {
+            error: lastError?.message,
+            sessionId: this.sessionId,
+        });
+        if (this.onPersistenceFailed && lastError) {
+            this.onPersistenceFailed({
+                attempts: maxRetries,
+                error: lastError,
+                sessionId: this.sessionId,
+            });
+        }
+    }
     /**
      * Find the index of the last assistant message.
      *
@@ -538,7 +655,7 @@ export class ContextManager {
     }
     /**
      * Persist current conversation history to storage with retry logic.
-     * This is called automatically after each message is added.
+     * This is the full-save fallback path — saves the entire message array.
      *
      * Uses exponential backoff for retries:
      * - Attempt 1: immediate
@@ -553,43 +670,31 @@ export class ContextManager {
         if (!this.historyStorage) {
             return;
         }
-        const { baseDelayMs, maxRetries, multiplier } = this.persistenceRetry;
-        let lastError;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                // Store InternalMessage directly (no conversion needed)
-                // eslint-disable-next-line no-await-in-loop
-                await this.historyStorage.saveHistory(this.sessionId, this.messages);
-                return; // Success - exit early
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (attempt < maxRetries) {
-                    // Calculate exponential backoff delay
-                    const delay = baseDelayMs * multiplier ** (attempt - 1);
-                    this.logger.warn(`Persistence attempt ${attempt}/${maxRetries} failed, retrying in ${delay}ms`, {
-                        error: lastError.message,
-                        sessionId: this.sessionId,
-                    });
-                    // Wait before next retry
-                    // eslint-disable-next-line no-await-in-loop
-                    await this.sleep(delay);
-                }
-            }
-        }
-        // All retries exhausted
-        this.logger.error(`Persistence failed after ${maxRetries} attempts`, {
-            error: lastError?.message,
-            sessionId: this.sessionId,
+        await this.executeWithRetry(async () => {
+            await this.historyStorage.saveHistory(this.sessionId, this.messages);
+            this.persistedCount = this.messages.length;
+            this.persistDirty = false;
         });
-        // Invoke callback if configured
-        if (this.onPersistenceFailed && lastError) {
-            this.onPersistenceFailed({
-                attempts: maxRetries,
-                error: lastError,
-                sessionId: this.sessionId,
-            });
+    }
+    /**
+     * Persist a single message incrementally.
+     * Falls back to full saveHistory() if in-memory state has diverged from storage.
+     *
+     * @param message - The single message to persist
+     */
+    async persistMessage(message) {
+        if (!this.historyStorage) {
+            return;
         }
+        if (this.persistDirty) {
+            // In-memory diverged from storage (e.g. after compressMessage) — full sync needed
+            await this.persistHistory();
+            return;
+        }
+        await this.executeWithRetry(async () => {
+            await this.historyStorage.appendMessage(this.sessionId, message);
+            this.persistedCount++;
+        });
     }
     /**
      * Sanitize tool result for storage.