centaurus-cli 2.8.6 → 2.8.8

package/dist/cli-adapter.js

@@ -13,9 +13,10 @@ import { grepSearchTool } from './tools/grep-search.js';
 import { findFilesTool } from './tools/find-files.js';
 import { getDiffTool } from './tools/get-diff.js';
 import { inspectSymbolTool } from './tools/inspect-symbol.js';
-import { createPlanTool, markTaskCompleteTool, getCurrentPlan, clearPlan, approvePlan, getPlanContextForPrompt } from './tools/plan-mode.js';
+import { createPlanTool, markTaskCompleteTool, getCurrentPlan, clearPlan, approvePlan, getPhaseContextForPrompt, getCurrentPhase } from './tools/plan-mode.js';
 import { webSearchTool, fetchUrlTool } from './tools/web-search.js';
 import { taskCompleteTool } from './tools/task-complete.js';
+import { readBinaryFileTool } from './tools/read-binary-file.js';
 import { apiClient } from './services/api-client.js';
 import { conversationManager } from './services/conversation-manager.js';
 import { aiServiceClient } from './services/ai-service-client.js';
@@ -32,6 +33,8 @@ import { MCPServerManager } from './mcp/mcp-server-manager.js';
 import { MCPCommandHandler } from './mcp/mcp-command-handler.js';
 import { isInteractiveEditorCommand, runWSLCommand, runDockerCommand, runSSHCommand } from './utils/editor-utils.js';
 import { conversationLogger } from './utils/conversation-logger.js';
+import { localChatStorage } from './services/local-chat-storage.js';
+import { logWarning } from './utils/logger.js';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
@@ -69,6 +72,15 @@ export class CentaurusCLI {
     mcpCommandHandler;
     onInteractiveEditorMode;
     onConnectionStatusUpdate;
+    currentChatId = null;
+    onShowChatPickerCallback;
+    onShowChatDeletePickerCallback;
+    onShowChatListCallback;
+    onShowChatRenamePickerCallback;
+    onRestoreMessagesCallback;
+    uiMessageHistory = []; // Mirror of App.tsx's messageHistory for saving
+    localCwdBeforeRemote = null; // Track local CWD before entering remote session
+    lastConnectionCommand = null; // Track the command used to connect to remote
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -163,7 +175,7 @@ export class CentaurusCLI {
             await this.mcpCommandHandler.initializeMCP();
         }
         catch (error) {
-            console.error('Failed to initialize MCP:', error);
+            logWarning(`Failed to initialize MCP: ${error?.message || error}`);
         }
     }
     writeToShellStdin(input) {
@@ -209,6 +221,12 @@ export class CentaurusCLI {
     getCurrentSubshellContext() {
         return this.contextManager.getCurrentContext();
     }
+    /**
+     * Get the current conversation ID for file uploads
+     */
+    getCurrentConversationId() {
+        return conversationManager.getCurrentConversationId();
+    }
     async handlePickerSelection(selection, pickerType) {
         try {
             // Selection is the index of the model in ALL_MODELS array
@@ -316,6 +334,7 @@ export class CentaurusCLI {
         this.toolRegistry.register(webSearchTool);
         this.toolRegistry.register(fetchUrlTool);
         this.toolRegistry.register(taskCompleteTool);
+        this.toolRegistry.register(readBinaryFileTool);
         // Load configuration
         const config = this.configManager.load();
         // Enable backend sync if authenticated
@@ -382,6 +401,12 @@ Press Enter to continue...
         if (this.conversationStarted || !apiClient.isAuthenticated()) {
             return;
         }
+        // Check if conversationManager already has a conversation (e.g., created by App.tsx for image upload)
+        // This prevents duplicate conversation creation
+        if (conversationManager.getCurrentConversationId()) {
+            this.conversationStarted = true;
+            return;
+        }
         try {
             const config = this.configManager.load();
             const title = `Conversation ${new Date().toLocaleString()}`;
@@ -492,12 +517,32 @@ Press Enter to continue...
         if (this.planMode && !this.pendingPlanRequest) {
             this.pendingPlanRequest = message;
         }
+        // Build the user message content - inject plan mode instructions if active
+        let userMessageContent = message;
+        // When plan mode is active, explicitly inject planning instructions into the user message
+        // This ensures the AI creates a plan even when toggled mid-conversation
+        if (this.planMode && !getCurrentPlan()?.isActive) {
+            const planModePrefix = `[PLAN MODE ACTIVE - You MUST call create_plan first before any implementation tools]
+
+User Request: ${message}
+
+CRITICAL INSTRUCTIONS:
+1. You are in PLANNING MODE - DO NOT implement anything directly
+2. First explore the codebase using view_file, list_dir, grep_search to understand the context
+3. Then call create_plan with a detailed plan including:
+   - designSummary: Your understanding of the codebase
+   - tasks: Hierarchical tasks with subtasks
+4. Wait for user approval before implementing
+
+DO NOT use write_to_file, edit_file, or execute_command until the plan is approved.`;
+            userMessageContent = planModePrefix;
+        }
         // Add user message to history
         this.conversationHistory.push({
             role: 'user',
-            content: message,
+            content: userMessageContent,
         });
-        // Save user message to backend
+        // Save user message to backend (save original message for display, not the prefixed version)
         await this.saveMessageToBackend('user', message);
         // Start logging session and log user message
         conversationLogger.startSession();
@@ -712,7 +757,10 @@ Press Enter to continue...
                 if (toolCalls.length > 0) {
                     // CRITICAL: AI should ONLY communicate via reason_text and task_complete summary
                     // Any text output alongside tool calls should be suppressed
-                    if (assistantMessage && assistantMessage.trim()) {
+                    // EXCEPTION: If task_complete is in the tool calls, preserve assistantMessage 
+                    // because task_complete can have an empty summary and rely on streamed text
+                    const hasTaskComplete = toolCalls.some(tc => tc.name === 'task_complete');
+                    if (assistantMessage && assistantMessage.trim() && !hasTaskComplete) {
                         // Suppress text output - AI should only use reason_text
                         assistantMessage = ''; // Clear ALL text output - AI should only use reason_text
                     }
@@ -739,13 +787,17 @@ Press Enter to continue...
                                 taskCompleted = true;
                                 taskCompleteSummary = toolCall.arguments.summary || '';
                                 conversationLogger.logTaskComplete(taskCompleteSummary);
-                                // CRITICAL: Suppress any text that came before task_complete in this turn
-                                // The AI should ONLY communicate through the task_complete summary
-                                assistantMessage = '';
-                                // Stream the summary to UI so it's visible
-                                if (taskCompleteSummary && this.onResponseStreamCallback) {
-                                    this.onResponseStreamCallback(taskCompleteSummary);
+                                // If task_complete has a summary, use that as the final message
+                                // If no summary provided, PRESERVE the already-streamed assistantMessage text
+                                if (taskCompleteSummary) {
+                                    // AI provided a summary - suppress any other text and use the summary
+                                    assistantMessage = '';
+                                    // Stream the summary to UI so it's visible
+                                    if (this.onResponseStreamCallback) {
+                                        this.onResponseStreamCallback(taskCompleteSummary);
+                                    }
                                 }
+                                // If no summary, keep assistantMessage as-is (it was already streamed to UI)
                                 // Execute the tool for proper result handling
                                 await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                                 // Clear the plan when task is complete
@@ -794,10 +846,11 @@ Press Enter to continue...
                                                 });
                                                 // Mark this tool call as handled so it's not duplicated
                                                 handledToolCallIds.add(toolCall.id);
-                                                // Add user message that includes plan context for execution phase
-                                                const planContext = getPlanContextForPrompt();
+                                                // Add user message that includes ONLY current phase context for execution
+                                                // This implements phased execution - AI only sees one task at a time
+                                                const phaseContext = getPhaseContextForPrompt();
                                                 const originalRequest = this.pendingPlanRequest || message;
-                                                const executionPrompt = `${planContext}\n\nOriginal Request: ${originalRequest}\n\nProceed with task 1. After completing each task, call mark_task_complete with the task number.`;
+                                                const executionPrompt = `${phaseContext}\n\nOriginal Request: ${originalRequest}\n\nComplete the current task. After finishing each subtask, call mark_task_complete with the subtask number (e.g., "1.1"). When all subtasks are done, the main task will automatically complete and you'll receive the next task.`;
                                                 this.conversationHistory.push({
                                                     role: 'user',
                                                     content: executionPrompt,
@@ -842,7 +895,7 @@ Press Enter to continue...
                                     }
                                     catch (parseError) {
                                         // Log error and add error result to history so AI knows
-                                        console.error('Failed to parse plan:', parseError);
+                                        logWarning(`Failed to parse plan: ${parseError?.message || parseError}`);
                                         // CRITICAL: Add tool result even on parse error to prevent silent loop
                                         this.conversationHistory.push({
                                             role: 'assistant',
@@ -887,20 +940,66 @@ Press Enter to continue...
                                     const completionJson = result.substring('TASK_COMPLETED:'.length);
                                     try {
                                         const completion = JSON.parse(completionJson);
-                                        const currentPlan = getCurrentPlan();
-                                        if (currentPlan && this.onTaskCompleted) {
-                                            const task = currentPlan.steps[completion.taskNumber - 1];
-                                            this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote);
+                                        const currentPlanData = getCurrentPlan();
+                                        if (currentPlanData && this.onTaskCompleted) {
+                                            // Handle both main task completion and subtask completion
+                                            const taskNumParts = String(completion.taskNumber).split('.');
+                                            const mainTaskNum = parseInt(taskNumParts[0], 10) - 1;
+                                            const task = currentPlanData.steps[mainTaskNum];
+                                            if (task) {
+                                                this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote);
+                                            }
+                                        }
+                                        // Notify UI about completed task/subtask
+                                        const displayType = completion.type === 'subtask' ? 'Subtask' : 'Task';
+                                        this.notifyToolStatus(toolCall.name, 'completed', toolCall.arguments, `${displayType} ${completion.taskNumber} of ${completion.totalCount} completed: ${completion.taskDescription}`);
+                                        // Check if we need to advance to next phase (when main task is complete)
+                                        if (completion.mainTaskComplete || completion.type === 'task') {
+                                            // A main task is complete - check if there's a next phase
+                                            const nextPhase = getCurrentPhase();
+                                            if (nextPhase && !completion.allComplete) {
+                                                // Inject next phase context for the AI
+                                                const phaseContext = getPhaseContextForPrompt();
+                                                // Add tool result for current task
+                                                toolResults.push({
+                                                    tool_call_id: toolCall.id,
+                                                    name: toolCall.name,
+                                                    result: `Task completed. Moving to Task ${nextPhase.taskNumber}: ${nextPhase.task.description}`,
+                                                });
+                                                // Add the tool call and result to history
+                                                this.conversationHistory.push({
+                                                    role: 'assistant',
+                                                    content: '',
+                                                    tool_calls: [toolCall],
+                                                });
+                                                this.conversationHistory.push({
+                                                    role: 'tool',
+                                                    tool_call_id: toolCall.id,
+                                                    content: `Task completed. Now starting Task ${nextPhase.taskNumber}.`,
+                                                });
+                                                // Add next phase instructions
+                                                this.conversationHistory.push({
+                                                    role: 'user',
+                                                    content: `${phaseContext}\n\nContinue with the next task. Complete each subtask and call mark_task_complete for each one.`,
+                                                });
+                                                // Mark as handled
+                                                handledToolCallIds.add(toolCall.id);
+                                                // Update messages and continue
+                                                messages = [...this.conversationHistory];
+                                                continue;
+                                            }
                                         }
-                                        // Notify UI about completed task
-                                        this.notifyToolStatus(toolCall.name, 'completed', toolCall.arguments, `Task ${completion.taskNumber} of ${completion.totalCount} completed: ${completion.taskDescription}`);
-                                        // Add to tool results
+                                        // Add to tool results for subtask completion or final completion
                                         toolResults.push({
                                             tool_call_id: toolCall.id,
                                             name: toolCall.name,
                                             result: completion.allComplete
-                                                ? 'All tasks completed! Call task_complete with a summary.'
-                                                : `Task ${completion.taskNumber} completed. Next: ${completion.nextTask}`,
+                                                ? 'All tasks completed! Call task_complete with a summary of what was accomplished.'
+                                                : completion.nextSubtask
+                                                    ? `Subtask ${completion.taskNumber} completed. Next subtask: ${completion.nextSubtask}`
+                                                    : completion.nextTask
+                                                        ? `Task ${completion.taskNumber} completed. Next: ${completion.nextTask}`
+                                                        : `Task ${completion.taskNumber} completed.`,
                                         });
                                         // If all tasks are complete, prompt AI to call task_complete
                                         if (completion.allComplete) {
@@ -909,7 +1008,7 @@ Press Enter to continue...
                                         }
                                     }
                                     catch (parseError) {
-                                        console.error('Failed to parse task completion:', parseError);
+                                        logWarning(`Failed to parse task completion: ${parseError?.message || parseError}`);
                                     }
                                 }
                                 continue;
@@ -1099,8 +1198,8 @@ Press Enter to continue...
                     }
                     // If task_complete was called, stop the agentic loop immediately
                     if (taskCompleted) {
-                        // Set the final message to the summary from task_complete
-                        finalAssistantMessage = taskCompleteSummary;
+                        // Set the final message: use summary if provided, otherwise use the streamed assistantMessage
+                        finalAssistantMessage = taskCompleteSummary || assistantMessage;
                         break;
                     }
                     // If user cancelled an operation, stop the agentic loop immediately
@@ -1361,6 +1460,8 @@ Press Enter to continue...
                 // Save assistant message to backend
                 await this.saveMessageToBackend('assistant', finalMessage);
             } // End of while loop
+            // Auto-save conversation to local storage
+            this.saveCurrentChat();
             // Log session end
             conversationLogger.endSession(finalAssistantMessage, turnCount);
             // Send response back to UI (only if there's a message)
@@ -1396,7 +1497,8 @@ Press Enter to continue...
                 responseMessage = `Available Commands:\n\n` +
                     `/help       - Show this help message\n` +
                     `/init       - Analyze project and create/load centaurus.md context file\n` +
-                    `/clear      - Clear conversation history\n` +
+                    `/chat       - Manage chat sessions (resume previous chats)\n` +
+                    `/clear      - Clear conversation and start a new chat\n` +
                     `/config     - View current configuration\n` +
                     `/model      - Select from available Google models\n` +
                     `/plan       - Toggle plan mode for complex implementations\n` +
@@ -1702,8 +1804,8 @@ Start by listing the directory structure to understand what you're working with.
                         '• Manual completion detection';
                 break;
             case 'clear':
-                this.conversationHistory = [];
-                this.conversationStarted = false;
+                // 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
                 return;
             case 'config':
@@ -1803,7 +1905,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://centaurus-web.vercel.app/docs';
+                const docsUrl = 'https://www.centauruslabs.in/docs';
                 const { exec } = await import('child_process');
                 const platform = process.platform;
                 if (platform === 'win32') {
@@ -1817,9 +1919,171 @@ Start by listing the directory structure to understand what you're working with.
                 }
                 responseMessage = `📖 Opening documentation in your browser...\n\n${docsUrl}`;
                 break;
+            case 'chat':
+                // Chat management commands
+                const chatSubCommand = args[0]?.toLowerCase();
+                if (chatSubCommand === 'resume' || !chatSubCommand) {
+                    // Show list of saved chats for resuming (interactive picker)
+                    const chats = localChatStorage.listChats();
+                    if (chats.length === 0) {
+                        responseMessage = '📭 No saved chats found.\\n\\nStart a new conversation and it will be automatically saved!';
+                    }
+                    else {
+                        // Format chat list for picker display
+                        if (this.onShowChatPickerCallback) {
+                            this.onShowChatPickerCallback(chats, this.currentChatId);
+                            return; // Don't send a text response, picker will handle it
+                        }
+                        else {
+                            // Fallback: show as text if no picker callback
+                            responseMessage = '📚 Saved Chats:\\n\\n' +
+                                chats.slice(0, 10).map((chat, i) => {
+                                    const date = new Date(chat.updatedAt).toLocaleDateString();
+                                    const time = new Date(chat.updatedAt).toLocaleTimeString();
+                                    return `${i + 1}. ${chat.title}\\n   📅 ${date} ${time} | 💬 ${chat.messageCount} messages`;
+                                }).join('\\n\\n') +
+                                (chats.length > 10 ? `\\n\\n...and ${chats.length - 10} more chats` : '');
+                        }
+                    }
+                }
+                else if (chatSubCommand === 'list') {
+                    // Show read-only list of saved chats (no selection)
+                    const chats = localChatStorage.listChats();
+                    if (chats.length === 0) {
+                        responseMessage = '📭 No saved chats found.\\n\\nStart a new conversation and it will be automatically saved!';
+                    }
+                    else {
+                        // Format chat list for read-only display
+                        if (this.onShowChatListCallback) {
+                            this.onShowChatListCallback(chats, this.currentChatId);
+                            return; // Don't send a text response, UI will handle it
+                        }
+                        else {
+                            // Fallback: show as text
+                            responseMessage = '📚 Saved Chats:\\n\\n' +
+                                chats.slice(0, 10).map((chat, i) => {
+                                    const date = new Date(chat.updatedAt).toLocaleDateString();
+                                    const time = new Date(chat.updatedAt).toLocaleTimeString();
+                                    const isCurrent = chat.id === this.currentChatId ? ' (current)' : '';
+                                    return `${i + 1}. ${chat.title}${isCurrent}\\n   📅 ${date} ${time} | 💬 ${chat.messageCount} messages`;
+                                }).join('\\n\\n') +
+                                (chats.length > 10 ? `\\n\\n...and ${chats.length - 10} more chats` : '');
+                        }
+                    }
+                }
+                else if (chatSubCommand === 'delete') {
+                    // Show list of saved chats for deletion
+                    const chats = localChatStorage.listChats();
+                    if (chats.length === 0) {
+                        responseMessage = '📭 No saved chats to delete.';
+                    }
+                    else {
+                        // Format chat list for delete picker display
+                        if (this.onShowChatDeletePickerCallback) {
+                            this.onShowChatDeletePickerCallback(chats, this.currentChatId);
+                            return; // Don't send a text response, picker will handle it
+                        }
+                        else {
+                            responseMessage = '❌ Delete picker not available. Please use the UI to delete chats.';
+                        }
+                    }
+                }
+                else if (chatSubCommand === 'new') {
+                    // Start a new chat session (old one is already saved)
+                    this.startNewChat();
+                    // Clear UI messages
+                    if (this.onRestoreMessagesCallback) {
+                        this.onRestoreMessagesCallback([]);
+                    }
+                    responseMessage = '🆕 Started a new chat session!\n\nYour previous conversation has been saved and can be resumed with /chat resume.';
+                }
+                else if (chatSubCommand === 'rename') {
+                    // Show list of saved chats for renaming
+                    const chats = localChatStorage.listChats();
+                    if (chats.length === 0) {
+                        responseMessage = '📭 No saved chats to rename.';
+                    }
+                    else {
+                        // Format chat list for rename picker display
+                        if (this.onShowChatRenamePickerCallback) {
+                            this.onShowChatRenamePickerCallback(chats, this.currentChatId);
+                            return; // Don't send a text response, picker will handle it
+                        }
+                        else {
+                            responseMessage = '❌ Rename picker not available. Please use the UI to rename chats.';
+                        }
+                    }
+                }
+                else {
+                    responseMessage = `Unknown /chat subcommand: ${chatSubCommand}\\n\\nUsage:\\n  /chat resume  - Resume a previous chat session\\n  /chat list    - List all saved chats\\n  /chat delete  - Delete a saved chat\\n  /chat new     - Start a new chat session\\n  /chat rename  - Rename a saved chat`;
+                }
+                break;
             case 'exit':
                 process.exit(0);
                 break;
+            case 'add-command':
+            case 'add-command-auto-detect':
+                // Handle custom command auto-detect management
+                const { CustomCommandsManager } = await import('./utils/custom-commands-manager.js');
+                const customCmdManager = CustomCommandsManager.getInstance();
+                await customCmdManager.initialize();
+                const addCmdSubCommand = args[0]?.toLowerCase();
+                if (!addCmdSubCommand || addCmdSubCommand === 'list') {
+                    // List all custom commands
+                    const commands = customCmdManager.listCommands();
+                    if (commands.length === 0) {
+                        responseMessage = '📋 No custom commands configured.\n\n' +
+                            'Add commands with: /add-command add <command>\n' +
+                            'These commands will be detected as terminal commands in Auto mode.';
+                    }
+                    else {
+                        responseMessage = `📋 Custom Terminal Commands (${commands.length}):\n\n` +
+                            commands.map(cmd => `  • ${cmd}`).join('\n') +
+                            '\n\nUsage:\n' +
+                            '  /add-command add <command>    - Add a command\n' +
+                            '  /add-command delete <command> - Delete a command';
+                    }
+                }
+                else if (addCmdSubCommand === 'add') {
+                    // Add a custom command
+                    const cmdToAdd = args.slice(1).join(' ').trim();
+                    if (!cmdToAdd) {
+                        responseMessage = '❌ Please specify a command to add.\n\nUsage: /add-command add <command>';
+                    }
+                    else {
+                        const result = await customCmdManager.addCommand(cmdToAdd);
+                        if (result.success) {
+                            responseMessage = `✅ ${result.message}\n\nThis word will now be detected as a terminal command in Auto mode.`;
+                        }
+                        else {
+                            responseMessage = `❌ ${result.message}`;
+                        }
+                    }
+                }
+                else if (addCmdSubCommand === 'delete') {
+                    // Delete a custom command
+                    const cmdToDelete = args.slice(1).join(' ').trim();
+                    if (!cmdToDelete) {
+                        responseMessage = '❌ Please specify a command to delete.\n\nUsage: /add-command delete <command>';
+                    }
+                    else {
+                        const result = await customCmdManager.deleteCommand(cmdToDelete);
+                        if (result.success) {
+                            responseMessage = `✅ ${result.message}`;
+                        }
+                        else {
+                            responseMessage = `❌ ${result.message}`;
+                        }
+                    }
+                }
+                else {
+                    responseMessage = `Unknown /add-command subcommand: ${addCmdSubCommand}\n\n` +
+                        'Usage:\n' +
+                        '  /add-command list              - List all custom commands\n' +
+                        '  /add-command add <command>     - Add a custom command\n' +
+                        '  /add-command delete <command>  - Delete a custom command';
+                }
+                break;
             default:
                 responseMessage = `Unknown command: /${cmd}\nType /help for available commands.`;
         }
@@ -1828,6 +2092,409 @@ Start by listing the directory structure to understand what you're working with.
             this.onDirectMessageCallback(responseMessage);
         }
     }
+    /**
+     * Set callback for showing chat picker
+     */
+    setOnShowChatPickerCallback(callback) {
+        this.onShowChatPickerCallback = callback;
+    }
+    /**
+     * Set callback for showing chat delete picker
+     */
+    setOnShowChatDeletePickerCallback(callback) {
+        this.onShowChatDeletePickerCallback = callback;
+    }
+    /**
+     * Set callback for showing chat list (read-only view)
+     */
+    setOnShowChatListCallback(callback) {
+        this.onShowChatListCallback = callback;
+    }
+    /**
+     * Set callback for showing chat rename picker
+     */
+    setOnShowChatRenamePickerCallback(callback) {
+        this.onShowChatRenamePickerCallback = callback;
+    }
+    /**
+     * Handle chat rename operation
+     */
+    handleChatRename(chatId, newTitle) {
+        const chat = localChatStorage.loadChat(chatId);
+        const oldTitle = chat?.title || 'Unknown chat';
+        const success = localChatStorage.renameChat(chatId, newTitle);
+        if (success) {
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(`✏️ Renamed chat: "${oldTitle}" → "${newTitle}"`);
+            }
+        }
+        else {
+            if (this.onResponseCallback) {
+                this.onResponseCallback('❌ Failed to rename the chat.');
+            }
+        }
+    }
+    /**
+     * Handle chat delete picker selection
+     */
+    async handleChatDeleteSelection(chatId) {
+        const chat = localChatStorage.loadChat(chatId);
+        const chatTitle = chat?.title || 'Unknown chat';
+        const isDeletingCurrentChat = this.currentChatId === chatId;
+        // Get the backend conversation ID (UUID) if available for file deletion
+        // Files are stored with the backend UUID, not the local chat ID
+        const fileDeleteId = chat?.backendConversationId || chatId;
+        const success = localChatStorage.deleteChat(chatId);
+        if (success) {
+            // Clean up any files associated with this conversation (images in GCS)
+            // Use backendConversationId (UUID) if available, as that's what files are stored under
+            // This is a fire-and-forget operation - don't block on it
+            if (apiClient.isAuthenticated()) {
+                apiClient.deleteConversationFiles(fileDeleteId).catch(() => {
+                    // Silently ignore - files might not exist or backend error
+                });
+            }
+            // If we deleted the current chat, start a new chat
+            if (isDeletingCurrentChat) {
+                this.startNewChat();
+                if (this.onDirectMessageCallback) {
+                    this.onDirectMessageCallback(`🗑️ Deleted current chat: "${chatTitle}"\n\n🆕 Started a new chat session.`);
+                }
+                // Clear UI messages via restore callback with empty array
+                if (this.onRestoreMessagesCallback) {
+                    this.onRestoreMessagesCallback([]);
+                }
+            }
+            else {
+                if (this.onDirectMessageCallback) {
+                    this.onDirectMessageCallback(`🗑️ Deleted chat: "${chatTitle}"`);
+                }
+            }
+        }
+        else {
+            if (this.onResponseCallback) {
+                this.onResponseCallback('❌ Failed to delete the selected chat.');
+            }
+        }
+    }
+    /**
+     * Record a user shell command and its output to conversation history
+     * This allows the AI to see what commands the user ran in command mode
+     */
+    recordShellCommandToHistory(command, output, cwd, exitCode) {
+        // Add as a user message so AI knows what the user did
+        const shellCommandInfo = exitCode !== undefined && exitCode !== 0
+            ? `[User ran shell command in ${cwd}]\nCommand: ${command}\nExit Code: ${exitCode}\nOutput:\n${output}`
+            : `[User ran shell command in ${cwd}]\nCommand: ${command}\nOutput:\n${output || '(no output)'}`;
+        this.conversationHistory.push({
+            role: 'user',
+            content: shellCommandInfo
+        });
+    }
+    /**
+     * Save current conversation to local storage
+     */
+    saveCurrentChat() {
+        // Only save if there are messages (AI conversation or shell commands)
+        if (this.conversationHistory.length === 0) {
+            return;
+        }
+        // Generate chat ID if not exists
+        if (!this.currentChatId) {
+            this.currentChatId = localChatStorage.generateChatId();
+        }
+        // Convert to StoredMessage format (AI context)
+        const storedMessages = this.conversationHistory.map(msg => ({
+            role: msg.role,
+            content: msg.content,
+            tool_calls: msg.tool_calls,
+            tool_call_id: msg.tool_call_id,
+        }));
+        // Convert UI messages to serializable format
+        const storedUIMessages = this.uiMessageHistory.map(msg => ({
+            id: msg.id,
+            role: msg.role,
+            content: msg.content,
+            timestamp: msg.timestamp?.toISOString(),
+            toolExecution: msg.toolExecution ? {
+                toolName: msg.toolExecution.toolName,
+                status: msg.toolExecution.status,
+                result: msg.toolExecution.result,
+                error: msg.toolExecution.error,
+                arguments: msg.toolExecution.arguments,
+            } : undefined,
+            shouldStream: msg.shouldStream,
+            isCommandMode: msg.isCommandMode,
+            tool_call_id: msg.tool_call_id,
+            tool_calls: msg.tool_calls,
+            thinkingDuration: msg.thinkingDuration,
+            taskCompletion: msg.taskCompletion,
+            planAccepted: msg.planAccepted,
+            connectionStatus: msg.connectionStatus, // For SSH/WSL/Docker connection status boxes
+        }));
+        // Capture remote context if in remote environment (SSH/WSL/Docker)
+        // Use null to explicitly clear remote context when not in remote (so resuming won't reconnect)
+        let remoteContext = null;
+        const currentContext = this.contextManager.getCurrentContext();
+        if (currentContext.type !== 'local' && this.lastConnectionCommand) {
+            remoteContext = {
+                type: currentContext.type,
+                connectionCommand: this.lastConnectionCommand,
+                remoteCwd: currentContext.metadata.workingDirectory,
+                localCwdBeforeRemote: this.localCwdBeforeRemote || process.cwd(),
+                metadata: {
+                    hostname: currentContext.metadata.hostname,
+                    username: currentContext.metadata.username,
+                    distroName: currentContext.metadata.distroName,
+                    containerId: currentContext.metadata.containerId,
+                    port: currentContext.metadata.port,
+                }
+            };
+        }
+        // Determine the local CWD to save (use localCwdBeforeRemote if in remote, otherwise current cwd)
+        const cwdToSave = currentContext.type !== 'local' && this.localCwdBeforeRemote
+            ? this.localCwdBeforeRemote
+            : this.cwd;
+        try {
+            localChatStorage.saveChat(this.currentChatId, storedMessages, storedUIMessages, cwdToSave, remoteContext);
+            // Also store the backend conversation ID (UUID) for file deletion
+            // This is the ID used for GCS file storage, not the local chat ID
+            const backendId = conversationManager.getCurrentConversationId();
+            if (backendId && backendId !== this.currentChatId) {
+                localChatStorage.setBackendConversationId(this.currentChatId, backendId);
+            }
+        }
+        catch (error) {
+            // Silently ignore save errors - don't interrupt the user
+        }
+    }
+    /**
+     * Load a chat from local storage and restore it
+     */
+    loadChat(chatId) {
+        const chat = localChatStorage.loadChat(chatId);
+        if (!chat) {
+            return false;
+        }
+        // Clear current history and load the saved chat
+        this.conversationHistory = chat.messages.map(msg => ({
+            role: msg.role,
+            content: msg.content,
+            tool_calls: msg.tool_calls,
+            tool_call_id: msg.tool_call_id,
+        }));
+        // Set the current chat ID to continue the conversation
+        this.currentChatId = chatId;
+        this.conversationStarted = true;
+        // Restore CWD if saved (important for commands to run in correct directory)
+        if (chat.cwd) {
+            this.cwd = chat.cwd;
+            // Update context manager if available
+            if (this.contextManager) {
+                this.contextManager.updateWorkingDirectory(chat.cwd);
+            }
+            // Notify UI of CWD change
+            if (this.onCwdChange) {
+                this.onCwdChange(chat.cwd);
+            }
+        }
+        return true;
+    }
+    /**
+     * Handle chat picker selection
+     */
+    async handleChatPickerSelection(chatId) {
+        const chat = localChatStorage.loadChat(chatId);
+        if (!chat) {
+            if (this.onResponseCallback) {
+                this.onResponseCallback('❌ Failed to load the selected chat.');
+            }
+            return;
+        }
+        // IMPORTANT: Clean up current remote session before loading new chat
+        // This ensures that switching from a remote chat to a local chat properly resets the state
+        const currentContext = this.contextManager.getCurrentContext();
+        if (currentContext.type !== 'local') {
+            // Disconnect from current remote session
+            if (currentContext.handler) {
+                try {
+                    await currentContext.handler.disconnect();
+                }
+                catch (error) {
+                    // Ignore disconnect errors - we're switching chats anyway
+                }
+            }
+            // Pop context to return to local
+            this.contextManager.popContext();
+            // Clear remote context tracking
+            this.localCwdBeforeRemote = null;
+            this.lastConnectionCommand = null;
+        }
+        // Load AI context
+        this.loadChat(chatId);
+        // Restore UI messages if available
+        if (chat.uiMessages && chat.uiMessages.length > 0 && this.onRestoreMessagesCallback) {
+            // Convert StoredUIMessage back to Message format
+            const restoredMessages = chat.uiMessages.map(msg => ({
+                id: msg.id,
+                role: msg.role,
+                content: msg.content,
+                timestamp: msg.timestamp ? new Date(msg.timestamp) : undefined,
+                toolExecution: msg.toolExecution,
+                shouldStream: false, // Don't stream restored messages
+                isCommandMode: msg.isCommandMode,
+                tool_call_id: msg.tool_call_id,
+                tool_calls: msg.tool_calls,
+                thinkingDuration: msg.thinkingDuration,
+                taskCompletion: msg.taskCompletion,
+                planAccepted: msg.planAccepted,
+                connectionStatus: msg.connectionStatus, // For SSH/WSL/Docker connection status boxes
+            }));
+            this.onRestoreMessagesCallback(restoredMessages);
+        }
+        // Attempt to restore remote context if chat was saved while in remote environment
+        if (chat.remoteContext) {
+            const { type, connectionCommand, remoteCwd, localCwdBeforeRemote } = chat.remoteContext;
+            // Store local CWD for when user exits remote
+            this.localCwdBeforeRemote = localCwdBeforeRemote;
+            this.lastConnectionCommand = connectionCommand;
+            // Show reconnection notification
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(`🔄 Reconnecting to ${type.toUpperCase()} session...`);
+            }
+            // Show connecting status
+            if (this.onConnectionStatusUpdate) {
+                this.onConnectionStatusUpdate({
+                    type: type,
+                    status: 'connecting',
+                    connectionString: this.buildConnectionString(type, chat.remoteContext.metadata)
+                });
+            }
+            try {
+                // Detect and connect using the saved command
+                const detection = this.commandDetector.detect(connectionCommand);
+                if (detection) {
+                    const context = await detection.handler.connect(connectionCommand, localCwdBeforeRemote);
+                    this.contextManager.pushContext(context);
+                    // Navigate to saved remote CWD
+                    if (remoteCwd && remoteCwd !== context.metadata.workingDirectory) {
+                        try {
+                            await this.contextManager.executeCommand(`cd "${remoteCwd}"`);
+                        }
+                        catch (cdError) {
+                            // Failed to cd to saved path - warn but continue
+                            if (this.onDirectMessageCallback) {
+                                this.onDirectMessageCallback(`⚠️ Could not restore remote directory: ${remoteCwd}`);
+                            }
+                        }
+                    }
+                    // Show success
+                    if (this.onConnectionStatusUpdate) {
+                        this.onConnectionStatusUpdate({
+                            type: type,
+                            status: 'connected',
+                            connectionString: this.buildConnectionString(type, chat.remoteContext.metadata)
+                        });
+                    }
+                    return;
+                }
+            }
+            catch (error) {
+                // Connection failed - fall back to local mode
+                this.localCwdBeforeRemote = null;
+                this.lastConnectionCommand = null;
+                if (this.onConnectionStatusUpdate) {
+                    this.onConnectionStatusUpdate({
+                        type: type,
+                        status: 'error',
+                        connectionString: this.buildConnectionString(type, chat.remoteContext.metadata),
+                        error: error.message
+                    });
+                }
+                if (this.onDirectMessageCallback) {
+                    this.onDirectMessageCallback(`⚠️ Loaded chat: "${chat.title}"\n\n❌ Could not reconnect to ${type.toUpperCase()}: ${error.message}\n\n📁 Restored to local directory: ${localCwdBeforeRemote}`);
+                }
+                return;
+            }
+        }
+        // No remote context - show regular confirmation
+        // No remote context - show regular confirmation and restore CWD
+        if (chat.cwd && !chat.remoteContext) {
+            if (fs.existsSync(chat.cwd)) {
+                this.cwd = chat.cwd;
+                this.contextManager.updateWorkingDirectory(chat.cwd);
+                if (this.onCwdChange) {
+                    this.onCwdChange(chat.cwd);
+                }
+            }
+        }
+        if (this.onDirectMessageCallback) {
+            const responseMessage = `✅ Loaded chat: "${chat.title}"\n\nYou have ${chat.messageCount} messages in AI context. Continue your conversation!`;
+            this.onDirectMessageCallback(responseMessage);
+        }
+    }
+    /**
+     * Build a connection string for display based on remote context metadata
+     */
+    buildConnectionString(type, metadata) {
+        if (!metadata)
+            return type;
+        if (type === 'ssh' && metadata.hostname) {
+            return `${metadata.username || 'user'}@${metadata.hostname}`;
+        }
+        else if (type === 'wsl' && metadata.distroName) {
+            return metadata.distroName;
+        }
+        else if (type === 'docker' && metadata.containerId) {
+            return metadata.containerId.substring(0, 12);
+        }
+        return type;
+    }
+    /**
+     * Get the current chat ID
+     */
+    getCurrentChatId() {
+        return this.currentChatId;
+    }
+    /**
+     * Start a new chat session
+     */
+    startNewChat() {
+        this.conversationHistory = [];
+        this.currentChatId = null;
+        this.conversationStarted = false;
+        this.uiMessageHistory = [];
+        this.localCwdBeforeRemote = null;
+        this.lastConnectionCommand = null;
+    }
+    /**
+     * Update UI message history (called from App.tsx via callback)
+     * Also triggers auto-save to ensure the latest messages are persisted
+     *
+     * Note: Only saves when there's real user/AI content, not just slash command system messages.
+     * This prevents empty chats from being created when user only runs /chat commands.
+     */
+    updateUIMessageHistory(messages) {
+        this.uiMessageHistory = messages;
+        // Auto-save when UI history changes, but only if there's real content
+        // Real content is defined as: user or assistant messages (not just system slash command messages)
+        // This ensures:
+        // - /chat rename, /chat new, etc. don't create new chats on their own
+        // - System messages from slash commands aren't saved permanently
+        // - Only actual AI conversation content triggers saves
+        const hasRealContent = this.conversationHistory.length > 0;
+        // Only save if there's actual AI conversation history
+        // The conversationHistory only contains real user/assistant/tool messages from AI interactions
+        if (messages.length > 0 && hasRealContent) {
+            this.saveCurrentChat();
+        }
+    }
+    /**
+     * Set callback for restoring UI messages
+     */
+    setOnRestoreMessagesCallback(callback) {
+        this.onRestoreMessagesCallback = callback;
+    }
     /**
      * Get environment context for backend
      * Returns structured environment information to be sent to backend
@@ -1923,6 +2590,45 @@ 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
@@ -1966,6 +2672,19 @@ Once the user approves the plan:
                     }
                     // Pop 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);
+                        if (this.onCwdChange) {
+                            this.onCwdChange(this.localCwdBeforeRemote);
+                        }
+                    }
+                    // Clear remote context tracking
+                    this.localCwdBeforeRemote = null;
+                    this.lastConnectionCommand = null;
+                    // Save chat with no remote context - so resuming won't try to reconnect
+                    this.saveCurrentChat();
                     if (this.onResponseCallback) {
                         this.onResponseCallback('✅ Exited subshell');
                     }
@@ -2007,9 +2726,21 @@ Once the user approves the plan:
                 // 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({
@@ -2135,6 +2866,8 @@ Once the user approves the plan:
                                 });
                             }
                         }
+                        // Record shell command to AI conversation history
+                        this.recordShellCommandToHistory(command, output, this.cwd, exitCode);
                         this.currentInteractiveProcess = undefined;
                         resolve();
                     });
@@ -2173,6 +2906,8 @@ Once the user approves the plan:
                                 });
                             }
                         }
+                        // Record shell command to AI conversation history
+                        this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
                         this.currentInteractiveProcess = undefined;
                         resolve();
                     });
@@ -2224,6 +2959,8 @@ Once the user approves the plan:
                                 });
                             }
                         }
+                        // Record shell command to AI conversation history
+                        this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
                         this.currentInteractiveProcess = undefined;
                         resolve();
                     });
@@ -2278,6 +3015,8 @@ Once the user approves the plan:
                                 });
                             }
                         }
+                        // Record shell command to AI conversation history
+                        this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
                         this.currentInteractiveProcess = undefined;
                         resolve();
                     });
@@ -2296,6 +3035,9 @@ Once the user approves the plan:
                     };
                 });
             }
+            // Save conversation after user shell command execution
+            // This ensures shell commands are saved to chat history like AI messages
+            this.saveCurrentChat();
         }
         catch (error) {
             if (this.onResponseCallback) {