centaurus-cli 2.9.8 → 3.0.0

package/dist/cli-adapter.js

@@ -3,6 +3,7 @@ import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import * as shellUtils from './utils/shell.js';
+import { sanitizeForContext } from './utils/context-sanitizer.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { ConfigManager } from './config/manager.js';
@@ -128,6 +129,12 @@ export class CentaurusCLI {
     learnedWorkflowSteps = [];
     // Callback to set input value (e.g., for revert)
     onSetInputCallback = null;
+    // Interrupt Queue state tracking
+    interruptQueue = [];
+    onInterruptQueueUpdateCallback;
+    onQueuedMessageDispatchedCallback;
+    // Track if we are currently reconnecting to remote sessions (prevent race conditions)
+    isReconnecting = false;
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -242,6 +249,12 @@ export class CentaurusCLI {
     setOnWorkflowSave(callback) {
         this.onWorkflowSaveCallback = callback;
     }
+    setOnInterruptQueueUpdate(callback) {
+        this.onInterruptQueueUpdateCallback = callback;
+    }
+    setOnQueuedMessageDispatched(callback) {
+        this.onQueuedMessageDispatchedCallback = callback;
+    }
     setOnAiAutoSuggestChange(callback) {
         this.onAiAutoSuggestChange = callback;
     }
@@ -399,10 +412,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) {
@@ -410,23 +421,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
@@ -1080,6 +1086,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);
+            }
         }
     }
     /**
@@ -1171,6 +1182,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
@@ -1246,32 +1264,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
@@ -1296,19 +1308,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/
@@ -1555,16 +1580,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;
                         }
@@ -1711,10 +1736,14 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         parsedResult = result.result;
                                     }
                                 }
+                                // Sanitize context for AI consumption (strip ANSI, compact file writes)
+                                const sanitizedResult = sanitizeForContext(toolCall.name, parsedResult, toolCall.arguments);
+                                // Log the sanitized version for debugging purposes
+                                conversationLogger.logToolResult(`${toolCall.name} (SANITIZED_CONTEXT)`, toolCall.id, sanitizedResult, true);
                                 inStreamToolResults.push({
                                     tool_call_id: toolCall.id,
                                     name: toolCall.name,
-                                    result: this.truncateResult(parsedResult),
+                                    result: this.truncateResult(sanitizedResult),
                                 });
                             }
                             else {
@@ -2207,8 +2236,12 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         parsedResult = result.result;
                                     }
                                 }
+                                // Sanitize context for AI consumption (strip ANSI, compact file writes)
+                                const sanitizedResult = sanitizeForContext(toolCall.name, parsedResult, toolCall.arguments);
+                                // Log the sanitized version for debugging purposes
+                                conversationLogger.logToolResult(`${toolCall.name} (SANITIZED_CONTEXT)`, toolCall.id, sanitizedResult, true);
                                 // Truncate result before sending to AI (to avoid exceeding message size limits)
-                                const truncatedResult = this.truncateResult(parsedResult);
+                                const truncatedResult = this.truncateResult(sanitizedResult);
                                 toolResults.push({
                                     tool_call_id: toolCall.id,
                                     name: toolCall.name,
@@ -2380,18 +2413,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
@@ -2400,6 +2433,34 @@ 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`);
+                        // 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 {
@@ -2506,11 +2567,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'));
@@ -2535,6 +2595,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) {
@@ -3632,7 +3715,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;
                         }
@@ -4447,116 +4535,122 @@ Create once, run many times across different machines.`;
             if (this.onDirectMessageCallback) {
                 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
+                    if (this.onDirectMessageCallback) {
+                        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 (e) { /* ignore */ }
+                            catch (cdError) {
+                                // Failed to cd to saved path - warn but continue
+                                if (this.onDirectMessageCallback) {
+                                    this.onDirectMessageCallback(`⚠️ Could not restore ${type} directory: ${remoteCwd}`);
+                                }
+                            }
+                        }
+                        // 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.contextManager.popContext();
                     }
-                    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) {