centaurus-cli 2.9.2 → 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';
@@ -42,6 +44,8 @@ import { localChatStorage } from './services/local-chat-storage.js';
 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;
@@ -89,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;
@@ -110,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();
@@ -119,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
@@ -217,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
@@ -441,25 +800,48 @@ export class CentaurusCLI {
     }
     async handlePickerSelection(selection, pickerType) {
         try {
-            // Selection is the index of the model in models array from backend
-            const modelsConfig = await fetchModelsConfig();
-            const modelIndex = parseInt(selection, 10);
-            if (isNaN(modelIndex) || modelIndex < 0 || modelIndex >= modelsConfig.models.length) {
-                throw new Error('Invalid model selection');
-            }
-            const selectedModel = modelsConfig.models[modelIndex];
-            // Store only the model ID and name (not the full config with thinkingConfig)
-            // This prevents caching issues when we update model configs
-            this.configManager.set('model', selectedModel.id);
-            this.configManager.set('modelName', selectedModel.name);
-            // Notify UI of model name change and contextWindow
-            if (this.onModelChange) {
-                this.onModelChange(selectedModel.name, selectedModel.contextWindow);
-            }
-            const responseMessage = `Model changed to: ${selectedModel.name}`;
-            // Send response back to UI
-            if (this.onResponseCallback) {
-                this.onResponseCallback(responseMessage);
+            if (pickerType === 'local-model') {
+                // Local Ollama model selection
+                // Selection is the model name (e.g., "llama3:latest")
+                const modelName = selection;
+                // Store the local model configuration
+                this.configManager.set('model', modelName);
+                this.configManager.set('modelName', modelName);
+                this.configManager.set('isLocalModel', true);
+                // Notify UI of model name change
+                // Local models don't have a fixed context window, use a reasonable default
+                if (this.onModelChange) {
+                    this.onModelChange(modelName, 128000); // Most local models have 128k context
+                }
+                const responseMessage = `✅ Switched to local Ollama model: ${modelName}`;
+                // Send response back to UI
+                if (this.onResponseCallback) {
+                    this.onResponseCallback(responseMessage);
+                }
+            }
+            else {
+                // Cloud model selection (existing behavior)
+                // Selection is the index of the model in models array from backend
+                const modelsConfig = await fetchModelsConfig();
+                const modelIndex = parseInt(selection, 10);
+                if (isNaN(modelIndex) || modelIndex < 0 || modelIndex >= modelsConfig.models.length) {
+                    throw new Error('Invalid model selection');
+                }
+                const selectedModel = modelsConfig.models[modelIndex];
+                // Store only the model ID and name (not the full config with thinkingConfig)
+                // This prevents caching issues when we update model configs
+                this.configManager.set('model', selectedModel.id);
+                this.configManager.set('modelName', selectedModel.name);
+                this.configManager.set('isLocalModel', false);
+                // Notify UI of model name change and contextWindow
+                if (this.onModelChange) {
+                    this.onModelChange(selectedModel.name, selectedModel.contextWindow);
+                }
+                const responseMessage = `✅ Switched to cloud model: ${selectedModel.name}`;
+                // Send response back to UI
+                if (this.onResponseCallback) {
+                    this.onResponseCallback(responseMessage);
+                }
             }
         }
         catch (error) {
@@ -474,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();
@@ -550,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) => {
@@ -659,41 +1048,69 @@ Press Enter to continue...
     }
     /**
      * Clean up orphaned tool_calls from conversation history.
-     * This is called when a request is aborted to ensure the history remains consistent.
-     * Vertex AI requires that every assistant message with tool_calls has matching tool result messages.
+     * This validates the ENTIRE history and removes any assistant messages
+     * where tool_calls don't have matching tool result messages.
+     *
+     * Vertex AI / Claude APIs require that every assistant message with tool_calls
+     * has matching tool result messages immediately following it.
      */
     cleanupOrphanedToolCalls() {
         if (this.conversationHistory.length === 0)
             return;
-        // Find the last assistant message with tool_calls
-        let lastAssistantWithToolCallsIndex = -1;
-        for (let i = this.conversationHistory.length - 1; i >= 0; i--) {
-            const msg = this.conversationHistory[i];
-            if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
-                lastAssistantWithToolCallsIndex = i;
-                break;
+        let cleanedAny = false;
+        let iterations = 0;
+        const maxIterations = 20; // Safety limit to prevent infinite loops
+        // Keep cleaning until no more orphans are found
+        // (removing one orphan may expose another)
+        while (iterations < maxIterations) {
+            iterations++;
+            let foundOrphan = false;
+            // Scan through history to find ALL assistant messages with tool_calls
+            for (let i = 0; i < this.conversationHistory.length; i++) {
+                const msg = this.conversationHistory[i];
+                if (msg.role !== 'assistant' || !msg.tool_calls || msg.tool_calls.length === 0) {
+                    continue;
+                }
+                // Collect all tool_call IDs from this assistant message
+                const expectedToolCallIds = new Set(msg.tool_calls.map((tc) => tc.id));
+                // Check if ALL tool_calls have matching tool result messages after this message
+                // Tool results must come AFTER the assistant message, before the next user/assistant message
+                let j = i + 1;
+                while (j < this.conversationHistory.length) {
+                    const nextMsg = this.conversationHistory[j];
+                    // If we hit a user or assistant message, stop looking for tool results
+                    if (nextMsg.role === 'user' || nextMsg.role === 'assistant') {
+                        break;
+                    }
+                    // If it's a tool result, check if it matches one of our expected IDs
+                    if (nextMsg.role === 'tool' && nextMsg.tool_call_id) {
+                        expectedToolCallIds.delete(nextMsg.tool_call_id);
+                    }
+                    j++;
+                }
+                // If there are still unmatched tool_calls, this is an orphan
+                if (expectedToolCallIds.size > 0) {
+                    try {
+                        quickLog(`[${new Date().toISOString()}] [CLI] Found orphaned tool_calls at index ${i}: ${Array.from(expectedToolCallIds).join(', ')}\n`);
+                    }
+                    catch (e) { }
+                    // Remove this assistant message and all tool results up to (but not including) the next user/assistant message
+                    const removeCount = j - i;
+                    this.conversationHistory.splice(i, removeCount);
+                    foundOrphan = true;
+                    cleanedAny = true;
+                    break; // Restart scan from beginning since indices changed
+                }
             }
-        }
-        if (lastAssistantWithToolCallsIndex === -1)
-            return; // No assistant messages with tool_calls
-        const assistantMsg = this.conversationHistory[lastAssistantWithToolCallsIndex];
-        const toolCallIds = new Set(assistantMsg.tool_calls.map((tc) => tc.id));
-        // Check if all tool_calls have matching tool result messages after this assistant message
-        for (let i = lastAssistantWithToolCallsIndex + 1; i < this.conversationHistory.length; i++) {
-            const msg = this.conversationHistory[i];
-            if (msg.role === 'tool' && msg.tool_call_id) {
-                toolCallIds.delete(msg.tool_call_id);
+            if (!foundOrphan) {
+                break; // No more orphans found, we're done
             }
         }
-        // If there are orphaned tool_calls (no matching tool results), remove from history
-        if (toolCallIds.size > 0) {
-            // Log the cleanup for debugging
+        if (cleanedAny) {
             try {
-                quickLog(`[${new Date().toISOString()}] [CLI] Cleaning up orphaned tool_calls: ${Array.from(toolCallIds).join(', ')}\n`);
+                quickLog(`[${new Date().toISOString()}] [CLI] Completed history cleanup after ${iterations} iteration(s), ${this.conversationHistory.length} messages remaining\n`);
             }
             catch (e) { }
-            // Remove the orphaned assistant message and any partial tool results after it
-            this.conversationHistory.splice(lastAssistantWithToolCallsIndex);
         }
     }
     /**
@@ -717,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;
         }
@@ -733,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.');
@@ -780,8 +1210,27 @@ Press Enter to continue...
         // Cancel any active request when a new message comes in
         // This enables "interrupt and replace" - new message takes priority
         if (this.currentAbortController) {
-            this.currentAbortController.abort();
-            this.currentAbortController = undefined;
+            // Mark as intentionally aborted so error handling knows not to throw or show message
+            this.requestIntentionallyAborted = true;
+            const oldController = this.currentAbortController;
+            // Create new controller BEFORE aborting old one to avoid race condition
+            // where new request tries to access undefined controller
+            this.currentAbortController = new AbortController();
+            oldController.abort();
+            // Clean up orphaned tool calls from the interrupted turn
+            this.cleanupOrphanedToolCalls();
+            // Remove the last user message from history (it's being replaced by the new message)
+            // Walk backwards and remove messages until we find and remove a user message
+            while (this.conversationHistory.length > 0) {
+                const lastMsg = this.conversationHistory[this.conversationHistory.length - 1];
+                this.conversationHistory.pop();
+                if (lastMsg.role === 'user') {
+                    // Found and removed the interrupted user message, stop here
+                    break;
+                }
+                // Continue removing assistant/tool messages that were part of the interrupted turn
+            }
+            quickLog(`[${new Date().toISOString()}] [handleMessage] Interrupted active request - cleaned up history for replacement\n`);
         }
         // Store original request if in planning mode (for execution phase after approval)
         if (this.planMode && !this.pendingPlanRequest) {
@@ -816,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
@@ -857,7 +1315,10 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             // Build messages array WITHOUT system prompt - backend will inject it
             // The backend uses cli-system-prompt.md for CLI clients
             // We pass environmentContext and mode separately so backend can inject them
-            let messages = [...this.conversationHistory];
+            // SAFETY: Clean up any orphaned tool calls before making AI request
+            // This prevents "improperly formed request" errors from corrupted history
+            this.cleanupOrphanedToolCalls();
+            let messages = getMessagesForContext();
             // Inject subshell context if in a subshell environment
             const currentContext = this.contextManager.getCurrentContext();
             messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
@@ -879,9 +1340,12 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             // ANTI-LOOP: Track ALL duplicate tool calls (not just file ops)
             const toolCallTracker = new Map(); // Hash -> count
             const MAX_IDENTICAL_TOOL_CALLS = 3; // Max times exact same tool call allowed
-            // Create AbortController for this request
-            this.currentAbortController = new AbortController();
-            this.requestIntentionallyAborted = false; // Reset abort flag for new request
+            // Create AbortController for this request (if not already created during interruption handling)
+            if (!this.currentAbortController) {
+                this.currentAbortController = new AbortController();
+            }
+            // Note: Don't reset requestIntentionallyAborted here - let the error handler reset it
+            // to avoid race condition where old request's error handler sees false
             // Clean up any orphaned tool_calls from a previous aborted request
             // This prevents 400 Bad Request errors when sending to the backend
             this.cleanupOrphanedToolCalls();
@@ -960,7 +1424,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 });
                 // Stream AI response from backend
                 // Backend will inject system prompt automatically with environment context
-                for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode, selectedModelThinkingConfig, this.currentAbortController.signal)) {
+                for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode, selectedModelThinkingConfig, this.currentAbortController?.signal)) {
                     // Handle error chunks
                     if (chunk.type === 'error') {
                         // Check if this is an abort situation (user cancelled or sent new message)
@@ -1303,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;
                                             }
@@ -1368,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 {
@@ -1392,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;
                             }
@@ -1459,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;
                                             }
                                         }
@@ -1801,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);
@@ -1844,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)
@@ -1865,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
@@ -1910,8 +2374,14 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
         catch (error) {
             // Log the error
             conversationLogger.logError('handleMessage', error);
-            // Check if this was an abort/cancellation
-            if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+            // Check if this was an abort/cancellation (including timeout errors from aborted requests)
+            if (error.name === 'AbortError' || error.message?.includes('aborted') || error.message?.includes('timed out') || this.requestIntentionallyAborted) {
+                // If intentionally aborted for replacement by new message, return silently
+                // The new message will take over - no need to show cancellation message
+                if (this.requestIntentionallyAborted) {
+                    this.requestIntentionallyAborted = false;
+                    return;
+                }
                 conversationLogger.logError('handleMessage', new Error('Request cancelled by user'));
                 if (this.onResponseCallback) {
                     this.onResponseCallback('⚠️ Request cancelled by user.');
@@ -2193,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' +
@@ -2271,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
@@ -2323,43 +2803,126 @@ Start by listing the directory structure to understand what you're working with.
                         `Model: ${config.model || 'gemini-2.5-flash (default)'}\n` +
                         `Enhanced Quality: ${config.enhancedQuality !== false ? '✅ Enabled' : '❌ Disabled'}\n` +
                         `Autonomous Mode: ${config.autonomousMode === true ? '✅ Enabled' : '❌ Disabled'}\n` +
+                        `AI Auto-Suggest: ${config.aiAutoSuggest === true ? '✅ Enabled' : '❌ Disabled'}\n` +
                         `Authentication: ${apiClient.isAuthenticated() ? '✅ Signed in' : '❌ Not signed in'}`;
                 }
                 break;
+            case 'settings':
+                if (args.length >= 2 && args[0].toLowerCase() === 'auto-suggest') {
+                    // Handle /settings auto-suggest <on/off>
+                    const value = args[1].toLowerCase();
+                    if (value === 'on') {
+                        this.configManager.set('aiAutoSuggest', true);
+                        responseMessage = '✅ **AI Auto-Suggestions Enabled**\n\n' +
+                            'From now on, I will suggest commands after 5 seconds of inactivity.\n' +
+                            'Suggestions will appear in grey text. Use the **Right Arrow** key to accept them.';
+                    }
+                    else if (value === 'off') {
+                        this.configManager.set('aiAutoSuggest', false);
+                        responseMessage = '✅ **AI Auto-Suggestions Disabled**\n\n' +
+                            'I will no longer provide AI-powered command suggestions.';
+                    }
+                    else {
+                        responseMessage = '❌ Invalid option. Usage: `/settings auto-suggest on` or `/settings auto-suggest off`';
+                    }
+                }
+                else {
+                    responseMessage = '❌ Invalid command format.\n\nUsage:\n- `/settings auto-suggest on`\n- `/settings auto-suggest off`';
+                }
+                break;
             case 'model':
-                if (args.length === 0) {
-                    // Show picker for model selection
+            case 'models':
+                // Handle subcommands: local, cloud
+                const modelSubCommand = args[0]?.toLowerCase();
+                if (modelSubCommand === 'local') {
+                    // Local Ollama models
+                    try {
+                        // Check if Ollama is running
+                        const status = await ollamaService.isOllamaRunning();
+                        if (!status.available) {
+                            responseMessage = `❌ Cannot connect to Ollama
+
+${status.error || 'Ollama is not running.'}
+
+To use local models:
+1. Install Ollama from: https://ollama.ai
+2. Start Ollama by running: ollama serve
+3. Pull a model: ollama pull llama3
+
+Then try /models local again.`;
+                            break;
+                        }
+                        // Get available local models
+                        const localModels = await ollamaService.getLocalModels();
+                        if (localModels.length === 0) {
+                            responseMessage = `📭 No local models found
+
+Ollama is running (v${status.version}) but no models are downloaded.
+
+To download models, run:
+  ollama pull llama3
+  ollama pull codellama
+  ollama pull mistral
+
+Then try /models local again.`;
+                            break;
+                        }
+                        // Show picker for local model selection
+                        if (this.onShowPickerCallback) {
+                            const config = this.configManager.load();
+                            const currentModelName = config.modelName || '';
+                            const isCurrentLocal = config.isLocalModel === true;
+                            this.onShowPickerCallback({
+                                message: 'Select Local Model (Ollama)',
+                                type: 'local-model', // Cast to bypass type check, will be handled in handlePickerSelection
+                                choices: localModels.map((model) => {
+                                    const size = OllamaService.formatModelSize(model.size);
+                                    const isCurrent = isCurrentLocal && currentModelName === model.name;
+                                    const supportsTools = OllamaService.modelSupportsTools(model.name);
+                                    const toolsBadge = supportsTools ? ' [Tools]' : '';
+                                    return {
+                                        label: `${model.name} (${size})${toolsBadge}${isCurrent ? ' [CURRENT]' : ''}`,
+                                        value: model.name
+                                    };
+                                })
+                            });
+                            return; // Don't send a text response, picker will handle it
+                        }
+                    }
+                    catch (error) {
+                        responseMessage = OllamaService.getHelpfulErrorMessage(error);
+                    }
+                    break;
+                }
+                if (modelSubCommand === 'cloud' || args.length === 0) {
+                    // Cloud models (default behavior when no subcommand or 'cloud' specified)
                     if (this.onShowPickerCallback) {
                         const config = this.configManager.load();
                         const currentModelName = config.modelName || '';
+                        const isCurrentCloud = config.isLocalModel !== true;
                         // Fetch models from backend
                         const modelsConfig = await fetchModelsConfig();
                         this.onShowPickerCallback({
-                            message: 'Select Model',
+                            message: '☁️ Select Cloud Model',
                             type: 'model',
-                            choices: modelsConfig.models.map((modelConfig, index) => ({
-                                label: `${modelConfig.name} - ${modelConfig.description}${currentModelName === modelConfig.name ? ' [CURRENT]' : ''}`,
-                                value: `${index}` // Use index as unique identifier
-                            }))
+                            choices: modelsConfig.models.map((modelConfig, index) => {
+                                const isCurrent = isCurrentCloud && currentModelName === modelConfig.name;
+                                return {
+                                    label: `${modelConfig.name} - ${modelConfig.description}${isCurrent ? ' [CURRENT]' : ''}`,
+                                    value: `${index}` // Use index as unique identifier
+                                };
+                            })
                         });
                         return; // Don't send a text response, picker will handle it
                     }
                 }
                 else {
-                    // Direct set via command argument
-                    const newModel = args.join(' ');
-                    // Validate model (async)
-                    if (!(await isValidModel(newModel))) {
-                        responseMessage = `❌ ${await getInvalidModelError(newModel)}`;
-                        break;
-                    }
-                    try {
-                        this.configManager.set('model', newModel);
-                        responseMessage = `✅ Model changed to: ${newModel}`;
-                    }
-                    catch (error) {
-                        responseMessage = `❌ Failed to set model: ${error.message}`;
-                    }
+                    // Unrecognized subcommand - show help
+                    responseMessage = `Usage: /models [local|cloud]
+
+  /models local  - Select from locally installed Ollama models
+  /models cloud  - Select from cloud models (Centaurus backend)
+  /models        - Default: show cloud models`;
                 }
                 break;
             case 'mcp':
@@ -2372,7 +2935,7 @@ Start by listing the directory structure to understand what you're working with.
                 break;
             case 'docs':
                 // Open documentation URL in default browser
-                const docsUrl = 'https://www.centauruslabs.in/docs';
+                const docsUrl = 'https://centauruslabs.in/docs';
                 const { exec } = await import('child_process');
                 const platform = process.platform;
                 if (platform === 'win32') {
@@ -2626,6 +3189,163 @@ Start by listing the directory structure to understand what you're working with.
                         '  /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()) {
@@ -3146,7 +3866,7 @@ Start by listing the directory structure to understand what you're working with.
                 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,
@@ -3156,9 +3876,9 @@ Start by listing the directory structure to understand what you're working with.
                 }
             };
         }
-        // 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);
@@ -3216,6 +3936,10 @@ Start by listing the directory structure to understand what you're working with.
         this.updateTokenCount().catch(err => {
             quickLog(`[${new Date().toISOString()}] [loadChatFromPicker] Failed to update token count: ${err}\n`);
         });
+        // Clean up any orphaned tool calls from previous interrupted sessions
+        // This prevents "improperly formed request" errors when continuing conversations
+        this.cleanupOrphanedToolCalls();
+        quickLog(`[${new Date().toISOString()}] [loadChat] Cleaned up conversation history after load\n`);
         return true;
     }
     /**
@@ -3245,7 +3969,7 @@ Start by listing the directory structure to understand what you're working with.
             // Pop context to return to local
             this.contextManager.popContext();
             // Clear remote context tracking
-            this.localCwdBeforeRemote = null;
+            this.cwdStack = [];
             this.lastConnectionCommand = null;
         }
         // Load AI context
@@ -3273,8 +3997,8 @@ Start by listing the directory structure to understand what you're working with.
         // 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) {
@@ -3319,7 +4043,7 @@ Start by listing the directory structure to understand what you're working with.
             }
             catch (error) {
                 // Connection failed - fall back to local mode
-                this.localCwdBeforeRemote = null;
+                this.cwdStack = [];
                 this.lastConnectionCommand = null;
                 if (this.onConnectionStatusUpdate) {
                     this.onConnectionStatusUpdate({
@@ -3382,7 +4106,7 @@ Start by listing the directory structure to understand what you're working with.
         this.currentChatId = null;
         this.conversationStarted = false;
         this.uiMessageHistory = [];
-        this.localCwdBeforeRemote = null;
+        this.cwdStack = [];
         this.lastConnectionCommand = null;
         // Reset context limit state
         if (this.contextLimitReached) {
@@ -3519,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
@@ -3599,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');
@@ -3620,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) {