centaurus-cli 2.9.3 → 2.9.5

package/dist/cli-adapter.js

@@ -20,6 +20,8 @@ import { readBinaryFileTool } from './tools/read-binary-file.js';
 import { createImageTool } from './tools/create-image.js';
 import { backgroundCommandTool } from './tools/background-command.js';
 import { subAgentTool } from './tools/sub-agent.js';
+import { enterRemoteSessionTool } from './tools/enter-remote-session.js';
+import { workflowTool } from './tools/workflow-tool.js';
 import { SubAgentManager } from './services/sub-agent-manager.js';
 import { ShellInputAgent } from './services/shell-input-agent.js';
 import { apiClient } from './services/api-client.js';
@@ -43,6 +45,7 @@ import { logWarning } from './utils/logger.js';
 import { BackgroundTaskManager } from './services/background-task-manager.js';
 import { sessionQuotaManager } from './services/session-quota-manager.js';
 import { ollamaService, OllamaService } from './services/ollama-service.js';
+import { workflowStorage } from './services/workflow-storage.js';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
@@ -90,8 +93,8 @@ export class CentaurusCLI {
     onShowChatRenamePickerCallback;
     onRestoreMessagesCallback;
     uiMessageHistory = []; // Mirror of App.tsx's messageHistory for saving
-    localCwdBeforeRemote = null; // Track local CWD before entering remote session
-    lastConnectionCommand = null; // Track the command used to connect to remote
+    cwdStack = []; // Stack of CWDs for nested sessions (pushed when entering, popped when exiting)
+    connectionCommandStack = []; // Stack of commands used to connect (for nested sessions like SSH>SSH, SSH>Docker)
     onBackgroundModeChange;
     onBackgroundTaskCountChange;
     onSetAutoMode;
@@ -111,6 +114,11 @@ export class CentaurusCLI {
     onShowMCPListScreen;
     onSubAgentCountChange; // Callback for sub-agent count changes
     onPromptAnswered; // Callback when AI answers a shell prompt
+    onShowWorkflowCreatorCallback; // Callback to show workflow creator screen with optional initial steps
+    onWorkflowSaveCallback; // Callback when workflow is saved
+    // Workflow learning mode state
+    workflowLearningActive = false;
+    learnedWorkflowSteps = [];
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -120,13 +128,14 @@ export class CentaurusCLI {
         this.commandDetector = new CommandDetector();
         this.aiContextInjector = new AIContextInjector();
         // Register context change callback to update cwd
-        this.contextManager.onContextChange((context) => {
+        // Register context change callback to update cwd
+        this.contextManager.onContextChange((context, stack) => {
             this.cwd = context.metadata.workingDirectory;
             if (this.onCwdChange) {
                 this.onCwdChange(this.cwd);
             }
             if (this.onSubshellContextChange) {
-                this.onSubshellContextChange(context);
+                this.onSubshellContextChange(context, stack);
             }
         });
         // Initialize MCP
@@ -218,6 +227,355 @@ export class CentaurusCLI {
         // Wire this callback to ShellInputAgent
         ShellInputAgent.setOnPromptAnswered(callback);
     }
+    setOnShowWorkflowCreator(callback) {
+        this.onShowWorkflowCreatorCallback = callback;
+    }
+    setOnWorkflowSave(callback) {
+        this.onWorkflowSaveCallback = callback;
+    }
+    /**
+     * Save a workflow from the workflow creator UI
+     */
+    saveWorkflow(name, steps, description) {
+        const workflow = workflowStorage.createWorkflow(name, steps, description);
+        workflowStorage.save(workflow);
+        if (this.onWorkflowSaveCallback) {
+            this.onWorkflowSaveCallback(workflow);
+        }
+    }
+    /**
+     * Toggle workflow learning mode.
+     * First call: Start learning and return a message to display.
+     * Second call: Stop learning and show workflow creator with learned steps.
+     * @returns Message to display to user, or null if showing workflow creator
+     */
+    toggleWorkflowLearning() {
+        if (this.workflowLearningActive) {
+            // Stop learning mode
+            this.workflowLearningActive = false;
+            const steps = [...this.learnedWorkflowSteps];
+            this.learnedWorkflowSteps = []; // Clear for next learning session
+            if (steps.length === 0) {
+                return '⚠️ No steps were recorded. Learning mode cancelled.';
+            }
+            // Show workflow creator with the learned steps
+            if (this.onShowWorkflowCreatorCallback) {
+                this.onShowWorkflowCreatorCallback(steps);
+                return null; // UI will handle the screen change
+            }
+            else {
+                return '❌ Workflow creator not available. Please update the CLI.';
+            }
+        }
+        else {
+            // Start learning mode
+            this.workflowLearningActive = true;
+            this.learnedWorkflowSteps = [];
+            return `📚 **Learning mode started!**
+
+Commands and prompts from here will be recorded to create your workflow.
+
+**Instructions:**
+• Run commands normally - they'll be saved as command steps
+• Type AI prompts - they'll be saved as instruction steps
+• Run \`/workflow new learn-workflow\` again when you're done
+
+Recording will begin with your next input.`;
+        }
+    }
+    /**
+     * Check if workflow learning is currently active
+     */
+    isWorkflowLearningActive() {
+        return this.workflowLearningActive;
+    }
+    /**
+     * Record a step during workflow learning mode
+     * @param type Type of step (command or instruction)
+     * @param content The command or instruction content
+     */
+    recordWorkflowStep(type, content) {
+        if (this.workflowLearningActive && content.trim()) {
+            this.learnedWorkflowSteps.push({ type, content: content.trim() });
+            quickLog(`[${new Date().toISOString()}] [WorkflowLearning] Recorded ${type}: ${content.trim()}\n`);
+        }
+    }
+    /**
+     * Cancel workflow learning mode with a message
+     * Used when conflicting commands are run during learning (e.g., /exit, /clear, /workflow run)
+     * @param reason The reason for cancellation
+     * @returns Message to display to user, or empty string if not in learning mode
+     */
+    cancelWorkflowLearning(reason) {
+        if (!this.workflowLearningActive) {
+            return '';
+        }
+        this.workflowLearningActive = false;
+        const stepsCount = this.learnedWorkflowSteps.length;
+        this.learnedWorkflowSteps = [];
+        quickLog(`[${new Date().toISOString()}] [WorkflowLearning] Cancelled: ${reason} (${stepsCount} steps discarded)\n`);
+        return `⚠️ **Learning mode cancelled**: ${reason}\n\n` +
+            `${stepsCount > 0 ? `${stepsCount} recorded step(s) were discarded.` : 'No steps were recorded.'}\n` +
+            `Run \`/workflow new learn-workflow\` to start again.`;
+    }
+    /**
+     * Build a prompt for the AI to execute a workflow
+     * This formats the workflow steps into a clear instruction set
+     */
+    buildWorkflowPrompt(workflow) {
+        const stepsText = workflow.steps.map((step, index) => {
+            const stepNum = index + 1;
+            if (step.type === 'command') {
+                return `Step ${stepNum}: [RUN COMMAND] ${step.content}`;
+            }
+            else {
+                return `Step ${stepNum}: [INSTRUCTION] ${step.content}`;
+            }
+        }).join('\n');
+        return `Execute the following workflow "${workflow.name}" step by step:
+
+${stepsText}
+
+IMPORTANT: 
+- For [RUN COMMAND] steps, execute the exact command shown using the execute_command tool.
+- For [INSTRUCTION] steps, follow the instruction using appropriate tools.
+- Execute each step in order, waiting for completion before moving to the next.
+- If any step fails, stop and report the error.
+- After all steps complete successfully, summarize what was done.
+
+Begin executing now, starting with Step 1.`;
+    }
+    /**
+     * Warpify a detected SSH/WSL/Docker session.
+     * This establishes a proper ssh2/handler connection (will prompt for password)
+     * so commands can be executed via the handler, not just PTY passthrough.
+     *
+     * @param command - The original command (e.g., "ssh rohan@localhost")
+     * @param type - The detected session type
+     * @param connectionString - The connection string (e.g., "rohan@localhost")
+     * @returns Promise<boolean> - true if warpify succeeded
+     */
+    async warpifySession(command, type, connectionString) {
+        try {
+            // Show connecting status
+            if (this.onConnectionStatusUpdate) {
+                this.onConnectionStatusUpdate({
+                    type: type,
+                    status: 'connecting',
+                    connectionString: connectionString
+                });
+            }
+            // Detect and connect using the command
+            const detection = this.commandDetector.detect(command);
+            if (!detection) {
+                throw new Error(`Could not detect handler for command: ${command}`);
+            }
+            // Check if we are already in a remote session
+            const currentContext = this.contextManager.getCurrentContext();
+            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) {
+                    quickLog(`[${new Date().toISOString()}] [Warpify] nesting connection: ${currentContext.type} -> ${type}\n`);
+                    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;
+                context = await detection.handler.connect(command, initialCwd);
+            }
+            this.connectionCommandStack.push(command);
+            this.contextManager.pushContext(context);
+            // Explicitly sync this.cwd with the new context's CWD to ensure consistency immediately
+            if (context.metadata.workingDirectory) {
+                this.cwd = context.metadata.workingDirectory;
+            }
+            // Set up disconnect callback for remote connections
+            if (context.handler && context.handler.setDisconnectCallback) {
+                context.handler.setDisconnectCallback((error) => {
+                    this.handleRemoteDisconnect(connectionString || '', type, error);
+                });
+            }
+            // Show success
+            if (this.onConnectionStatusUpdate) {
+                this.onConnectionStatusUpdate({
+                    type: type,
+                    status: 'connected',
+                    connectionString: connectionString
+                });
+            }
+            // Update CWD to remote working directory
+            if (this.onCwdChange && context.metadata.workingDirectory) {
+                this.onCwdChange(context.metadata.workingDirectory);
+            }
+            quickLog(`[${new Date().toISOString()}] [Warpify] Successfully established ${type} connection via ssh2/handler\n`);
+            return true;
+        }
+        catch (error) {
+            // Connection failed
+            if (this.onConnectionStatusUpdate) {
+                this.onConnectionStatusUpdate({
+                    type: type,
+                    status: 'error',
+                    connectionString: connectionString,
+                    error: error.message
+                });
+            }
+            quickLog(`[${new Date().toISOString()}] [Warpify] Failed to establish connection: ${error.message}\n`);
+            return false;
+        }
+    }
+    /**
+     * Exit the current remote session and return to parent environment.
+     * Called by the AI agent's enter_remote_session tool with action="exit".
+     * @returns Promise<boolean> - true if there was a session to exit
+     */
+    async exitRemoteSession() {
+        const currentContext = this.contextManager.getCurrentContext();
+        // Check if we're in a remote session
+        if (currentContext.type === 'local') {
+            return false; // No remote session to exit
+        }
+        // Get connection info for logging
+        const sessionType = currentContext.type;
+        const metadata = currentContext.metadata;
+        const connectionString = metadata.connectionString ||
+            metadata.host ||
+            metadata.containerId ||
+            metadata.distro ||
+            metadata.workingDirectory ||
+            'unknown';
+        quickLog(`[${new Date().toISOString()}] [ExitRemoteSession] Exiting ${sessionType} session: ${connectionString}\n`);
+        // Close the handler if it has a disconnect method
+        if (currentContext.handler && typeof currentContext.handler.disconnect === 'function') {
+            try {
+                await currentContext.handler.disconnect();
+            }
+            catch (error) {
+                quickLog(`[${new Date().toISOString()}] [ExitRemoteSession] Error during handler disconnect: ${error.message}\n`);
+            }
+        }
+        // Pop the context
+        this.contextManager.popContext();
+        // Restore CWD from stack
+        const previousCwd = this.cwdStack.pop();
+        const newContext = this.contextManager.getCurrentContext();
+        if (previousCwd) {
+            this.cwd = previousCwd;
+        }
+        else if (newContext.type !== 'local') {
+            this.cwd = newContext.metadata.workingDirectory;
+        }
+        this.contextManager.updateWorkingDirectory(this.cwd);
+        if (newContext.type === 'local') {
+            this.connectionCommandStack.pop();
+        }
+        // Notify CWD change
+        if (this.onCwdChange) {
+            this.onCwdChange(this.cwd);
+        }
+        // Save chat state
+        this.saveCurrentChat();
+        // Update UI connection status
+        if (this.onConnectionStatusUpdate) {
+            if (newContext.type === 'local') {
+                this.onConnectionStatusUpdate({
+                    type: sessionType,
+                    status: 'disconnected',
+                    connectionString: connectionString
+                });
+            }
+            else {
+                // Still in a nested session
+                const newMetadata = newContext.metadata;
+                this.onConnectionStatusUpdate({
+                    type: newContext.type,
+                    status: 'connected',
+                    connectionString: newMetadata.connectionString || newMetadata.host || newMetadata.workingDirectory
+                });
+            }
+        }
+        return true;
+    }
+    /**
+     * Handle disconnection from a remote session
+     */
+    handleRemoteDisconnect(connectionString, type, error) {
+        quickLog(`[${new Date().toISOString()}] [Warpify] Disconnected from ${type} session: ${connectionString} (${error || 'clean exit'})\n`);
+        // Pop the context (this was the session that just ended)
+        const endedContext = this.contextManager.popContext();
+        // Now look at the NEW current context (the parent)
+        const currentContext = this.contextManager.getCurrentContext();
+        // Restore CWD from stack - this handles any nesting level
+        const previousCwd = this.cwdStack.pop();
+        if (previousCwd) {
+            this.cwd = previousCwd;
+        }
+        else if (currentContext.type !== 'local') {
+            // Fallback: use parent context's CWD if no stack entry
+            this.cwd = currentContext.metadata.workingDirectory;
+        }
+        this.contextManager.updateWorkingDirectory(this.cwd);
+        if (currentContext.type === 'local') {
+            this.connectionCommandStack.pop();
+        }
+        // Notify CWD change
+        if (this.onCwdChange) {
+            this.onCwdChange(this.cwd);
+        }
+        // Save chat state
+        this.saveCurrentChat();
+        // Update UI connection status
+        if (this.onConnectionStatusUpdate) {
+            if (currentContext.type === 'local') {
+                this.onConnectionStatusUpdate({
+                    type: type,
+                    status: 'disconnected',
+                    connectionString
+                });
+            }
+            else {
+                // Update status to reflect the parent session
+                let parentConnString = '';
+                if (currentContext.type === 'ssh') {
+                    parentConnString = `${currentContext.metadata.username}@${currentContext.metadata.hostname}`;
+                }
+                else if (currentContext.type === 'wsl') {
+                    parentConnString = currentContext.metadata.distroName || '';
+                }
+                else if (currentContext.type === 'docker') {
+                    parentConnString = currentContext.metadata.containerId || '';
+                }
+                this.onConnectionStatusUpdate({
+                    type: currentContext.type,
+                    status: 'connected',
+                    connectionString: parentConnString
+                });
+            }
+        }
+        // If there's an active tool execution (shell running), mark it as error
+        if (this.onToolExecutionUpdate && this.currentInteractiveProcess) {
+            this.onToolExecutionUpdate({
+                toolName: 'execute_command',
+                status: 'error',
+                error: `Disconnected from ${type}: ${error || 'Connection lost'}`
+            });
+            this.currentInteractiveProcess = undefined;
+        }
+    }
     /**
      * Calculate and update token count based on current conversation history
      * This ensures UI is always in sync with the actual AI context
@@ -498,6 +856,11 @@ export class CentaurusCLI {
      * Notify UI about tool execution status
      */
     notifyToolStatus(toolName, status, args, result, error) {
+        // Skip UI status updates for enter_remote_session - the password prompt
+        // and "Established Wormhole" message already provide sufficient feedback
+        if (toolName === 'enter_remote_session') {
+            return;
+        }
         if (this.onToolExecutionUpdate) {
             // Get current context for remote prefix
             const currentContext = this.contextManager.getCurrentContext();
@@ -574,6 +937,8 @@ export class CentaurusCLI {
         this.toolRegistry.register(createImageTool);
         this.toolRegistry.register(backgroundCommandTool);
         this.toolRegistry.register(subAgentTool);
+        this.toolRegistry.register(enterRemoteSessionTool);
+        this.toolRegistry.register(workflowTool);
         // Initialize SubAgentManager with tool registry
         SubAgentManager.initialize(this.toolRegistry);
         SubAgentManager.setOnSubAgentCountChange((count) => {
@@ -769,14 +1134,22 @@ Press Enter to continue...
             }
         }
     }
-    async handleMessage(message) {
+    async handleMessage(message, options = {}) {
         // Handle command mode - execute commands directly
         if (this.commandMode) {
+            // Record command step if workflow learning mode is active
+            if (this.workflowLearningActive) {
+                this.recordWorkflowStep('command', message);
+            }
             await this.handleCommandModeExecution(message);
             return;
         }
         // Handle background mode - execute commands in background
         if (this.backgroundMode) {
+            // Record command step if workflow learning mode is active
+            if (this.workflowLearningActive) {
+                this.recordWorkflowStep('command', message);
+            }
             this.handleBackgroundModeExecution(message);
             return;
         }
@@ -785,6 +1158,11 @@ Press Enter to continue...
             await this.handleSlashCommand(message);
             return;
         }
+        // Record step if workflow learning mode is active
+        // AI prompts are recorded as instruction steps
+        if (this.workflowLearningActive) {
+            this.recordWorkflowStep('instruction', message);
+        }
         // Check authentication
         if (!apiClient.isAuthenticated()) {
             throw new Error('Authentication required. Please sign in to use AI features.');
@@ -887,6 +1265,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             role: 'user',
             content: userMessageContent,
         });
+        // 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);
+            }
+            return [...this.conversationHistory];
+        };
         // Messages are stored locally only - no backend persistence needed
         // Local storage is handled by saveCurrentChat() which saves to ~/.centaurus/chats/
         // Start logging session and log user message
@@ -931,7 +1318,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             // SAFETY: Clean up any orphaned tool calls before making AI request
             // This prevents "improperly formed request" errors from corrupted history
             this.cleanupOrphanedToolCalls();
-            let messages = [...this.conversationHistory];
+            let messages = getMessagesForContext();
             // Inject subshell context if in a subshell environment
             const currentContext = this.contextManager.getCurrentContext();
             messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
@@ -1380,7 +1767,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                 // Clear pending plan request
                                                 this.pendingPlanRequest = null;
                                                 // Update messages array for this turn
-                                                messages = [...this.conversationHistory];
+                                                messages = getMessagesForContext();
                                                 // Continue the loop - AI will now execute with plan context
                                                 continue;
                                             }
@@ -1445,7 +1832,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         });
                                         // Mark this tool call as handled so it's not duplicated
                                         handledToolCallIds.add(toolCall.id);
-                                        messages = [...this.conversationHistory];
+                                        messages = getMessagesForContext();
                                     }
                                 }
                                 else {
@@ -1469,7 +1856,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                     });
                                     // Mark this tool call as handled so it's not duplicated
                                     handledToolCallIds.add(toolCall.id);
-                                    messages = [...this.conversationHistory];
+                                    messages = getMessagesForContext();
                                 }
                                 continue;
                             }
@@ -1536,7 +1923,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                 // Mark as handled
                                                 handledToolCallIds.add(toolCall.id);
                                                 // Update messages and continue
-                                                messages = [...this.conversationHistory];
+                                                messages = getMessagesForContext();
                                                 continue;
                                             }
                                         }
@@ -1878,7 +2265,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     // Rebuild messages array with updated history
                     // During agent loop: keep ALL thinking for current task
                     // (Thinking from previous tasks was already stripped at request start)
-                    messages = [...this.conversationHistory];
+                    messages = getMessagesForContext();
                     // No need to reset currentTurnThinking - keep accumulating for the task
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
@@ -1921,7 +2308,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     }
                     // Rebuild messages array with updated history
                     // Backend will inject system prompt
-                    messages = [...this.conversationHistory];
+                    messages = getMessagesForContext();
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
                     // Continue loop to get AI's response (removed 500ms delay for faster response)
@@ -1942,7 +2329,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 });
                 // Rebuild messages array with updated history
                 // Backend will inject system prompt
-                messages = [...this.conversationHistory];
+                messages = getMessagesForContext();
                 // Re-inject subshell context
                 messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
                 // Add delay before prompting
@@ -2276,6 +2663,11 @@ Start by listing the directory structure to understand what you're working with.
                 break;
             case 'logout':
                 try {
+                    // Cancel workflow learning if active before logout
+                    const logoutCancelMsg = this.cancelWorkflowLearning('Logging out');
+                    if (logoutCancelMsg && this.onDirectMessageCallback) {
+                        this.onDirectMessageCallback(logoutCancelMsg);
+                    }
                     await apiClient.logout();
                     responseMessage = '✅ Logged out successfully.\n\n' +
                         'Your session has been cleared.\n' +
@@ -2354,6 +2746,11 @@ Start by listing the directory structure to understand what you're working with.
                         '• Manual completion detection';
                 break;
             case 'clear':
+                // Cancel workflow learning if active before clearing
+                const clearCancelMsg = this.cancelWorkflowLearning('Clearing chat session');
+                if (clearCancelMsg && this.onDirectMessageCallback) {
+                    this.onDirectMessageCallback(clearCancelMsg);
+                }
                 // Start a new chat session (clears history and generates new chat ID)
                 this.startNewChat();
                 // Don't send any response message - the UI will handle clearing
@@ -2792,6 +3189,163 @@ Then try /models local again.`;
                         '  /background-task cancel  - Cancel a running background task';
                 }
                 break;
+            case 'workflow':
+            case 'wf':
+                // Workflow management commands
+                const wfSubCommand = args[0]?.toLowerCase();
+                if (!wfSubCommand) {
+                    // Show workflow help
+                    responseMessage = `📋 **Workflow Commands:**
+
+  **/workflow new** - Create a new workflow
+  **/workflow list** - List saved workflows
+  **/workflow run <name>** - Run a workflow
+  **/workflow view <name>** - View workflow steps
+  **/workflow delete <name>** - Delete a workflow
+
+**What are workflows?**
+Workflows let you save and replay sequences of commands and instructions.
+Create once, run many times across different machines.`;
+                }
+                else if (wfSubCommand === 'new' || wfSubCommand === 'create') {
+                    // Check for nested subcommand (manual or learn-workflow)
+                    const newSubCommand = args[1]?.toLowerCase();
+                    if (newSubCommand === 'manual') {
+                        // If learning mode is active, cancel it instead of starting manual mode
+                        if (this.workflowLearningActive) {
+                            responseMessage = this.cancelWorkflowLearning('Switching to manual mode');
+                            break; // Don't start manual mode, just show cancellation message
+                        }
+                        // Show workflow creator screen (manual mode)
+                        if (this.onShowWorkflowCreatorCallback) {
+                            this.onShowWorkflowCreatorCallback();
+                            return; // Don't send text response, UI will handle it
+                        }
+                        else {
+                            responseMessage = '❌ Workflow creator not available. Please update the CLI.';
+                        }
+                    }
+                    else if (newSubCommand === 'learn-workflow') {
+                        // Toggle workflow learning mode
+                        const result = this.toggleWorkflowLearning();
+                        if (result === null) {
+                            return; // UI will handle the screen change
+                        }
+                        responseMessage = result;
+                    }
+                    else if (newSubCommand) {
+                        // Unknown subcommand
+                        responseMessage = `❌ Unknown workflow new subcommand: ${newSubCommand}. Use 'manual' or 'learn-workflow'.`;
+                    }
+                    else {
+                        // No subcommand - show help for new options
+                        responseMessage = `📋 **Create a New Workflow:**
+
+  **/workflow new manual** - Manually create by typing steps
+  **/workflow new learn-workflow** - Learn from your commands and prompts
+
+**Manual Mode:** Type each step one at a time, toggle between command/instruction mode.
+
+**Learn Mode:** Start learning, then run commands and prompts naturally. Run the command again to save.`;
+                    }
+                }
+                else if (wfSubCommand === 'list' || wfSubCommand === 'ls') {
+                    // List saved workflows
+                    const workflows = workflowStorage.list();
+                    if (workflows.length === 0) {
+                        responseMessage = '📭 No workflows saved yet.\n\nCreate one with: /workflow new';
+                    }
+                    else {
+                        responseMessage = `📋 **Saved Workflows (${workflows.length}):**\n\n`;
+                        for (const wf of workflows) {
+                            const date = new Date(wf.updatedAt).toLocaleDateString();
+                            responseMessage += `• **${wf.name}** (${wf.stepCount} steps)\n`;
+                            if (wf.description) {
+                                responseMessage += `  ${wf.description}\n`;
+                            }
+                            responseMessage += `  Last updated: ${date}\n\n`;
+                        }
+                        responseMessage += 'Use `/workflow run <name>` to execute a workflow.';
+                    }
+                }
+                else if (wfSubCommand === 'run' || wfSubCommand === 'execute') {
+                    // Run a workflow
+                    const wfName = args.slice(1).join(' ').trim();
+                    if (!wfName) {
+                        responseMessage = 'Usage: /workflow run <name>\n\nUse /workflow list to see available workflows.';
+                    }
+                    else {
+                        // Cancel workflow learning if active before running a different workflow
+                        const runCancelMsg = this.cancelWorkflowLearning('Running another workflow');
+                        if (runCancelMsg && this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(runCancelMsg);
+                        }
+                        const workflow = workflowStorage.load(wfName);
+                        if (!workflow) {
+                            responseMessage = `❌ Workflow '${wfName}' not found.\n\nUse /workflow list to see available workflows.`;
+                        }
+                        else {
+                            // Start workflow execution
+                            responseMessage = `🚀 Starting workflow: **${workflow.name}**\n\n` +
+                                `${workflow.steps.length} steps to execute...\n\n` +
+                                workflowStorage.formatWorkflowForDisplay(workflow);
+                            // Send initial response
+                            if (this.onDirectMessageCallback) {
+                                this.onDirectMessageCallback(responseMessage);
+                            }
+                            // Trigger workflow execution by sending the workflow to the AI
+                            // Format the workflow as a prompt for the AI to execute
+                            const workflowPrompt = this.buildWorkflowPrompt(workflow);
+                            // Use setTimeout to allow the UI to update before starting execution
+                            setTimeout(() => {
+                                this.handleMessage(workflowPrompt, { isolatedWorkflow: true });
+                            }, 100);
+                            return;
+                        }
+                    }
+                }
+                else if (wfSubCommand === 'view' || wfSubCommand === 'show') {
+                    // View a workflow's steps
+                    const wfName = args.slice(1).join(' ').trim();
+                    if (!wfName) {
+                        responseMessage = 'Usage: /workflow view <name>';
+                    }
+                    else {
+                        const workflow = workflowStorage.load(wfName);
+                        if (!workflow) {
+                            responseMessage = `❌ Workflow '${wfName}' not found.\n\nUse /workflow list to see available workflows.`;
+                        }
+                        else {
+                            responseMessage = workflowStorage.formatWorkflowForDisplay(workflow);
+                        }
+                    }
+                }
+                else if (wfSubCommand === 'delete' || wfSubCommand === 'rm' || wfSubCommand === 'remove') {
+                    // Delete a workflow
+                    const wfName = args.slice(1).join(' ').trim();
+                    if (!wfName) {
+                        responseMessage = 'Usage: /workflow delete <name>';
+                    }
+                    else {
+                        const result = workflowStorage.delete(wfName);
+                        if (result.success) {
+                            responseMessage = `✅ Workflow '${wfName}' deleted successfully.`;
+                        }
+                        else {
+                            responseMessage = `❌ ${result.error}`;
+                        }
+                    }
+                }
+                else {
+                    responseMessage = `Unknown /workflow subcommand: ${wfSubCommand}\n\n` +
+                        'Usage:\n' +
+                        '  /workflow new          - Create a new workflow\n' +
+                        '  /workflow list         - List saved workflows\n' +
+                        '  /workflow run <name>   - Run a workflow\n' +
+                        '  /workflow view <name>  - View workflow steps\n' +
+                        '  /workflow delete <name> - Delete a workflow';
+                }
+                break;
             case 'sync':
                 // Sync local data to/from cloud
                 if (!apiClient.isAuthenticated()) {
@@ -3215,12 +3769,32 @@ Then try /models local again.`;
                     }
                     return;
                 }
+                // Check if Docker is nested inside SSH
+                const parentContext = this.contextManager.getParentContext();
                 // Start remote task first to get callbacks
                 const remoteTask = BackgroundTaskManager.startRemoteTask(command, effectiveCwd, remoteContextDisplay || 'docker');
                 taskId = remoteTask.id;
-                // Create Docker PTY with the callbacks from BackgroundTaskManager
-                const dockerPty = runDockerCommand(containerId, command, effectiveCwd, remoteTask.onData, remoteTask.onExit);
-                remoteTask.setRemotePty(dockerPty);
+                if (parentContext && parentContext.type === 'ssh') {
+                    // Nested Docker inside SSH: route docker exec command through SSH
+                    const sshClient = parentContext.handler?.client;
+                    if (!sshClient) {
+                        if (this.onResponseCallback) {
+                            this.onResponseCallback('❌ SSH client not available for nested Docker background task');
+                        }
+                        return;
+                    }
+                    // Build docker exec command to run via SSH
+                    const escapedCommand = command.replace(/"/g, '\\"');
+                    const dockerCommand = `docker exec -w "${effectiveCwd}" ${containerId} sh -c "${escapedCommand}"`;
+                    // Create SSH PTY to run the docker command
+                    const sshPty = runSSHCommand(sshClient, dockerCommand, parentContext.metadata.workingDirectory || '~', remoteTask.onData, remoteTask.onExit);
+                    remoteTask.setRemotePty(sshPty);
+                }
+                else {
+                    // Local Docker: use standard runDockerCommand
+                    const dockerPty = runDockerCommand(containerId, command, effectiveCwd, remoteTask.onData, remoteTask.onExit);
+                    remoteTask.setRemotePty(dockerPty);
+                }
             }
             else {
                 // Unknown remote type - fall back to local
@@ -3306,28 +3880,57 @@ Then try /models local again.`;
         // Capture remote context if in remote environment (SSH/WSL/Docker)
         // Use null to explicitly clear remote context when not in remote (so resuming won't reconnect)
         let remoteContext = null;
+        let remoteContextStack = null;
         const currentContext = this.contextManager.getCurrentContext();
-        if (currentContext.type !== 'local' && this.lastConnectionCommand) {
-            remoteContext = {
-                type: currentContext.type,
-                connectionCommand: this.lastConnectionCommand,
-                remoteCwd: currentContext.metadata.workingDirectory,
-                localCwdBeforeRemote: this.localCwdBeforeRemote || process.cwd(),
-                metadata: {
-                    hostname: currentContext.metadata.hostname,
-                    username: currentContext.metadata.username,
-                    distroName: currentContext.metadata.distroName,
-                    containerId: currentContext.metadata.containerId,
-                    port: currentContext.metadata.port,
+        // Build remoteContextStack for nested sessions
+        if (currentContext.type !== 'local' && this.connectionCommandStack.length > 0) {
+            remoteContextStack = [];
+            // Build stack of contexts from the connectionCommandStack and cwdStack
+            // cwdStack[0] = local CWD before first remote
+            // cwdStack[1] = first remote CWD before second remote (if nested)
+            // connectionCommandStack[0] = first connection command
+            // connectionCommandStack[1] = second connection command (if nested)
+            for (let i = 0; i < this.connectionCommandStack.length; i++) {
+                const connCmd = this.connectionCommandStack[i];
+                // Detect the type from the command
+                let ctxType = 'ssh';
+                if (connCmd.startsWith('docker ') || connCmd.startsWith('docker-compose ')) {
+                    ctxType = 'docker';
                 }
-            };
+                else if (connCmd.startsWith('wsl')) {
+                    ctxType = 'wsl';
+                }
+                // Get the CWD before this remote connection
+                const cwdBefore = i < this.cwdStack.length ? this.cwdStack[i] : process.cwd();
+                // For the last (current) context, use the actual metadata
+                const isLastContext = i === this.connectionCommandStack.length - 1;
+                const remoteCwd = isLastContext ? currentContext.metadata.workingDirectory : (this.cwdStack[i + 1] || '~');
+                const storedCtx = {
+                    type: ctxType,
+                    connectionCommand: connCmd,
+                    remoteCwd: remoteCwd,
+                    localCwdBeforeRemote: cwdBefore,
+                    metadata: isLastContext ? {
+                        hostname: currentContext.metadata.hostname,
+                        username: currentContext.metadata.username,
+                        distroName: currentContext.metadata.distroName,
+                        containerId: currentContext.metadata.containerId,
+                        port: currentContext.metadata.port,
+                    } : {}
+                };
+                remoteContextStack.push(storedCtx);
+            }
+            // For backward compatibility, also set remoteContext to the last (current) context
+            if (remoteContextStack.length > 0) {
+                remoteContext = remoteContextStack[remoteContextStack.length - 1];
+            }
         }
-        // Determine the local CWD to save (use localCwdBeforeRemote if in remote, otherwise current cwd)
-        const cwdToSave = currentContext.type !== 'local' && this.localCwdBeforeRemote
-            ? this.localCwdBeforeRemote
+        // Determine the local CWD to save (use base of cwdStack if in remote, otherwise current cwd)
+        const cwdToSave = currentContext.type !== 'local' && this.cwdStack.length > 0
+            ? this.cwdStack[0]
             : this.cwd;
         try {
-            localChatStorage.saveChat(this.currentChatId, storedMessages, storedUIMessages, cwdToSave, remoteContext);
+            localChatStorage.saveChat(this.currentChatId, storedMessages, storedUIMessages, cwdToSave, remoteContext, remoteContextStack);
             // Also store the backend conversation ID (UUID) for file deletion
             // This is the ID used for GCS file storage, not the local chat ID
             const backendId = conversationManager.getCurrentConversationId();
@@ -3415,8 +4018,8 @@ Then try /models local again.`;
             // Pop context to return to local
             this.contextManager.popContext();
             // Clear remote context tracking
-            this.localCwdBeforeRemote = null;
-            this.lastConnectionCommand = null;
+            this.cwdStack = [];
+            this.connectionCommandStack = [];
         }
         // Load AI context
         this.loadChat(chatId);
@@ -3441,28 +4044,64 @@ Then try /models local again.`;
             this.onRestoreMessagesCallback(restoredMessages);
         }
         // Attempt to restore remote context if chat was saved while in remote environment
-        if (chat.remoteContext) {
-            const { type, connectionCommand, remoteCwd, localCwdBeforeRemote } = chat.remoteContext;
-            // Store local CWD for when user exits remote
-            this.localCwdBeforeRemote = localCwdBeforeRemote;
-            this.lastConnectionCommand = connectionCommand;
-            // Show reconnection notification
+        // Support both remoteContextStack (for nested sessions) and single remoteContext (backward compat)
+        const contextStackToRestore = chat.remoteContextStack ?? (chat.remoteContext ? [chat.remoteContext] : null);
+        if (contextStackToRestore && contextStackToRestore.length > 0) {
+            // Get the base local CWD from the first context's localCwdBeforeRemote
+            const baseLocalCwd = contextStackToRestore[0].localCwdBeforeRemote;
+            // Initialize stacks
+            this.cwdStack = [baseLocalCwd];
+            this.connectionCommandStack = [];
+            // Show initial reconnection notification
+            const nestingInfo = contextStackToRestore.length > 1
+                ? ` (${contextStackToRestore.length} levels: ${contextStackToRestore.map(c => c.type).join(' > ')})`
+                : '';
             if (this.onDirectMessageCallback) {
-                this.onDirectMessageCallback(`🔄 Reconnecting to ${type.toUpperCase()} session...`);
-            }
-            // Show connecting status
-            if (this.onConnectionStatusUpdate) {
-                this.onConnectionStatusUpdate({
-                    type: type,
-                    status: 'connecting',
-                    connectionString: this.buildConnectionString(type, chat.remoteContext.metadata)
-                });
+                this.onDirectMessageCallback(`🔄 Reconnecting to session${nestingInfo}...`);
             }
-            try {
-                // Detect and connect using the saved command
-                const detection = this.commandDetector.detect(connectionCommand);
-                if (detection) {
-                    const context = await detection.handler.connect(connectionCommand, localCwdBeforeRemote);
+            // 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}`);
+                    }
+                    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 (detection.handler.connectFromRemote) {
+                            context = await detection.handler.connectFromRemote(connectionCommand, previousCwd, currentContext);
+                        }
+                        else {
+                            throw new Error(`Nested connections not supported by ${type} handler`);
+                        }
+                    }
+                    else {
+                        // First level: connect from local
+                        context = await detection.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) {
@@ -3472,38 +4111,61 @@ Then try /models local again.`;
                         catch (cdError) {
                             // Failed to cd to saved path - warn but continue
                             if (this.onDirectMessageCallback) {
-                                this.onDirectMessageCallback(`⚠️ Could not restore remote directory: ${remoteCwd}`);
+                                this.onDirectMessageCallback(`⚠️ Could not restore ${type} directory: ${remoteCwd}`);
                             }
                         }
                     }
-                    // Show success
+                    // 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, chat.remoteContext.metadata)
+                            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 {
+                                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;
                 }
             }
-            catch (error) {
-                // Connection failed - fall back to local mode
-                this.localCwdBeforeRemote = null;
-                this.lastConnectionCommand = null;
-                if (this.onConnectionStatusUpdate) {
-                    this.onConnectionStatusUpdate({
-                        type: type,
-                        status: 'error',
-                        connectionString: this.buildConnectionString(type, chat.remoteContext.metadata),
-                        error: error.message
-                    });
-                }
-                if (this.onDirectMessageCallback) {
-                    this.onDirectMessageCallback(`⚠️ Loaded chat: "${chat.title}"\n\n❌ Could not reconnect to ${type.toUpperCase()}: ${error.message}\n\n📁 Restored to local directory: ${localCwdBeforeRemote}`);
+            // All levels connected successfully
+            if (this.onDirectMessageCallback) {
+                const successInfo = contextStackToRestore.length > 1
+                    ? `🔗 Reconnected through ${contextStackToRestore.length} levels`
+                    : '';
+                if (successInfo) {
+                    this.onDirectMessageCallback(successInfo);
                 }
-                return;
             }
+            return;
         }
         // No remote context - show regular confirmation
         // No remote context - show regular confirmation and restore CWD
@@ -3552,8 +4214,8 @@ Then try /models local again.`;
         this.currentChatId = null;
         this.conversationStarted = false;
         this.uiMessageHistory = [];
-        this.localCwdBeforeRemote = null;
-        this.lastConnectionCommand = null;
+        this.cwdStack = [];
+        this.connectionCommandStack = [];
         // Reset context limit state
         if (this.contextLimitReached) {
             this.contextLimitReached = false;
@@ -3689,45 +4351,6 @@ Once the user approves the plan:
             }
         }
     }
-    /**
-     * Handle unexpected remote session disconnect
-     * Called when SSH/WSL/Docker connection is lost unexpectedly
-     */
-    handleRemoteDisconnect(connectionString, type, error) {
-        // Pop the remote context
-        this.contextManager.popContext();
-        // Restore local CWD
-        if (this.localCwdBeforeRemote) {
-            this.cwd = this.localCwdBeforeRemote;
-            this.contextManager.updateWorkingDirectory(this.localCwdBeforeRemote);
-            if (this.onCwdChange) {
-                this.onCwdChange(this.localCwdBeforeRemote);
-            }
-        }
-        // Clear remote context tracking
-        this.localCwdBeforeRemote = null;
-        this.lastConnectionCommand = null;
-        // Save chat with no remote context
-        this.saveCurrentChat();
-        // Notify UI of disconnection via connection status update
-        if (this.onConnectionStatusUpdate) {
-            this.onConnectionStatusUpdate({
-                type: type,
-                status: 'disconnected',
-                connectionString,
-                error: error
-            });
-        }
-        // If there's an active tool execution (shell running), mark it as error
-        if (this.onToolExecutionUpdate && this.currentInteractiveProcess) {
-            this.onToolExecutionUpdate({
-                toolName: 'execute_command',
-                status: 'error',
-                error: `Disconnected from ${type}: ${error || 'Connection lost'}`
-            });
-            this.currentInteractiveProcess = undefined;
-        }
-    }
     /**
      * Set the current interactive process
      * This is called by the execute_command tool when starting an interactive command
@@ -3755,7 +4378,8 @@ Once the user approves the plan:
                     // Remote context (SSH, WSL, Docker) - pass remote context to App
                     // Use the remote context's working directory, not the local Windows CWD
                     const remoteCwd = currentContextForEditor.metadata?.workingDirectory || '~';
-                    this.onInteractiveEditorMode(true, command, remoteCwd, currentContextForEditor);
+                    const parentContext = this.contextManager.getParentContext() || undefined; // Convert null to undefined
+                    this.onInteractiveEditorMode(true, command, remoteCwd, currentContextForEditor, parentContext);
                 }
                 return;
             }
@@ -3769,20 +4393,32 @@ Once the user approves the plan:
                     if (currentContext.handler) {
                         await currentContext.handler.disconnect();
                     }
-                    // Pop context
+                    // Pop context - this returns us to the parent context
                     this.contextManager.popContext();
-                    // Restore local CWD that was saved before entering remote session
-                    if (this.localCwdBeforeRemote) {
-                        this.cwd = this.localCwdBeforeRemote;
-                        this.contextManager.updateWorkingDirectory(this.localCwdBeforeRemote);
+                    // Check the NEW current context after popping
+                    const newContext = this.contextManager.getCurrentContext();
+                    // Pop the previous CWD from stack - this handles any nesting level
+                    const previousCwd = this.cwdStack.pop();
+                    if (previousCwd) {
+                        this.cwd = previousCwd;
+                        this.contextManager.updateWorkingDirectory(previousCwd);
+                        if (this.onCwdChange) {
+                            this.onCwdChange(previousCwd);
+                        }
+                    }
+                    else if (newContext.type !== 'local') {
+                        // Fallback: use parent context's CWD if no stack entry
+                        const parentCwd = newContext.metadata?.workingDirectory || '~';
+                        this.cwd = parentCwd;
                         if (this.onCwdChange) {
-                            this.onCwdChange(this.localCwdBeforeRemote);
+                            this.onCwdChange(parentCwd);
                         }
                     }
-                    // Clear remote context tracking
-                    this.localCwdBeforeRemote = null;
-                    this.lastConnectionCommand = null;
-                    // Save chat with no remote context - so resuming won't try to reconnect
+                    if (newContext.type === 'local') {
+                        // Clear tracking when back to local
+                        this.connectionCommandStack.pop();
+                    }
+                    // Save chat - include remote context info if still in remote
                     this.saveCurrentChat();
                     if (this.onResponseCallback) {
                         this.onResponseCallback('✅ Exited subshell');
@@ -3790,87 +4426,32 @@ Once the user approves the plan:
                     return;
                 }
             }
-            // Detect subshell commands
+            // WARPIFY MODE: SSH/WSL/Docker commands now run as NORMAL PTY commands
+            // The old flow intercepted these commands and used the ssh2/etc libraries directly.
+            // The new flow lets them run in focus mode, user enters password in terminal,
+            // then presses Alt+E to "warpify" the session for AI context awareness.
+            // The detection code is preserved below (commented) for reference.
+            /*
+            // Detect subshell commands (OLD FLOW - DISABLED FOR WARPIFY)
             const detection = this.commandDetector.detect(command);
             if (detection) {
-                // Build connection string for display (e.g., "rohan@localhost" for SSH)
-                let connectionString = '';
-                if (detection.handler.type === 'ssh') {
-                    // Parse SSH command to get user@host
-                    const sshMatch = command.match(/ssh\s+(?:(?:-\w+\s+)+)?(?:(\S+)@)?(\S+)/);
-                    if (sshMatch) {
-                        const user = sshMatch[1] || 'user';
-                        const host = sshMatch[2] || 'remote';
-                        connectionString = `${user}@${host}`;
-                    }
-                }
-                else if (detection.handler.type === 'wsl') {
-                    // Parse WSL command to get distribution name
-                    const wslMatch = command.match(/wsl(?:\s+(?:-d|--distribution)\s+(\S+))?/);
-                    connectionString = wslMatch?.[1] || 'Ubuntu';
-                }
-                else if (detection.handler.type === 'docker') {
-                    // Parse Docker command to get container
-                    const dockerMatch = command.match(/docker\s+exec\s+(?:(?:-\w+\s+)+)?(\S+)/);
-                    connectionString = dockerMatch?.[1]?.substring(0, 12) || 'container';
-                }
-                // Show connecting message with spinner (dynamic)
-                if (this.onConnectionStatusUpdate) {
-                    this.onConnectionStatusUpdate({
-                        type: detection.handler.type,
-                        status: 'connecting',
-                        connectionString
-                    });
-                }
-                // Update connection state
-                this.contextManager.updateConnectionState('connecting');
-                try {
-                    // Save local CWD before entering remote session (for restoration when resuming chat)
-                    if (this.contextManager.getCurrentContext().type === 'local') {
-                        this.localCwdBeforeRemote = this.cwd;
-                    }
-                    this.lastConnectionCommand = command;
-                    // Connect to subshell
-                    const context = await detection.handler.connect(command, this.cwd);
-                    this.contextManager.pushContext(context);
-                    // Set up disconnect callback for SSH connections
-                    if (detection.handler.type === 'ssh' && context.handler?.setDisconnectCallback) {
-                        context.handler.setDisconnectCallback((error) => {
-                            // Handle unexpected disconnect
-                            this.handleRemoteDisconnect(connectionString, detection.handler.type, error);
-                        });
-                    }
-                    // Show success message (replaces the spinner with static message)
-                    if (this.onConnectionStatusUpdate) {
-                        this.onConnectionStatusUpdate({
-                            type: detection.handler.type,
-                            status: 'connected',
-                            connectionString
-                        });
-                    }
-                    return;
-                }
-                catch (error) {
-                    // Connection failed
-                    this.contextManager.updateConnectionState('error');
-                    if (this.onConnectionStatusUpdate) {
-                        this.onConnectionStatusUpdate({
-                            type: detection.handler.type,
-                            status: 'error',
-                            connectionString,
-                            error: error.message
-                        });
-                    }
-                    return;
-                }
+              // ... old interception logic ...
+              // This triggered password prompt BEFORE running the command
             }
+            */
             // Special handling for cd command - change the actual working directory
-            const cdMatch = command.match(/^cd\s+(.+)$/);
+            // Check for chained commands: cd path && cmd or cd path ; cmd
+            const chainedCdMatch = command.match(/^cd\s+([^;&]+?)\s*(&&|;)\s*(.+)$/);
+            const simpleCdMatch = command.match(/^cd\s+(.+)$/);
+            // Determine if this starts with cd
+            const cdMatch = chainedCdMatch || simpleCdMatch;
             if (cdMatch) {
                 const currentContext = this.contextManager.getCurrentContext();
+                const targetDir = (chainedCdMatch ? chainedCdMatch[1] : cdMatch[1]).trim();
+                const hasChainedCommand = !!chainedCdMatch;
+                const chainedCommand = chainedCdMatch ? chainedCdMatch[3] : null;
                 if (currentContext.type === 'local') {
                     // Local cd handling
-                    const targetDir = cdMatch[1].trim();
                     const newCwd = path.resolve(this.cwd, targetDir);
                     if (!fs.existsSync(newCwd)) {
                         if (this.onResponseCallback) {
@@ -3884,19 +4465,31 @@ Once the user approves the plan:
                         }
                         return;
                     }
+                    this.cwd = newCwd;
                     this.contextManager.updateWorkingDirectory(newCwd);
                     if (this.onResponseCallback) {
                         this.onResponseCallback(`Changed directory to: ${newCwd}`);
                     }
+                    // If there's a chained command, execute it in the new directory
+                    if (hasChainedCommand && chainedCommand) {
+                        // Recursively handle the next command
+                        await this.handleCommandModeExecution(chainedCommand);
+                    }
                     return;
                 }
                 else {
-                    // Subshell cd handling - execute via handler
-                    const result = await this.contextManager.executeCommand(command);
+                    // Subshell cd handling - execute just the cd command via handler
+                    const cdOnlyCommand = `cd ${targetDir}`;
+                    const result = await this.contextManager.executeCommand(cdOnlyCommand);
                     if (result.exitCode === 0) {
                         if (this.onResponseCallback) {
                             this.onResponseCallback(`Changed directory to: ${currentContext.metadata.workingDirectory}`);
                         }
+                        // If there's a chained command, execute it in the new directory
+                        if (hasChainedCommand && chainedCommand) {
+                            // Recursively handle the next command
+                            await this.handleCommandModeExecution(chainedCommand);
+                        }
                     }
                     else {
                         if (this.onResponseCallback) {
@@ -4026,57 +4619,118 @@ Once the user approves the plan:
                 });
             }
             else if (currentContext.type === 'docker') {
-                // Docker execution with PTY for proper TTY handling
+                // Docker execution - check if nested inside SSH
+                const parentContext = this.contextManager.getParentContext();
                 const remoteCwd = currentContext.metadata?.workingDirectory || '~';
                 const containerId = currentContext.metadata?.containerId || '';
                 let output = '';
-                await new Promise((resolve) => {
-                    const dockerPty = runDockerCommand(containerId, command, remoteCwd, (data) => {
-                        // Stream output to UI
-                        output += data;
-                        if (this.onToolStreamingOutput) {
-                            this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
-                        }
-                    }, (exitCode) => {
-                        // Notify UI of completion
-                        if (this.onToolExecutionUpdate) {
-                            if (exitCode !== 0) {
-                                this.onToolExecutionUpdate({
-                                    toolName: 'execute_command',
-                                    status: 'error',
-                                    result: output,
-                                    error: `Exit Code: ${exitCode}`,
-                                    arguments: { command, cwd: remoteCwd, remoteContext }
-                                });
+                if (parentContext && parentContext.type === 'ssh') {
+                    // Nested Docker inside SSH: route docker exec command through SSH
+                    const sshClient = parentContext.handler?.client;
+                    if (!sshClient) {
+                        throw new Error('SSH client not available for nested Docker session');
+                    }
+                    // Build docker exec command to run via SSH
+                    const escapedCommand = command.replace(/"/g, '\\"');
+                    const dockerCommand = `docker exec -w "${remoteCwd}" ${containerId} sh -c "${escapedCommand}"`;
+                    await new Promise((resolve) => {
+                        const sshPty = runSSHCommand(sshClient, dockerCommand, parentContext.metadata.workingDirectory || '~', (data) => {
+                            // Stream output to UI
+                            output += data;
+                            if (this.onToolStreamingOutput) {
+                                this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
                             }
-                            else {
-                                this.onToolExecutionUpdate({
-                                    toolName: 'execute_command',
-                                    status: 'completed',
-                                    result: output || 'Command executed successfully',
-                                    arguments: { command, cwd: remoteCwd, remoteContext }
-                                });
+                        }, (exitCode) => {
+                            // Notify UI of completion
+                            if (this.onToolExecutionUpdate) {
+                                if (exitCode !== 0) {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'error',
+                                        result: output,
+                                        error: `Exit Code: ${exitCode}`,
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
+                                else {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'completed',
+                                        result: output || 'Command executed successfully',
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
                             }
-                        }
-                        // Record shell command to AI conversation history
-                        this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
-                        this.currentInteractiveProcess = undefined;
-                        resolve();
+                            // Record shell command to AI conversation history
+                            this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
+                            this.currentInteractiveProcess = undefined;
+                            resolve();
+                        });
+                        // Set up interactive process for stdin
+                        this.currentInteractiveProcess = {
+                            process: null,
+                            write: (data) => sshPty.write(data),
+                            kill: () => sshPty.kill(),
+                            signal: (sig) => {
+                                if (sig === 'SIGINT') {
+                                    sshPty.write('\x03'); // Ctrl+C
+                                }
+                            },
+                            resize: (cols, rows) => sshPty.resize(cols, rows),
+                            isPty: true
+                        };
                     });
-                    // Set up interactive process for stdin
-                    this.currentInteractiveProcess = {
-                        process: null,
-                        write: (data) => dockerPty.write(data),
-                        kill: () => dockerPty.kill(),
-                        signal: (sig) => {
-                            if (sig === 'SIGINT') {
-                                dockerPty.write('\x03'); // Ctrl+C
+                }
+                else {
+                    // Local Docker: use standard runDockerCommand
+                    await new Promise((resolve) => {
+                        const dockerPty = runDockerCommand(containerId, command, remoteCwd, (data) => {
+                            // Stream output to UI
+                            output += data;
+                            if (this.onToolStreamingOutput) {
+                                this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
                             }
-                        },
-                        resize: (cols, rows) => dockerPty.resize(cols, rows),
-                        isPty: true
-                    };
-                });
+                        }, (exitCode) => {
+                            // Notify UI of completion
+                            if (this.onToolExecutionUpdate) {
+                                if (exitCode !== 0) {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'error',
+                                        result: output,
+                                        error: `Exit Code: ${exitCode}`,
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
+                                else {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'completed',
+                                        result: output || 'Command executed successfully',
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
+                            }
+                            // Record shell command to AI conversation history
+                            this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
+                            this.currentInteractiveProcess = undefined;
+                            resolve();
+                        });
+                        // Set up interactive process for stdin
+                        this.currentInteractiveProcess = {
+                            process: null,
+                            write: (data) => dockerPty.write(data),
+                            kill: () => dockerPty.kill(),
+                            signal: (sig) => {
+                                if (sig === 'SIGINT') {
+                                    dockerPty.write('\x03'); // Ctrl+C
+                                }
+                            },
+                            resize: (cols, rows) => dockerPty.resize(cols, rows),
+                            isPty: true
+                        };
+                    });
+                }
             }
             else if (currentContext.type === 'ssh') {
                 // SSH execution with PTY for proper TTY handling