centaurus-cli 2.9.3 → 2.9.4

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,7 +93,7 @@ export class CentaurusCLI {
     onShowChatRenamePickerCallback;
     onRestoreMessagesCallback;
     uiMessageHistory = []; // Mirror of App.tsx's messageHistory for saving
-    localCwdBeforeRemote = null; // Track local CWD before entering remote session
+    cwdStack = []; // Stack of CWDs for nested sessions (pushed when entering, popped when exiting)
     lastConnectionCommand = null; // Track the command used to connect to remote
     onBackgroundModeChange;
     onBackgroundTaskCountChange;
@@ -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.lastConnectionCommand = 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.lastConnectionCommand = null;
+        }
+        // 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.lastConnectionCommand = null;
+        }
+        // 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()) {
@@ -3312,7 +3866,7 @@ Then try /models local again.`;
                 type: currentContext.type,
                 connectionCommand: this.lastConnectionCommand,
                 remoteCwd: currentContext.metadata.workingDirectory,
-                localCwdBeforeRemote: this.localCwdBeforeRemote || process.cwd(),
+                localCwdBeforeRemote: this.cwdStack.length > 0 ? this.cwdStack[0] : process.cwd(),
                 metadata: {
                     hostname: currentContext.metadata.hostname,
                     username: currentContext.metadata.username,
@@ -3322,9 +3876,9 @@ Then try /models local again.`;
                 }
             };
         }
-        // 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);
@@ -3415,7 +3969,7 @@ Then try /models local again.`;
             // Pop context to return to local
             this.contextManager.popContext();
             // Clear remote context tracking
-            this.localCwdBeforeRemote = null;
+            this.cwdStack = [];
             this.lastConnectionCommand = null;
         }
         // Load AI context
@@ -3443,8 +3997,8 @@ Then try /models local again.`;
         // 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;
+            // Store local CWD for when user exits remote (as base of stack)
+            this.cwdStack = [localCwdBeforeRemote];
             this.lastConnectionCommand = connectionCommand;
             // Show reconnection notification
             if (this.onDirectMessageCallback) {
@@ -3489,7 +4043,7 @@ Then try /models local again.`;
             }
             catch (error) {
                 // Connection failed - fall back to local mode
-                this.localCwdBeforeRemote = null;
+                this.cwdStack = [];
                 this.lastConnectionCommand = null;
                 if (this.onConnectionStatusUpdate) {
                     this.onConnectionStatusUpdate({
@@ -3552,7 +4106,7 @@ Then try /models local again.`;
         this.currentChatId = null;
         this.conversationStarted = false;
         this.uiMessageHistory = [];
-        this.localCwdBeforeRemote = null;
+        this.cwdStack = [];
         this.lastConnectionCommand = null;
         // Reset context limit state
         if (this.contextLimitReached) {
@@ -3689,45 +4243,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
@@ -3769,20 +4284,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.lastConnectionCommand = null;
+                    }
+                    // Save chat - include remote context info if still in remote
                     this.saveCurrentChat();
                     if (this.onResponseCallback) {
                         this.onResponseCallback('✅ Exited subshell');
@@ -3790,80 +4317,19 @@ 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+(.+)$/);
             if (cdMatch) {