centaurus-cli 2.9.9 → 3.0.1

package/dist/cli-adapter.js

@@ -106,6 +106,7 @@ export class CentaurusCLI {
     onBackgroundTaskViewCallback;
     onTokenCountUpdate; // Report actual AI context token count to UI
     currentTokenCount = 0; // Track current token count for context limit checking
+    tokenCountUpdateVersion = 0; // Guards against stale async token count updates
     contextLimitReached = false; // Track if context limit has been reached
     onContextLimitReached; // Notify UI about context limit state
     onSessionQuotaUpdate;
@@ -129,6 +130,13 @@ export class CentaurusCLI {
     learnedWorkflowSteps = [];
     // Callback to set input value (e.g., for revert)
     onSetInputCallback = null;
+    // Interrupt Queue state tracking
+    interruptQueue = [];
+    onInterruptQueueUpdateCallback;
+    onQueuedMessageDispatchedCallback;
+    static INTERRUPT_SYSTEM_NOTE_PREFIX = '[SYSTEM NOTE: The user interrupted you with the following message. Please address it, adjust your actions, and proceed with the task.]';
+    // Track if we are currently reconnecting to remote sessions (prevent race conditions)
+    isReconnecting = false;
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -243,6 +251,12 @@ export class CentaurusCLI {
     setOnWorkflowSave(callback) {
         this.onWorkflowSaveCallback = callback;
     }
+    setOnInterruptQueueUpdate(callback) {
+        this.onInterruptQueueUpdateCallback = callback;
+    }
+    setOnQueuedMessageDispatched(callback) {
+        this.onQueuedMessageDispatchedCallback = callback;
+    }
     setOnAiAutoSuggestChange(callback) {
         this.onAiAutoSuggestChange = callback;
     }
@@ -257,7 +271,7 @@ export class CentaurusCLI {
             return [];
         return this.checkpointManager.list().map(cp => ({
             id: cp.id,
-            prompt: cp.prompt,
+            prompt: this.normalizePromptForInputBar(cp.prompt),
             timestamp: new Date(cp.createdAt)
         }));
     }
@@ -400,10 +414,8 @@ Begin executing now, starting with Step 1.`;
             }
             // Check if we are already in a remote session
             const currentContext = this.contextManager.getCurrentContext();
+            // Setup variables for the new context
             let context;
-            // Save current CWD to stack BEFORE entering any new session (local or nested)
-            // This enables proper restoration when exiting, regardless of nesting level
-            this.cwdStack.push(this.cwd);
             if (currentContext.type !== 'local') {
                 // Nested session: connect from remote
                 if (detection.handler.connectFromRemote) {
@@ -411,23 +423,18 @@ Begin executing now, starting with Step 1.`;
                     context = await detection.handler.connectFromRemote(command, this.cwd, currentContext);
                 }
                 else {
-                    // If nested connection fails, pop the CWD we just pushed
-                    this.cwdStack.pop();
                     throw new Error(`Nested connections are not supported by the ${type} handler yet.`);
                 }
             }
             else {
                 // Local session: connect from local
-                // For SSH, we shouldn't pass the local (potentially Windows) CWD as it won't exist remotely.
-                // For local->WSL or local->Docker, the handler might translate it, but strictly speaking
-                // starting 'fresh' in the remote user's home/default dir is safer for 'warpify' semantics regardless of type.
-                // However, to avoid regression for WSL/Docker usage where inheritance is expected, we restricts this fix to SSH.
                 const initialCwd = type === 'ssh' ? undefined : this.cwd;
-                // Use factory method to create a new handler instance for this session
-                // This prevents state issues where the singleton handler's client is overwritten by nested sessions
                 const newHandler = detection.handler.createNew();
                 context = await newHandler.connect(command, initialCwd);
             }
+            // Connection succeeded! Now we can safely mutate the stacks.
+            // Save current CWD to stack BEFORE entering the new session state (local or nested)
+            this.cwdStack.push(this.cwd);
             this.connectionCommandStack.push(command);
             this.contextManager.pushContext(context);
             // Explicitly sync this.cwd with the new context's CWD to ensure consistency immediately
@@ -607,6 +614,16 @@ Begin executing now, starting with Step 1.`;
             this.currentInteractiveProcess = undefined;
         }
     }
+    normalizePromptForInputBar(prompt) {
+        if (!prompt)
+            return '';
+        if (prompt.startsWith(CentaurusCLI.INTERRUPT_SYSTEM_NOTE_PREFIX)) {
+            return prompt
+                .slice(CentaurusCLI.INTERRUPT_SYSTEM_NOTE_PREFIX.length)
+                .trimStart();
+        }
+        return prompt;
+    }
     /**
      * Calculate and update token count based on current conversation history
      * This ensures UI is always in sync with the actual AI context
@@ -615,6 +632,7 @@ Begin executing now, starting with Step 1.`;
     async updateTokenCount() {
         if (!this.onTokenCountUpdate)
             return;
+        const updateVersion = ++this.tokenCountUpdateVersion;
         try {
             // Get current model
             const currentModel = this.configManager.get('modelName') || 'gemini-2.5-flash';
@@ -624,6 +642,10 @@ Begin executing now, starting with Step 1.`;
             const messagesForCounting = [...this.conversationHistory];
             // Call backend API for accurate token counting
             const tokenCount = await apiClient.countTokens(currentModel, messagesForCounting);
+            if (updateVersion !== this.tokenCountUpdateVersion) {
+                quickLog(`[${new Date().toISOString()}] [updateTokenCount] Ignored stale token count update\n`);
+                return;
+            }
             // Store locally for context limit checking
             this.currentTokenCount = tokenCount;
             // Update UI with accurate count
@@ -636,6 +658,9 @@ Begin executing now, starting with Step 1.`;
             quickLog(`[${new Date().toISOString()}] [updateTokenCount] ${logMsg}`);
         }
         catch (error) {
+            if (updateVersion !== this.tokenCountUpdateVersion) {
+                return;
+            }
             // Fallback to character-based estimation if API fails
             const SYSTEM_PROMPT_ESTIMATE = 14000; // Backend injects ~14K char system prompt
             // Calculate total characters from conversation history
@@ -1081,6 +1106,11 @@ Press Enter to continue...
             this.requestIntentionallyAborted = true;
             this.currentAbortController.abort();
             this.currentAbortController = undefined;
+            // Clear interrupt queue on hard cancel
+            this.interruptQueue = [];
+            if (this.onInterruptQueueUpdateCallback) {
+                this.onInterruptQueueUpdateCallback(this.interruptQueue);
+            }
         }
     }
     /**
@@ -1172,6 +1202,13 @@ Press Enter to continue...
         }
     }
     async handleMessage(message, options = {}) {
+        // Prevent messages from being processed while remote reconnection is ongoing
+        if (this.isReconnecting) {
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback('⏳ Please wait until the chat is fully reconnected before sending a message.');
+            }
+            return;
+        }
         // Handle command mode - execute commands directly
         if (this.commandMode) {
             // Record command step if workflow learning mode is active
@@ -1247,32 +1284,26 @@ Press Enter to continue...
         // Cancel any active request when a new message comes in
         // This enables "interrupt and replace" - new message takes priority
         if (this.currentAbortController) {
-            // Mark as intentionally aborted so error handling knows not to throw or show message
-            this.requestIntentionallyAborted = true;
-            const oldController = this.currentAbortController;
-            // Create new controller BEFORE aborting old one to avoid race condition
-            // where new request tries to access undefined controller
-            this.currentAbortController = new AbortController();
-            oldController.abort();
-            // Clean up orphaned tool calls from the interrupted turn
-            this.cleanupOrphanedToolCalls();
-            // Remove the last user message from history (it's being replaced by the new message)
-            // Walk backwards and remove messages until we find and remove a user message
-            while (this.conversationHistory.length > 0) {
-                const lastMsg = this.conversationHistory[this.conversationHistory.length - 1];
-                this.conversationHistory.pop();
-                if (lastMsg.role === 'user') {
-                    // Found and removed the interrupted user message, stop here
-                    break;
-                }
-                // Continue removing assistant/tool messages that were part of the interrupted turn
+            // INSTEAD of aborting, enqueue the message as an interrupt.
+            const queuedMessage = options.interruptCleanText || message;
+            this.interruptQueue.push(queuedMessage);
+            if (this.onInterruptQueueUpdateCallback) {
+                this.onInterruptQueueUpdateCallback(this.interruptQueue);
             }
-            quickLog(`[${new Date().toISOString()}] [handleMessage] Interrupted active request - cleaned up history for replacement\n`);
+            quickLog(`[${new Date().toISOString()}] [handleMessage] Added message to interrupt queue. Queue length: ${this.interruptQueue.length}\n`);
+            return;
         }
         // Store original request if in planning mode (for execution phase after approval)
         if (this.planMode && !this.pendingPlanRequest) {
             this.pendingPlanRequest = message;
         }
+        // Notify UI that this message is now actively being processed.
+        // Only fire for DIRECT (non-queued) messages here.
+        // For queued interrupts, the finally block fires this BEFORE calling handleMessage,
+        // so we must not fire it again here — that would cause the user bubble to appear twice.
+        if (!options.interruptCleanText && this.onQueuedMessageDispatchedCallback) {
+            this.onQueuedMessageDispatchedCallback(message);
+        }
         // Build the user message content - inject plan mode instructions if active
         let userMessageContent = message;
         // When plan mode is active, explicitly inject planning instructions into the user message
@@ -1297,19 +1328,32 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
         // This clears thinking from the previous agent loop but thinking will be
         // preserved for all turns within the current agent loop
         this.stripThinkingFromHistory();
-        // Add user message to history
+        // Add user message to history, using clean text if it's an interrupt
+        const messageToStore = options.interruptCleanText || userMessageContent;
         this.conversationHistory.push({
             role: 'user',
-            content: userMessageContent,
+            content: messageToStore,
         });
+        // Capture the abort controller for THIS request locally so we are entirely immune to race conditions
+        if (!this.currentAbortController) {
+            this.currentAbortController = new AbortController();
+        }
+        const myAbortController = this.currentAbortController;
         // Calculate start index for AI context (0 for normal, current index for isolated workflow)
         const contextStartIndex = options.isolatedWorkflow ? this.conversationHistory.length - 1 : 0;
         // Helper to get messages for AI context respecting isolation
         const getMessagesForContext = () => {
-            if (options.isolatedWorkflow) {
-                return this.conversationHistory.slice(contextStartIndex);
+            const msgs = options.isolatedWorkflow ? this.conversationHistory.slice(contextStartIndex) : [...this.conversationHistory];
+            // If this is an interrupt, we must ensure the AI sees the wrapped message for this specific turn
+            if (options.interruptCleanText && msgs.length > 0) {
+                // Swap the last user message's content with the wrapped message just for the AI request
+                const lastMsg = msgs[msgs.length - 1];
+                if (lastMsg.role === 'user') {
+                    // We map over to not mutate the original history array object
+                    msgs[msgs.length - 1] = { ...lastMsg, content: userMessageContent };
+                }
             }
-            return [...this.conversationHistory];
+            return msgs;
         };
         // Messages are stored locally only - no backend persistence needed
         // Local storage is handled by saveCurrentChat() which saves to ~/.centaurus/chats/
@@ -1351,8 +1395,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 }
             }
             try {
+                const checkpointPrompt = options.interruptCleanText || message;
                 const checkpointStartPromise = this.checkpointManager.startCheckpoint({
-                    prompt: message,
+                    prompt: checkpointPrompt,
                     cwd: this.cwd,
                     contextType: currentContext.type,
                     conversationIndex: this.conversationHistory.length - 1,
@@ -1556,16 +1601,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 });
                 // Stream AI response from backend
                 // Backend will inject system prompt automatically with environment context
-                for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode, selectedModelThinkingConfig, this.currentAbortController?.signal)) {
+                for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode, selectedModelThinkingConfig, myAbortController.signal)) {
                     // Handle error chunks
                     if (chunk.type === 'error') {
                         // Check if this is an abort situation (user cancelled or sent new message)
-                        if (chunk.code === 'TIMEOUT' && this.requestIntentionallyAborted) {
-                            // Reset the flag
-                            this.requestIntentionallyAborted = false;
-                            // Clean up orphaned tool_calls from conversation history
-                            // This prevents 400 Bad Request errors when assistant has tool_calls without matching tool results
-                            this.cleanupOrphanedToolCalls();
+                        if (chunk.code === 'TIMEOUT' && myAbortController.isIntentionalAbort) {
+                            if (!myAbortController.isReplacement) {
+                                // Clean up orphaned tool_calls from conversation history only if NOT a replacement.
+                                // If it's a replacement, the newer handleMessage already cleaned up before starting.
+                                this.cleanupOrphanedToolCalls();
+                            }
                             // Gracefully exit - request was intentionally cancelled
                             return;
                         }
@@ -2389,18 +2434,18 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         }
                         catch (e) { }
                         this.conversationHistory.push(assistantHistoryMsg);
-                    }
-                    // Add tool results to conversation history as tool messages
-                    // Format: { tool_call_id, name, result: <object or string> }
-                    // Only add results for unhandled tool calls (handled ones already added their own results)
-                    for (const toolResult of unhandledToolResults) {
-                        // Add tool result to conversation history as tool message
-                        // IMPORTANT: tool_call_id must be a top-level property
-                        this.conversationHistory.push({
-                            role: 'tool',
-                            tool_call_id: toolResult.tool_call_id,
-                            content: typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result),
-                        });
+                        // Add tool results to conversation history as tool messages
+                        // Format: { tool_call_id, name, result: <object or string> }
+                        // Only add results for unhandled tool calls (handled ones already added their own results)
+                        for (const toolResult of unhandledToolResults) {
+                            // Add tool result to conversation history as tool message
+                            // IMPORTANT: tool_call_id must be a top-level property
+                            this.conversationHistory.push({
+                                role: 'tool',
+                                tool_call_id: toolResult.tool_call_id,
+                                content: typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result),
+                            });
+                        }
                     }
                     // Rebuild messages array with updated history
                     // During agent loop: keep ALL thinking for current task
@@ -2409,6 +2454,77 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     // No need to reset currentTurnThinking - keep accumulating for the task
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
+                    // ── Mid-turn interrupt check ──────────────────────────────────
+                    // If the user sent a message while this turn was executing, inject
+                    // it into the conversation now so the AI sees it on the very next
+                    // turn — instead of waiting for the entire multi-turn task to end.
+                    if (this.interruptQueue.length > 0) {
+                        const nextInterrupt = this.interruptQueue.shift();
+                        // Update queue UI
+                        if (this.onInterruptQueueUpdateCallback) {
+                            this.onInterruptQueueUpdateCallback(this.interruptQueue);
+                        }
+                        // Notify App.tsx to add the user bubble to messageHistory
+                        if (this.onQueuedMessageDispatchedCallback) {
+                            this.onQueuedMessageDispatchedCallback(nextInterrupt);
+                        }
+                        quickLog(`[${new Date().toISOString()}] [handleMessage] Processing mid-turn interrupt from user.\n`);
+                        // Create a checkpoint for this interrupt so it appears in /revert.
+                        // Store the clean user text (without system wrapper) for autocomplete/input prefill.
+                        if (this.checkpointManager && this.currentChatId) {
+                            try {
+                                const checkpointContext = this.contextManager.getCurrentContext();
+                                let remoteSessionInfo;
+                                let remoteHandler;
+                                if (checkpointContext.type !== 'local' && checkpointContext.handler) {
+                                    const metadata = checkpointContext.metadata;
+                                    remoteSessionInfo = {
+                                        hostname: metadata.hostname,
+                                        username: metadata.username,
+                                        sessionId: checkpointContext.sessionId,
+                                        connectionString: metadata.hostname
+                                            ? `${metadata.username || 'user'}@${metadata.hostname}`
+                                            : metadata.distroName || metadata.containerId || undefined,
+                                    };
+                                    if (typeof checkpointContext.handler.readFile === 'function' &&
+                                        typeof checkpointContext.handler.writeFile === 'function' &&
+                                        typeof checkpointContext.handler.executeCommand === 'function' &&
+                                        typeof checkpointContext.handler.isConnected === 'function') {
+                                        remoteHandler = checkpointContext.handler;
+                                    }
+                                }
+                                // conversationIndex points to the next message slot (the interrupt user message).
+                                const interruptCheckpoint = await this.checkpointManager.startCheckpoint({
+                                    prompt: nextInterrupt,
+                                    cwd: this.cwd,
+                                    contextType: checkpointContext.type,
+                                    conversationIndex: this.conversationHistory.length,
+                                    remoteSessionInfo,
+                                    handler: remoteHandler,
+                                });
+                                if (interruptCheckpoint) {
+                                    this.currentCheckpointId = interruptCheckpoint.id;
+                                    context.currentCheckpointId = interruptCheckpoint.id;
+                                    quickLog(`[${new Date().toISOString()}] [Checkpoint] Started mid-turn checkpoint ${interruptCheckpoint.id} for interrupt: "${nextInterrupt.slice(0, 50)}..."\n`);
+                                }
+                            }
+                            catch (checkpointError) {
+                                quickLog(`[${new Date().toISOString()}] [Checkpoint] Failed to create mid-turn interrupt checkpoint: ${checkpointError?.message || checkpointError}\n`);
+                            }
+                        }
+                        // Wrap the interrupt with context for the AI
+                        const wrappedInterrupt = `[SYSTEM NOTE: The user interrupted you with the following message. Please address it, adjust your actions, and proceed with the task.]\n\n${nextInterrupt}`;
+                        // Push the interrupt into conversation history so the AI
+                        // receives both the tool results from THIS turn and the
+                        // user's new message together on the next AI call.
+                        this.conversationHistory.push({
+                            role: 'user',
+                            content: wrappedInterrupt,
+                        });
+                        // Rebuild messages to include the interrupt
+                        messages = getMessagesForContext();
+                        messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
+                    }
                     continue; // Loop back to AI service
                 }
                 else {
@@ -2515,11 +2631,10 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             // Log the error
             conversationLogger.logError('handleMessage', error);
             // Check if this was an abort/cancellation (including timeout errors from aborted requests)
-            if (error.name === 'AbortError' || error.message?.includes('aborted') || error.message?.includes('timed out') || this.requestIntentionallyAborted) {
+            if (error.name === 'AbortError' || error.message?.includes('aborted') || error.message?.includes('timed out') || myAbortController.isIntentionalAbort) {
                 // If intentionally aborted for replacement by new message, return silently
                 // The new message will take over - no need to show cancellation message
-                if (this.requestIntentionallyAborted) {
-                    this.requestIntentionallyAborted = false;
+                if (myAbortController.isIntentionalAbort && myAbortController.isReplacement) {
                     return;
                 }
                 conversationLogger.logError('handleMessage', new Error('Request cancelled by user'));
@@ -2544,6 +2659,29 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             }
             // Clean up abort controller
             this.currentAbortController = undefined;
+            // Process any queued interrupts if the task wasn't aborted intentionally
+            if (this.interruptQueue.length > 0 && !this.requestIntentionallyAborted) {
+                // We aren't checking `myAbortController.isIntentionalAbort` here because we don't set it anymore
+                // Next message in queue
+                const nextInterrupt = this.interruptQueue.shift();
+                if (this.onInterruptQueueUpdateCallback) {
+                    this.onInterruptQueueUpdateCallback(this.interruptQueue);
+                }
+                // Notify UI that this queued message is now being dispatched for processing.
+                // App.tsx uses this to add the user message to messageHistory at the correct time
+                // (i.e., when the message actually starts being processed, not when it was first queued).
+                if (this.onQueuedMessageDispatchedCallback) {
+                    this.onQueuedMessageDispatchedCallback(nextInterrupt);
+                }
+                quickLog(`[${new Date().toISOString()}] [handleMessage] Processing queued interrupt from user.\n`);
+                const wrappedMessage = `[SYSTEM NOTE: The user interrupted you with the following message. Please address it, adjust your actions, and proceed with the task.]\n\n${nextInterrupt}`;
+                // Start next message processing asynchronously so we don't block finally block returning
+                setTimeout(() => {
+                    this.handleMessage(wrappedMessage, { interruptCleanText: nextInterrupt }).catch(err => {
+                        conversationLogger.logError('Queued interrupt handleMessage', err);
+                    });
+                }, 0);
+            }
         }
     }
     async handleSlashCommand(command) {
@@ -3306,9 +3444,10 @@ Then try /models local again.`;
                     // Truncate conversation history to the checkpoint
                     if (checkpointIndex >= 0) {
                         const checkpoint = result.checkpoint;
+                        const checkpointPromptForUi = this.normalizePromptForInputBar(checkpoint.prompt);
                         // Populate the input bar with the reverted prompt
                         if (this.onSetInputCallback) {
-                            this.onSetInputCallback(checkpoint.prompt);
+                            this.onSetInputCallback(checkpointPromptForUi);
                         }
                         // Use conversationIndex from metadata if available (robust)
                         // This avoids issues with duplicate prompts getting truncated at the wrong occurrence
@@ -3322,7 +3461,7 @@ Then try /models local again.`;
                         }
                         else {
                             // Fallback to string matching (legacy or missing index)
-                            const targetPrompt = checkpoint.prompt;
+                            const targetPrompt = checkpointPromptForUi;
                             // Find the user message with this prompt in conversationHistory
                             let foundIndex = -1;
                             // Use a broader search to find the matching message
@@ -3355,7 +3494,7 @@ Then try /models local again.`;
                         }
                         else {
                             // Fallback to string matching (legacy or missing index)
-                            const targetPrompt = checkpoint.prompt;
+                            const targetPrompt = checkpointPromptForUi;
                             const searchPrompt = targetPrompt.slice(0, 50);
                             let foundUiIndex = -1;
                             for (let i = 0; i < this.uiMessageHistory.length; i++) {
@@ -3371,15 +3510,20 @@ Then try /models local again.`;
                                 quickLog(`[${new Date().toISOString()}] [Revert] Truncated UI message history to index ${foundUiIndex} (exclusive, using string match)\n`);
                             }
                         }
+                        // Recompute token count from the truncated history.
+                        // This keeps the context indicator in sync even before any follow-up prompt.
+                        await this.updateTokenCount().catch(err => {
+                            quickLog(`[${new Date().toISOString()}] [Revert] Failed to update token count after revert: ${err}\n`);
+                        });
                         // Remove the reverted checkpoint AND all checkpoints created after it
                         // They should not appear in autocomplete anymore
                         this.checkpointManager.removeCheckpointsFrom(checkpointArg);
                         // Build the success message BEFORE calling handleChatPickerSelection
                         // This will be passed as a parameter and included in the same React setState call
                         quickLog(`[${new Date().toISOString()}] [Revert] Building success message for checkpoint "${checkpointArg}"\n`);
-                        const truncatedPrompt = result.checkpoint.prompt.length > 50
-                            ? result.checkpoint.prompt.slice(0, 50) + '...'
-                            : result.checkpoint.prompt;
+                        const truncatedPrompt = checkpointPromptForUi.length > 50
+                            ? checkpointPromptForUi.slice(0, 50) + '...'
+                            : checkpointPromptForUi;
                         let revertSuccessMessage = `✅ Reverted to: "${truncatedPrompt}"\n` +
                             `Restored ${result.restored} files, removed ${result.removed} files.`;
                         if (result.errors.length > 0) {
@@ -3389,7 +3533,7 @@ Then try /models local again.`;
                         if (this.currentChatId) {
                             quickLog(`[${new Date().toISOString()}] [Revert] Saving truncated chat to disk (chatId: ${this.currentChatId})\n`);
                             quickLog(`[${new Date().toISOString()}] [Revert] uiMessageHistory.length BEFORE save: ${this.uiMessageHistory.length}\n`);
-                            this.saveCurrentChat();
+                            this.saveCurrentChat({ allowEmpty: true });
                             // Reload the chat to force UI update ensures consistency
                             // This simulates a /chat resume command which correctly populates the UI
                             // Pass skipLoadedMessage=true and the revert success message
@@ -3641,7 +3785,12 @@ Create once, run many times across different machines.`;
                             const workflowPrompt = this.buildWorkflowPrompt(workflow);
                             // Use setTimeout to allow the UI to update before starting execution
                             setTimeout(() => {
-                                this.handleMessage(workflowPrompt, { isolatedWorkflow: true });
+                                this.handleMessage(workflowPrompt, { isolatedWorkflow: true }).catch((err) => {
+                                    quickLog(`[${new Date().toISOString()}] [Workflow] Error executing workflow: ${err.message}\n`);
+                                    if (this.onDirectMessageCallback) {
+                                        this.onDirectMessageCallback(`❌ Error executing workflow: ${err.message}`);
+                                    }
+                                });
                             }, 100);
                             return;
                         }
@@ -4182,13 +4331,19 @@ Create once, run many times across different machines.`;
     /**
      * Save current conversation to local storage
      */
-    saveCurrentChat() {
-        // Only save if there are messages (AI conversation or shell commands)
-        if (this.conversationHistory.length === 0) {
+    saveCurrentChat(options) {
+        const allowEmpty = options?.allowEmpty ?? false;
+        // Only save if there are messages (AI conversation or shell commands),
+        // unless explicitly forced (revert-to-first-message edge case).
+        if (this.conversationHistory.length === 0 && !allowEmpty) {
             return;
         }
         // Generate chat ID if not exists
         if (!this.currentChatId) {
+            if (allowEmpty) {
+                // Avoid creating brand-new empty chats.
+                return;
+            }
             this.currentChatId = localChatStorage.generateChatId();
         }
         // Convert to StoredMessage format (AI context)
@@ -4403,9 +4558,10 @@ Create once, run many times across different machines.`;
         // Restore UI messages if available
         quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] chat.uiMessages exists: ${!!chat.uiMessages}, length: ${chat.uiMessages?.length ?? 0}\n`);
         quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] onRestoreMessagesCallback exists: ${!!this.onRestoreMessagesCallback}\n`);
-        if (chat.uiMessages && chat.uiMessages.length > 0 && this.onRestoreMessagesCallback) {
+        if (this.onRestoreMessagesCallback) {
+            const sourceUiMessages = chat.uiMessages ?? [];
             // Convert StoredUIMessage back to Message format
-            const restoredMessages = chat.uiMessages.map(msg => ({
+            const restoredMessages = sourceUiMessages.map(msg => ({
                 id: msg.id,
                 role: msg.role,
                 content: msg.content,
@@ -4434,6 +4590,45 @@ Create once, run many times across different machines.`;
                 restoredMessages.push(revertSystemMessage);
                 quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] Appended revert success message, restoredMessages.length: ${restoredMessages.length}\n`);
             }
+            // Determine if this is a remote chat that needs reconnection
+            const pendingContextStack = shouldPreserveRemote
+                ? null
+                : (chat.remoteContextStack ?? (chat.remoteContext ? [chat.remoteContext] : null));
+            const hasRemoteContext = pendingContextStack && pendingContextStack.length > 0;
+            // IMPORTANT: Append the "Loaded chat" or "Reconnecting" status message to restoredMessages
+            // BEFORE calling onRestoreMessagesCallback. This prevents the message from being added
+            // separately via onDirectMessageCallback between the two-phase restore (Phase 1: clear,
+            // Phase 2: 50ms delayed restore), which would cause Ink's Static component to increment
+            // its rendered count and skip the first restored message.
+            if (!skipLoadedMessage && !revertSuccessMessage) {
+                if (hasRemoteContext) {
+                    // For remote chats, include the reconnection notification
+                    const nestingInfo = pendingContextStack.length > 1
+                        ? ` (${pendingContextStack.length} levels: ${pendingContextStack.map((c) => c.type).join(' > ')})`
+                        : '';
+                    const reconnectMessage = {
+                        id: `reconnect-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+                        role: 'assistant',
+                        content: `🔄 Reconnecting to session${nestingInfo}...`,
+                        timestamp: new Date(),
+                        shouldStream: false,
+                    };
+                    restoredMessages.push(reconnectMessage);
+                    quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] Appended reconnect message to restoredMessages\n`);
+                }
+                else {
+                    // For local chats, include the "Loaded chat" confirmation
+                    const loadedMessage = {
+                        id: `loaded-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+                        role: 'assistant',
+                        content: `✅ Loaded chat: "${chat.title}"\n\nYou have ${chat.messageCount} messages in AI context. Continue your conversation!`,
+                        timestamp: new Date(),
+                        shouldStream: false,
+                    };
+                    restoredMessages.push(loadedMessage);
+                    quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] Appended loaded chat message to restoredMessages\n`);
+                }
+            }
             quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] Calling onRestoreMessagesCallback with ${restoredMessages.length} messages\n`);
             this.onRestoreMessagesCallback(restoredMessages);
             quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] onRestoreMessagesCallback completed\n`);
@@ -4449,123 +4644,132 @@ Create once, run many times across different machines.`;
             // Initialize stacks
             this.cwdStack = [baseLocalCwd];
             this.connectionCommandStack = [];
-            // Show initial reconnection notification
+            // Note: The initial "Reconnecting to session..." notification is now included
+            // in the restoredMessages array (if uiMessages were restored) to avoid Ink's Static
+            // component count desync. Only show via onDirectMessageCallback if no UI restore happened.
             const nestingInfo = contextStackToRestore.length > 1
                 ? ` (${contextStackToRestore.length} levels: ${contextStackToRestore.map(c => c.type).join(' > ')})`
                 : '';
-            if (this.onDirectMessageCallback) {
+            if (this.onDirectMessageCallback && !this.onRestoreMessagesCallback) {
                 this.onDirectMessageCallback(`🔄 Reconnecting to session${nestingInfo}...`);
             }
-            // Sequential reconnection through the stack
-            let previousCwd = baseLocalCwd;
-            for (let i = 0; i < contextStackToRestore.length; i++) {
-                const remoteCtx = contextStackToRestore[i];
-                const { type, connectionCommand, remoteCwd } = remoteCtx;
-                const levelInfo = contextStackToRestore.length > 1 ? ` [${i + 1}/${contextStackToRestore.length}]` : '';
-                // Show connecting status for this level
-                if (this.onDirectMessageCallback) {
-                    this.onDirectMessageCallback(`🔄${levelInfo} Connecting to ${type.toUpperCase()}...`);
-                }
-                if (this.onConnectionStatusUpdate) {
-                    this.onConnectionStatusUpdate({
-                        type: type,
-                        status: 'connecting',
-                        connectionString: this.buildConnectionString(type, remoteCtx.metadata)
-                    });
-                }
-                try {
-                    // Detect and connect using the saved command
-                    const detection = this.commandDetector.detect(connectionCommand);
-                    if (!detection) {
-                        throw new Error(`Could not detect handler for: ${connectionCommand}`);
-                    }
-                    // Create a new instance of the handler to ensure each level of the connection
-                    // has its own state (client, stream, etc.), critical for nested sessions of the same type
-                    const handler = detection.handler.createNew();
-                    let context;
-                    // Check if this is a nested connection (i > 0 means we're inside a remote session)
-                    if (i > 0) {
-                        const currentContext = this.contextManager.getCurrentContext();
-                        if (handler.connectFromRemote) {
-                            context = await handler.connectFromRemote(connectionCommand, previousCwd, currentContext);
-                        }
-                        else {
-                            throw new Error(`Nested connections not supported by ${type} handler`);
-                        }
-                    }
-                    else {
-                        // First level: connect from local
-                        context = await handler.connect(connectionCommand, previousCwd);
-                    }
-                    // Push to stacks
-                    this.connectionCommandStack.push(connectionCommand);
-                    if (i > 0) {
-                        this.cwdStack.push(previousCwd); // Save the previous remote CWD for nested exits
-                    }
-                    this.contextManager.pushContext(context);
-                    // Navigate to saved remote CWD
-                    if (remoteCwd && remoteCwd !== context.metadata.workingDirectory) {
-                        try {
-                            await this.contextManager.executeCommand(`cd "${remoteCwd}"`);
-                        }
-                        catch (cdError) {
-                            // Failed to cd to saved path - warn but continue
-                            if (this.onDirectMessageCallback) {
-                                this.onDirectMessageCallback(`⚠️ Could not restore ${type} directory: ${remoteCwd}`);
-                            }
-                        }
+            this.isReconnecting = true;
+            try {
+                // Sequential reconnection through the stack
+                let previousCwd = baseLocalCwd;
+                for (let i = 0; i < contextStackToRestore.length; i++) {
+                    const remoteCtx = contextStackToRestore[i];
+                    const { type, connectionCommand, remoteCwd } = remoteCtx;
+                    const levelInfo = contextStackToRestore.length > 1 ? ` [${i + 1}/${contextStackToRestore.length}]` : '';
+                    // Show connecting status for this level
+                    // Only show via onDirectMessageCallback if no UI restore happened (same reason as reconnecting message above)
+                    if (this.onDirectMessageCallback && !this.onRestoreMessagesCallback) {
+                        this.onDirectMessageCallback(`🔄${levelInfo} Connecting to ${type.toUpperCase()}...`);
                     }
-                    // Update previousCwd for next iteration
-                    previousCwd = this.contextManager.getCurrentContext().metadata.workingDirectory;
-                    // Show success for this level
                     if (this.onConnectionStatusUpdate) {
                         this.onConnectionStatusUpdate({
                             type: type,
-                            status: 'connected',
+                            status: 'connecting',
                             connectionString: this.buildConnectionString(type, remoteCtx.metadata)
                         });
                     }
-                }
-                catch (error) {
-                    // Connection failed at this level - fall back to local mode
-                    // If we partially connected, disconnect all and reset
-                    while (this.contextManager.getCurrentContext().type !== 'local') {
-                        const ctx = this.contextManager.getCurrentContext();
-                        if (ctx.handler) {
+                    try {
+                        // Detect and connect using the saved command
+                        const detection = this.commandDetector.detect(connectionCommand);
+                        if (!detection) {
+                            throw new Error(`Could not detect handler for: ${connectionCommand}`);
+                        }
+                        // Create a new instance of the handler to ensure each level of the connection
+                        // has its own state (client, stream, etc.), critical for nested sessions of the same type
+                        const handler = detection.handler.createNew();
+                        let context;
+                        // Check if this is a nested connection (i > 0 means we're inside a remote session)
+                        if (i > 0) {
+                            const currentContext = this.contextManager.getCurrentContext();
+                            if (handler.connectFromRemote) {
+                                context = await handler.connectFromRemote(connectionCommand, previousCwd, currentContext);
+                            }
+                            else {
+                                throw new Error(`Nested connections not supported by ${type} handler`);
+                            }
+                        }
+                        else {
+                            // First level: connect from local
+                            context = await handler.connect(connectionCommand, previousCwd);
+                        }
+                        // Push to stacks
+                        this.connectionCommandStack.push(connectionCommand);
+                        if (i > 0) {
+                            this.cwdStack.push(previousCwd); // Save the previous remote CWD for nested exits
+                        }
+                        this.contextManager.pushContext(context);
+                        // Navigate to saved remote CWD
+                        if (remoteCwd && remoteCwd !== context.metadata.workingDirectory) {
                             try {
-                                await ctx.handler.disconnect();
+                                await this.contextManager.executeCommand(`cd "${remoteCwd}"`);
+                            }
+                            catch (cdError) {
+                                // Failed to cd to saved path - warn but continue
+                                if (this.onDirectMessageCallback) {
+                                    this.onDirectMessageCallback(`⚠️ Could not restore ${type} directory: ${remoteCwd}`);
+                                }
                             }
-                            catch (e) { /* ignore */ }
                         }
-                        this.contextManager.popContext();
+                        // Update previousCwd for next iteration
+                        previousCwd = this.contextManager.getCurrentContext().metadata.workingDirectory;
+                        // Show success for this level
+                        if (this.onConnectionStatusUpdate) {
+                            this.onConnectionStatusUpdate({
+                                type: type,
+                                status: 'connected',
+                                connectionString: this.buildConnectionString(type, remoteCtx.metadata)
+                            });
+                        }
                     }
-                    this.cwdStack = [];
-                    this.connectionCommandStack = [];
-                    if (this.onConnectionStatusUpdate) {
-                        this.onConnectionStatusUpdate({
-                            type: type,
-                            status: 'error',
-                            connectionString: this.buildConnectionString(type, remoteCtx.metadata),
-                            error: error.message
-                        });
+                    catch (error) {
+                        // Connection failed at this level - fall back to local mode
+                        // If we partially connected, disconnect all and reset
+                        while (this.contextManager.getCurrentContext().type !== 'local') {
+                            const ctx = this.contextManager.getCurrentContext();
+                            if (ctx.handler) {
+                                try {
+                                    await ctx.handler.disconnect();
+                                }
+                                catch (e) { /* ignore */ }
+                            }
+                            this.contextManager.popContext();
+                        }
+                        this.cwdStack = [];
+                        this.connectionCommandStack = [];
+                        if (this.onConnectionStatusUpdate) {
+                            this.onConnectionStatusUpdate({
+                                type: type,
+                                status: 'error',
+                                connectionString: this.buildConnectionString(type, remoteCtx.metadata),
+                                error: error.message
+                            });
+                        }
+                        const failedAt = contextStackToRestore.length > 1 ? ` at level ${i + 1} (${type})` : '';
+                        if (this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(`⚠️ Loaded chat: "${chat.title}"\n\n❌ Could not reconnect${failedAt}: ${error.message}\n\n📁 Restored to local directory: ${baseLocalCwd}`);
+                        }
+                        return;
                     }
-                    const failedAt = contextStackToRestore.length > 1 ? ` at level ${i + 1} (${type})` : '';
-                    if (this.onDirectMessageCallback) {
-                        this.onDirectMessageCallback(`⚠️ Loaded chat: "${chat.title}"\n\n❌ Could not reconnect${failedAt}: ${error.message}\n\n📁 Restored to local directory: ${baseLocalCwd}`);
+                }
+                // All levels connected successfully
+                if (this.onDirectMessageCallback) {
+                    const successInfo = contextStackToRestore.length > 1
+                        ? `🔗 Reconnected through ${contextStackToRestore.length} levels`
+                        : '';
+                    if (successInfo) {
+                        this.onDirectMessageCallback(successInfo);
                     }
-                    return;
                 }
+                return;
             }
-            // All levels connected successfully
-            if (this.onDirectMessageCallback) {
-                const successInfo = contextStackToRestore.length > 1
-                    ? `🔗 Reconnected through ${contextStackToRestore.length} levels`
-                    : '';
-                if (successInfo) {
-                    this.onDirectMessageCallback(successInfo);
-                }
+            finally {
+                this.isReconnecting = false;
             }
-            return;
         }
         // No remote context - show regular confirmation and restore CWD
         if (!shouldPreserveRemote && chat.cwd && !chat.remoteContext) {
@@ -4578,7 +4782,9 @@ Create once, run many times across different machines.`;
             }
         }
         // Skip loaded message if called from revert (to avoid React setState race condition)
-        if (this.onDirectMessageCallback && !skipLoadedMessage) {
+        // Also skip if we already included it in the restoredMessages array (when uiMessages were restored)
+        const uiMessagesWereRestored = !!this.onRestoreMessagesCallback;
+        if (this.onDirectMessageCallback && !skipLoadedMessage && !uiMessagesWereRestored) {
             const responseMessage = `✅ Loaded chat: "${chat.title}"\n\nYou have ${chat.messageCount} messages in AI context. Continue your conversation!`;
             this.onDirectMessageCallback(responseMessage);
         }