centaurus-cli 2.8.8 → 2.9.0

package/dist/cli-adapter.js

@@ -17,10 +17,12 @@ import { createPlanTool, markTaskCompleteTool, getCurrentPlan, clearPlan, approv
 import { webSearchTool, fetchUrlTool } from './tools/web-search.js';
 import { taskCompleteTool } from './tools/task-complete.js';
 import { readBinaryFileTool } from './tools/read-binary-file.js';
+import { createImageTool } from './tools/create-image.js';
+import { backgroundCommandTool } from './tools/background-command.js';
 import { apiClient } from './services/api-client.js';
 import { conversationManager } from './services/conversation-manager.js';
 import { aiServiceClient } from './services/ai-service-client.js';
-import { isValidModel, getInvalidModelError } from './config/models.js';
+import { isValidModel, getInvalidModelError, fetchModelsConfig, getModelConfigByIdAndName } from './config/models.js';
 import { authenticateWithGoogle } from './services/auth-handler.js';
 import { ContextManager } from './context/context-manager.js';
 import { CommandDetector } from './context/command-detector.js';
@@ -32,9 +34,10 @@ import { MCPConfigManager } from './config/mcp-config-manager.js';
 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 { conversationLogger, quickLog } from './utils/conversation-logger.js';
 import { localChatStorage } from './services/local-chat-storage.js';
 import { logWarning } from './utils/logger.js';
+import { BackgroundTaskManager } from './services/background-task-manager.js';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
@@ -43,6 +46,7 @@ export class CentaurusCLI {
     planMode = false;
     pendingPlanRequest = null; // Stores original user request during planning phase
     commandMode = false;
+    backgroundMode = false; // Background shell mode for running commands in background
     previousMode = 'execution';
     onResponseCallback;
     onDirectMessageCallback; // For slash commands - adds directly to history
@@ -81,6 +85,13 @@ export class CentaurusCLI {
     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
+    onBackgroundModeChange;
+    onBackgroundTaskCountChange;
+    onSetAutoMode;
+    onShowBackgroundTaskPickerCallback;
+    onShowBackgroundTaskCancelPickerCallback;
+    onBackgroundTaskViewCallback;
+    onTokenCountUpdate; // Report actual AI context token count to UI
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -166,6 +177,9 @@ export class CentaurusCLI {
     setOnConnectionStatusUpdate(callback) {
         this.onConnectionStatusUpdate = callback;
     }
+    setOnTokenCountUpdate(callback) {
+        this.onTokenCountUpdate = callback;
+    }
     async initializeMCP() {
         try {
             const mcpConfigManager = new MCPConfigManager();
@@ -229,20 +243,20 @@ export class CentaurusCLI {
     }
     async handlePickerSelection(selection, pickerType) {
         try {
-            // Selection is the index of the model in ALL_MODELS array
-            const { ALL_MODELS } = await import('./config/models.js');
+            // 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 >= ALL_MODELS.length) {
+            if (isNaN(modelIndex) || modelIndex < 0 || modelIndex >= modelsConfig.models.length) {
                 throw new Error('Invalid model selection');
             }
-            const selectedModel = ALL_MODELS[modelIndex];
+            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
+            // Notify UI of model name change and contextWindow
             if (this.onModelChange) {
-                this.onModelChange(selectedModel.name);
+                this.onModelChange(selectedModel.name, selectedModel.contextWindow);
             }
             const responseMessage = `Model changed to: ${selectedModel.name}`;
             // Send response back to UI
@@ -335,6 +349,8 @@ export class CentaurusCLI {
         this.toolRegistry.register(fetchUrlTool);
         this.toolRegistry.register(taskCompleteTool);
         this.toolRegistry.register(readBinaryFileTool);
+        this.toolRegistry.register(createImageTool);
+        this.toolRegistry.register(backgroundCommandTool);
         // Load configuration
         const config = this.configManager.load();
         // Enable backend sync if authenticated
@@ -396,47 +412,24 @@ Press Enter to continue...
     }
     /**
      * Start a new conversation in the backend
+     * @deprecated Backend conversation creation is no longer needed since messages are stored locally
+     * This function is kept as a no-op for compatibility
      */
     async ensureConversationStarted() {
-        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()}`;
-            await conversationManager.startNewConversation(title, config.model || 'gemini-2.5-flash', 'google', // Always use Google provider now
-            this.cwd);
-            this.conversationStarted = true;
-        }
-        catch (error) {
-            // Silently continue without backend persistence
-        }
+        // No-op: Backend conversation creation has been disabled
+        // Conversations are now managed locally via local-chat-storage.ts
+        return;
     }
     /**
      * Save a message to the backend
+     * @deprecated Messages are now stored locally only via saveCurrentChat()
+     * This function is kept as a no-op for compatibility
      */
     async saveMessageToBackend(role, content) {
-        if (!apiClient.isAuthenticated()) {
-            return;
-        }
-        try {
-            await this.ensureConversationStarted();
-            await conversationManager.addMessage({
-                role,
-                content,
-                contentType: 'text',
-                metadata: {},
-            });
-        }
-        catch (error) {
-            // Silently continue without backend persistence
-        }
+        // No-op: Messages are stored locally only
+        // Backend message storage has been disabled to avoid "failed to fetch" errors
+        // All conversation history is persisted via local-chat-storage.ts
+        return;
     }
     getModel() {
         const config = this.configManager.load();
@@ -485,19 +478,45 @@ Press Enter to continue...
         if (toolCallIds.size > 0) {
             // Log the cleanup for debugging
             try {
-                fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Cleaning up orphaned tool_calls: ${Array.from(toolCallIds).join(', ')}\n`);
+                quickLog(`[${new Date().toISOString()}] [CLI] Cleaning up orphaned tool_calls: ${Array.from(toolCallIds).join(', ')}\n`);
             }
             catch (e) { }
             // Remove the orphaned assistant message and any partial tool results after it
             this.conversationHistory.splice(lastAssistantWithToolCallsIndex);
         }
     }
+    /**
+     * Strip thinking blocks from ALL assistant messages in the conversation history.
+     *
+     * This is called at the START of a new user request to clear thinking from
+     * previous tasks. During the current agent loop, thinking is preserved for
+     * all turns to help the AI maintain reasoning context.
+     *
+     * Pattern:
+     * - New user request starts → strip ALL thinking from history
+     * - During agent loop (multi-turn tool execution) → keep ALL thinking
+     * - This allows AI to remember reasoning for current task but not old tasks
+     */
+    stripThinkingFromHistory() {
+        for (let i = 0; i < this.conversationHistory.length; i++) {
+            const msg = this.conversationHistory[i];
+            if (msg.role === 'assistant' && msg.thinking) {
+                // Remove thinking from the message in place
+                delete msg.thinking;
+            }
+        }
+    }
     async handleMessage(message) {
         // Handle command mode - execute commands directly
         if (this.commandMode) {
             await this.handleCommandModeExecution(message);
             return;
         }
+        // Handle background mode - execute commands in background
+        if (this.backgroundMode) {
+            this.handleBackgroundModeExecution(message);
+            return;
+        }
         // Handle slash commands
         if (message.startsWith('/')) {
             await this.handleSlashCommand(message);
@@ -537,13 +556,17 @@ CRITICAL INSTRUCTIONS:
 DO NOT use write_to_file, edit_file, or execute_command until the plan is approved.`;
             userMessageContent = planModePrefix;
         }
+        // NEW USER REQUEST: Strip thinking from previous tasks
+        // This clears thinking from the previous agent loop but thinking will be
+        // preserved for all turns within the current agent loop
+        this.stripThinkingFromHistory();
         // Add user message to history
         this.conversationHistory.push({
             role: 'user',
             content: userMessageContent,
         });
-        // Save user message to backend (save original message for display, not the prefixed version)
-        await this.saveMessageToBackend('user', message);
+        // 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
         conversationLogger.startSession();
         conversationLogger.logUserMessage(message);
@@ -569,10 +592,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             // Get selected model ID from config, then look up full config from models-config.json
             const config = this.configManager.load();
             const selectedModelId = config.model || 'gemini-2.5-flash';
-            // Look up the full model config (including thinkingConfig) from models-config.json
-            // This ensures we always use the latest config, not a cached version
-            const { ALL_MODELS } = await import('./config/models.js');
-            const selectedModelConfig = ALL_MODELS.find(m => m.id === selectedModelId && m.name === config.modelName);
+            // Look up the full model config (including thinkingConfig) from backend
+            // This ensures we always use the latest config
+            const selectedModelConfig = await getModelConfigByIdAndName(selectedModelId, config.modelName || '');
             const selectedModel = selectedModelId;
             const selectedModelThinkingConfig = selectedModelConfig?.thinkingConfig;
             // Build messages array WITHOUT system prompt - backend will inject it
@@ -594,7 +616,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             let narrationAttempts = 0; // Track how many times AI narrated without executing
             let completionAttempts = 0; // Track how many times AI provided text summary without task_complete
             let thoughtStartTime = null; // Track when thinking started
-            let thoughtContent = ''; // Accumulate thought content
+            let thoughtContent = ''; // Accumulate thought content during streaming
+            let currentTurnThinking = ''; // Persist thinking for the current turn to attach to assistant message
             // ANTI-LOOP: Track duplicate tool calls to detect infinite loops
             const MAX_DUPLICATE_CALLS = 2; // Max times same operation allowed on same target
             const fileWriteTracker = new Map(); // Track writes per file
@@ -619,7 +642,28 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 // DEBUG: Log message history state before AI call
                 const messageStats = {
                     totalMessages: messages.length,
-                    totalCharacters: messages.reduce((sum, m) => sum + (typeof m.content === 'string' ? m.content.length : 0), 0),
+                    totalCharacters: messages.reduce((sum, m) => {
+                        let len = typeof m.content === 'string' ? m.content.length : 0;
+                        // Include thinking content (internal reasoning)
+                        if (m.thinking) {
+                            len += m.thinking.length;
+                        }
+                        // Include tool calls (name + arguments)
+                        if (m.tool_calls) {
+                            m.tool_calls.forEach(tc => {
+                                len += tc.name.length;
+                                // Arguments are JSON stringified in the payload
+                                if (tc.arguments) {
+                                    len += JSON.stringify(tc.arguments).length;
+                                }
+                            });
+                        }
+                        // Include tool_call_id for tool messages
+                        if (m.role === 'tool' && m.tool_call_id) {
+                            len += m.tool_call_id.length;
+                        }
+                        return sum + len;
+                    }, 0),
                     byRole: {
                         system: messages.filter(m => m.role === 'system').length,
                         user: messages.filter(m => m.role === 'user').length,
@@ -629,12 +673,19 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     assistantWithToolCalls: messages.filter(m => m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0).length
                 };
                 try {
-                    fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] === TURN ${turnCount} AI CALL ===\n`);
-                    fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Message history: ${messageStats.totalMessages} messages, ${messageStats.totalCharacters} chars\n`);
-                    fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] By role: system=${messageStats.byRole.system}, user=${messageStats.byRole.user}, assistant=${messageStats.byRole.assistant}, tool=${messageStats.byRole.tool}\n`);
-                    fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Assistant messages with tool_calls: ${messageStats.assistantWithToolCalls}\n`);
+                    quickLog(`[${new Date().toISOString()}] [CLI] === TURN ${turnCount} AI CALL ===\n`);
+                    quickLog(`[${new Date().toISOString()}] [CLI] Message history: ${messageStats.totalMessages} messages, ${messageStats.totalCharacters} chars\n`);
+                    quickLog(`[${new Date().toISOString()}] [CLI] By role: system=${messageStats.byRole.system}, user=${messageStats.byRole.user}, assistant=${messageStats.byRole.assistant}, tool=${messageStats.byRole.tool}\n`);
+                    quickLog(`[${new Date().toISOString()}] [CLI] Assistant messages with tool_calls: ${messageStats.assistantWithToolCalls}\n`);
                 }
                 catch (e) { }
+                // Report actual token count to UI (estimate: 1 token ≈ 4 chars)
+                // Include system prompt estimate (~14000 chars based on backend logs)
+                const SYSTEM_PROMPT_ESTIMATE = 14000; // Backend injects ~14K char system prompt
+                const estimatedTokens = Math.ceil((messageStats.totalCharacters + SYSTEM_PROMPT_ESTIMATE) / 4);
+                if (this.onTokenCountUpdate) {
+                    this.onTokenCountUpdate(estimatedTokens);
+                }
                 // 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)) {
@@ -675,6 +726,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -696,7 +749,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         const toolCall = chunk.toolCall;
                         // Debug: Log every tool_call chunk received
                         try {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] *** TOOL_CALL CHUNK RECEIVED: ${toolCall?.name || 'unknown'}, toolCalls.length before push: ${toolCalls.length}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL CHUNK RECEIVED: ${toolCall?.name || 'unknown'}, toolCalls.length before push: ${toolCalls.length}\n`);
                         }
                         catch (e) { }
                         conversationLogger.logToolCall(toolCall?.name || 'unknown', toolCall?.id || 'unknown', toolCall?.arguments || {});
@@ -707,6 +760,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -722,7 +777,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         }
                         // Debug: Log after push
                         try {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] *** TOOL_CALL PUSHED: ${toolCall?.name || 'unknown'}, toolCalls.length after push: ${toolCalls.length}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL PUSHED: ${toolCall?.name || 'unknown'}, toolCalls.length after push: ${toolCalls.length}\n`);
                         }
                         catch (e) { }
                     }
@@ -735,6 +790,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -777,7 +834,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     for (let i = 0; i < toolCalls.length; i++) {
                         // Debug: Log which tool we're about to execute
                         try {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] *** ABOUT TO EXECUTE TOOL [${i + 1}/${toolCalls.length}]: ${toolCalls[i].name}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** ABOUT TO EXECUTE TOOL [${i + 1}/${toolCalls.length}]: ${toolCalls[i].name}\n`);
                         }
                         catch (e) { }
                         const toolCall = toolCalls[i];
@@ -833,11 +890,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                     this.onPlanModeChange(false);
                                                 }
                                                 // Add assistant message with plan tool call to history
-                                                this.conversationHistory.push({
+                                                const planAssistantMsg = {
                                                     role: 'assistant',
                                                     content: '',
                                                     tool_calls: [toolCall],
-                                                });
+                                                };
+                                                if (currentTurnThinking) {
+                                                    planAssistantMsg.thinking = currentTurnThinking;
+                                                }
+                                                this.conversationHistory.push(planAssistantMsg);
                                                 // Add plan approval response
                                                 this.conversationHistory.push({
                                                     role: 'tool',
@@ -873,11 +934,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         else {
                                             // No approval callback - add the tool result to history and wait for user response
                                             // This ensures the AI doesn't get stuck in a silent loop
-                                            this.conversationHistory.push({
+                                            const planAssistantMsg = {
                                                 role: 'assistant',
                                                 content: '',
                                                 tool_calls: [toolCall],
-                                            });
+                                            };
+                                            if (currentTurnThinking) {
+                                                planAssistantMsg.thinking = currentTurnThinking;
+                                            }
+                                            this.conversationHistory.push(planAssistantMsg);
                                             this.conversationHistory.push({
                                                 role: 'tool',
                                                 tool_call_id: toolCall.id,
@@ -897,11 +962,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         // Log error and add error result to history so AI knows
                                         logWarning(`Failed to parse plan: ${parseError?.message || parseError}`);
                                         // CRITICAL: Add tool result even on parse error to prevent silent loop
-                                        this.conversationHistory.push({
+                                        const errorAssistantMsg = {
                                             role: 'assistant',
                                             content: '',
                                             tool_calls: [toolCall],
-                                        });
+                                        };
+                                        if (currentTurnThinking) {
+                                            errorAssistantMsg.thinking = currentTurnThinking;
+                                        }
+                                        this.conversationHistory.push(errorAssistantMsg);
                                         this.conversationHistory.push({
                                             role: 'tool',
                                             tool_call_id: toolCall.id,
@@ -914,11 +983,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                 }
                                 else {
                                     // Tool returned non-PLAN_CREATED result - add it to history
-                                    this.conversationHistory.push({
+                                    const resultAssistantMsg = {
                                         role: 'assistant',
                                         content: '',
                                         tool_calls: [toolCall],
-                                    });
+                                    };
+                                    if (currentTurnThinking) {
+                                        resultAssistantMsg.thinking = currentTurnThinking;
+                                    }
+                                    this.conversationHistory.push(resultAssistantMsg);
                                     this.conversationHistory.push({
                                         role: 'tool',
                                         tool_call_id: toolCall.id,
@@ -947,7 +1020,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                             const mainTaskNum = parseInt(taskNumParts[0], 10) - 1;
                                             const task = currentPlanData.steps[mainTaskNum];
                                             if (task) {
-                                                this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote);
+                                                this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote, completion.taskDescription // Pass the actual task/subtask description
+                                                );
                                             }
                                         }
                                         // Notify UI about completed task/subtask
@@ -967,11 +1041,15 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                     result: `Task completed. Moving to Task ${nextPhase.taskNumber}: ${nextPhase.task.description}`,
                                                 });
                                                 // Add the tool call and result to history
-                                                this.conversationHistory.push({
+                                                const nextPhaseAssistantMsg = {
                                                     role: 'assistant',
                                                     content: '',
                                                     tool_calls: [toolCall],
-                                                });
+                                                };
+                                                if (currentTurnThinking) {
+                                                    nextPhaseAssistantMsg.thinking = currentTurnThinking;
+                                                }
+                                                this.conversationHistory.push(nextPhaseAssistantMsg);
                                                 this.conversationHistory.push({
                                                     role: 'tool',
                                                     tool_call_id: toolCall.id,
@@ -1204,12 +1282,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     }
                     // If user cancelled an operation, stop the agentic loop immediately
                     if (userCancelledOperation) {
-                        // Add assistant message to history
-                        this.conversationHistory.push({
+                        // Add assistant message to history with thinking if available
+                        const cancelledAssistantMsg = {
                             role: 'assistant',
                             content: assistantMessage || '',
                             tool_calls: toolCalls, // Store tool calls for MaaS models
-                        });
+                        };
+                        if (currentTurnThinking) {
+                            cancelledAssistantMsg.thinking = currentTurnThinking;
+                        }
+                        this.conversationHistory.push(cancelledAssistantMsg);
                         // Add tool results to history
                         for (const toolResult of toolResults) {
                             this.conversationHistory.push({
@@ -1230,13 +1312,13 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     // Add assistant message with tool calls to conversation history
                     if (toolCalls && toolCalls.length > 0) {
                         try {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Adapting assistant message: has toolCalls=${toolCalls.length}, first=${JSON.stringify(toolCalls[0])}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] Adapting assistant message: has toolCalls=${toolCalls.length}, first=${JSON.stringify(toolCalls[0])}\n`);
                         }
                         catch (e) { }
                     }
                     else {
                         try {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Adapting assistant message: NO toolCalls\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] Adapting assistant message: NO toolCalls\n`);
                         }
                         catch (e) { }
                     }
@@ -1247,11 +1329,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     const unhandledToolResults = toolResults.filter(tr => !handledToolCallIds.has(tr.tool_call_id));
                     // Only add assistant message if there are unhandled tool calls
                     if (unhandledToolCalls.length > 0) {
-                        this.conversationHistory.push({
+                        const assistantHistoryMsg = {
                             role: 'assistant',
                             content: assistantMessage || '',
                             tool_calls: unhandledToolCalls, // Only include unhandled tool calls
-                        });
+                        };
+                        // Include thinking from this turn if available (Extended Thinking pattern)
+                        if (currentTurnThinking) {
+                            assistantHistoryMsg.thinking = currentTurnThinking;
+                        }
+                        this.conversationHistory.push(assistantHistoryMsg);
                     }
                     // Add tool results to conversation history as tool messages
                     // Format: { tool_call_id, name, result: <object or string> }
@@ -1266,8 +1353,10 @@ 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
+                    // During agent loop: keep ALL thinking for current task
+                    // (Thinking from previous tasks was already stripped at request start)
                     messages = [...this.conversationHistory];
+                    // No need to reset currentTurnThinking - keep accumulating for the task
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
                     continue; // Loop back to AI service
@@ -1457,8 +1546,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     role: 'assistant',
                     content: finalMessage,
                 });
-                // Save assistant message to backend
-                await this.saveMessageToBackend('assistant', finalMessage);
+                // Messages are stored locally only via saveCurrentChat() below
             } // End of while loop
             // Auto-save conversation to local storage
             this.saveCurrentChat();
@@ -1499,11 +1587,13 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     `/init       - Analyze project and create/load centaurus.md context file\n` +
                     `/chat       - Manage chat sessions (resume previous chats)\n` +
                     `/clear      - Clear conversation and start a new chat\n` +
+                    `/sync       - Sync data to/from cloud (upload/restore)\n` +
                     `/config     - View current configuration\n` +
                     `/model      - Select from available Google models\n` +
                     `/plan       - Toggle plan mode for complex implementations\n` +
                     `/mcp        - Manage configured MCP servers and tools\n` +
                     `/docs       - Open Centaurus documentation in browser\n` +
+                    `/copy-chat-context - Copy chat as readable text to clipboard\n` +
                     `/quality    - Toggle enhanced quality features (thinking protocol, validation)\n` +
                     `/autonomous - Toggle autonomous mode (Silent Operator with task_complete)\n` +
                     `/sign-in    - Sign in with Google (if not already signed in)\n` +
@@ -1865,12 +1955,12 @@ Start by listing the directory structure to understand what you're working with.
                     if (this.onShowPickerCallback) {
                         const config = this.configManager.load();
                         const currentModelName = config.modelName || '';
-                        // Import ALL_MODELS to show all variants including duplicates
-                        const { ALL_MODELS } = await import('./config/models.js');
+                        // Fetch models from backend
+                        const modelsConfig = await fetchModelsConfig();
                         this.onShowPickerCallback({
                             message: 'Select Model',
                             type: 'model',
-                            choices: ALL_MODELS.map((modelConfig, index) => ({
+                            choices: modelsConfig.models.map((modelConfig, index) => ({
                                 label: `${modelConfig.name} - ${modelConfig.description}${currentModelName === modelConfig.name ? ' [CURRENT]' : ''}`,
                                 value: `${index}` // Use index as unique identifier
                             }))
@@ -1881,9 +1971,9 @@ Start by listing the directory structure to understand what you're working with.
                 else {
                     // Direct set via command argument
                     const newModel = args.join(' ');
-                    // Validate model
-                    if (!isValidModel(newModel)) {
-                        responseMessage = `❌ ${getInvalidModelError(newModel)}`;
+                    // Validate model (async)
+                    if (!(await isValidModel(newModel))) {
+                        responseMessage = `❌ ${await getInvalidModelError(newModel)}`;
                         break;
                     }
                     try {
@@ -1926,7 +2016,7 @@ Start by listing the directory structure to understand what you're working with.
                     // 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!';
+                        responseMessage = 'No saved chats found.\n\nStart a new conversation and it will be automatically saved!';
                     }
                     else {
                         // Format chat list for picker display
@@ -1936,13 +2026,13 @@ Start by listing the directory structure to understand what you're working with.
                         }
                         else {
                             // Fallback: show as text if no picker callback
-                            responseMessage = '📚 Saved Chats:\\n\\n' +
+                            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` : '');
+                                    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` : '');
                         }
                     }
                 }
@@ -1950,7 +2040,7 @@ Start by listing the directory structure to understand what you're working with.
                     // 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!';
+                        responseMessage = 'No saved chats found.\n\nStart a new conversation and it will be automatically saved!';
                     }
                     else {
                         // Format chat list for read-only display
@@ -1975,7 +2065,7 @@ Start by listing the directory structure to understand what you're working with.
                     // Show list of saved chats for deletion
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats to delete.';
+                        responseMessage = 'No saved chats to delete.';
                     }
                     else {
                         // Format chat list for delete picker display
@@ -1995,13 +2085,13 @@ Start by listing the directory structure to understand what you're working with.
                     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.';
+                    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.';
+                        responseMessage = 'No saved chats to rename.';
                     }
                     else {
                         // Format chat list for rename picker display
@@ -2018,6 +2108,30 @@ Start by listing the directory structure to understand what you're working with.
                     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 'copy-chat-context':
+                try {
+                    const { formatChatForClipboard } = await import('./utils/chat-formatter.js');
+                    const { copyTextToClipboard } = await import('./utils/text-clipboard.js');
+                    if (this.uiMessageHistory.length === 0) {
+                        responseMessage = 'No messages in current chat to copy.';
+                    }
+                    else {
+                        const formattedChat = formatChatForClipboard(this.uiMessageHistory);
+                        const success = await copyTextToClipboard(formattedChat);
+                        if (success) {
+                            responseMessage = '✅ Chat content copied to clipboard!';
+                        }
+                        else {
+                            responseMessage = '❌ Failed to copy to clipboard.\n\n' +
+                                'This might happen if clipboard access is not available in your environment.\n' +
+                                'Try running the CLI in a terminal with clipboard access.';
+                        }
+                    }
+                }
+                catch (error) {
+                    responseMessage = `❌ Error copying chat content: ${error.message}`;
+                }
+                break;
             case 'exit':
                 process.exit(0);
                 break;
@@ -2084,6 +2198,189 @@ Start by listing the directory structure to understand what you're working with.
                         '  /add-command delete <command>  - Delete a custom command';
                 }
                 break;
+            case 'background-task':
+            case 'bkg':
+            case 'bg-task':
+                // Background task management commands
+                const bkgSubCommand = args[0]?.toLowerCase();
+                if (bkgSubCommand === 'list' || !bkgSubCommand) {
+                    // Show list of running background tasks
+                    const runningTasks = BackgroundTaskManager.getRunningTasks();
+                    if (runningTasks.length === 0) {
+                        responseMessage = '📭 No background tasks running.\n\nSwitch to Background mode (Ctrl+D) to run commands in the background.';
+                    }
+                    else {
+                        // Show picker for task selection
+                        if (this.onShowBackgroundTaskPickerCallback) {
+                            this.onShowBackgroundTaskPickerCallback(runningTasks);
+                            return; // Don't send text response, picker will handle it
+                        }
+                        else {
+                            // Fallback: show as text
+                            responseMessage = '🔄 Running Background Tasks:\n\n' +
+                                runningTasks.map((task, i) => {
+                                    const durationSec = Math.round(task.durationMs / 1000);
+                                    return `${i + 1}. ${task.command}\n   📁 ${task.cwd} | ⏱️ ${durationSec}s running`;
+                                }).join('\n\n');
+                        }
+                    }
+                }
+                else if (bkgSubCommand === 'cancel') {
+                    // Show list of running tasks for cancellation
+                    const runningTasks = BackgroundTaskManager.getRunningTasks();
+                    if (runningTasks.length === 0) {
+                        responseMessage = '📭 No background tasks to cancel.';
+                    }
+                    else {
+                        // Show picker for task cancellation
+                        if (this.onShowBackgroundTaskCancelPickerCallback) {
+                            this.onShowBackgroundTaskCancelPickerCallback(runningTasks);
+                            return; // Don't send text response, picker will handle it
+                        }
+                        else {
+                            responseMessage = '❌ Cancel picker not available. Use /background-task list to see tasks.';
+                        }
+                    }
+                }
+                else {
+                    responseMessage = `Unknown /background-task subcommand: ${bkgSubCommand}\n\n` +
+                        'Usage:\n' +
+                        '  /background-task list    - List running background tasks\n' +
+                        '  /background-task cancel  - Cancel a running background task';
+                }
+                break;
+            case 'sync':
+                // Sync local data to/from cloud
+                if (!apiClient.isAuthenticated()) {
+                    responseMessage = '❌ You must be signed in to sync data.\n\nUse /sign-in to authenticate first.';
+                    break;
+                }
+                // Parse subcommand
+                const syncSubcommand = args[0]?.toLowerCase();
+                if (!syncSubcommand) {
+                    // Show sync help
+                    responseMessage = '☁️  Sync Commands:\n\n' +
+                        '  /sync upload   - Upload local data to cloud (overwrites cloud data)\n' +
+                        '  /sync restore  - Download cloud data and restore locally (overwrites local data)\n\n' +
+                        'Use these commands to backup or restore your chat history and settings.';
+                    break;
+                }
+                if (syncSubcommand === 'upload') {
+                    try {
+                        responseMessage = '☁️  Uploading data to cloud...';
+                        // Send initial response
+                        if (this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(responseMessage);
+                        }
+                        // Gather all local data
+                        const config = this.configManager.load();
+                        const chats = localChatStorage.listChats();
+                        // Load full chat data for each chat
+                        const fullChats = chats.map(chatMeta => {
+                            const fullChat = localChatStorage.loadChat(chatMeta.id);
+                            return fullChat;
+                        }).filter(chat => chat !== null);
+                        // Create sync data structure
+                        const syncData = {
+                            version: 1,
+                            exportedAt: new Date().toISOString(),
+                            config: {
+                                model: config.model,
+                                modelName: config.modelName,
+                                enhancedQuality: config.enhancedQuality,
+                                autonomousMode: config.autonomousMode,
+                            },
+                            chats: fullChats,
+                            metadata: {
+                                totalChats: fullChats.length,
+                                totalMessages: fullChats.reduce((sum, chat) => sum + (chat?.messageCount || 0), 0),
+                            }
+                        };
+                        // Upload to backend
+                        const result = await apiClient.uploadSyncData(syncData);
+                        responseMessage = `✅ Data uploaded successfully!\n\n` +
+                            `📊 Upload Summary:\n` +
+                            `   • Chats: ${fullChats.length}\n` +
+                            `   • Messages: ${syncData.metadata.totalMessages}\n` +
+                            `   • Version: ${result.version}\n` +
+                            `   • Updated: ${new Date(result.updatedAt).toLocaleString()}\n\n` +
+                            `Your local data is now backed up to the cloud.`;
+                    }
+                    catch (error) {
+                        responseMessage = `❌ Upload failed: ${error.message}\n\nPlease try again later.`;
+                    }
+                }
+                else if (syncSubcommand === 'restore') {
+                    try {
+                        responseMessage = '☁️  Downloading data from cloud...';
+                        // Send initial response
+                        if (this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(responseMessage);
+                        }
+                        // Get sync data from backend
+                        const cloudData = await apiClient.getSyncData();
+                        if (!cloudData) {
+                            responseMessage = '❌ No cloud data found.\n\nUse /sync upload first to backup your data.';
+                            break;
+                        }
+                        const syncData = cloudData.syncData;
+                        // Validate sync data structure
+                        if (!syncData || typeof syncData !== 'object') {
+                            responseMessage = '❌ Invalid cloud data format.\n\nPlease try uploading again with /sync upload.';
+                            break;
+                        }
+                        // Restore config if present
+                        if (syncData.config) {
+                            const currentConfig = this.configManager.load();
+                            if (syncData.config.model) {
+                                currentConfig.model = syncData.config.model;
+                            }
+                            if (syncData.config.modelName) {
+                                currentConfig.modelName = syncData.config.modelName;
+                            }
+                            if (typeof syncData.config.enhancedQuality === 'boolean') {
+                                currentConfig.enhancedQuality = syncData.config.enhancedQuality;
+                            }
+                            if (typeof syncData.config.autonomousMode === 'boolean') {
+                                currentConfig.autonomousMode = syncData.config.autonomousMode;
+                            }
+                            this.configManager.save(currentConfig);
+                        }
+                        // Restore chats if present
+                        let restoredChats = 0;
+                        let restoredMessages = 0;
+                        if (syncData.chats && Array.isArray(syncData.chats)) {
+                            for (const chat of syncData.chats) {
+                                if (chat && chat.id) {
+                                    // Import each chat to local storage
+                                    const success = localChatStorage.importChat(chat);
+                                    if (success) {
+                                        restoredChats++;
+                                        restoredMessages += chat.messageCount || chat.messages?.length || 0;
+                                    }
+                                }
+                            }
+                        }
+                        responseMessage = `✅ Data restored successfully!\n\n` +
+                            `📊 Restore Summary:\n` +
+                            `   • Chats restored: ${restoredChats}\n` +
+                            `   • Messages restored: ${restoredMessages}\n` +
+                            `   • Cloud version: ${cloudData.version}\n` +
+                            `   • Last updated: ${new Date(cloudData.updatedAt).toLocaleString()}\n\n` +
+                            `Your local data has been restored from the cloud.\n` +
+                            `Note: Existing local chats with the same ID were overwritten.`;
+                    }
+                    catch (error) {
+                        responseMessage = `❌ Restore failed: ${error.message}\n\nPlease try again later.`;
+                    }
+                }
+                else {
+                    responseMessage = `❌ Unknown sync subcommand: ${syncSubcommand}\n\n` +
+                        'Available subcommands:\n' +
+                        '  /sync upload   - Upload local data to cloud\n' +
+                        '  /sync restore  - Download and restore cloud data locally';
+                }
+                break;
             default:
                 responseMessage = `Unknown command: /${cmd}\nType /help for available commands.`;
         }
@@ -2116,6 +2413,139 @@ Start by listing the directory structure to understand what you're working with.
     setOnShowChatRenamePickerCallback(callback) {
         this.onShowChatRenamePickerCallback = callback;
     }
+    /**
+     * Set callback for background mode change
+     */
+    setOnBackgroundModeChange(callback) {
+        this.onBackgroundModeChange = callback;
+    }
+    /**
+     * Set callback for background task count change
+     */
+    setOnBackgroundTaskCountChange(callback) {
+        this.onBackgroundTaskCountChange = callback;
+        // Subscribe to BackgroundTaskManager count changes
+        BackgroundTaskManager.on('countChanged', (count) => {
+            this.onBackgroundTaskCountChange?.(count);
+        });
+    }
+    /**
+     * Set callback for setting Auto mode (used after background task starts)
+     */
+    setOnSetAutoMode(callback) {
+        this.onSetAutoMode = callback;
+    }
+    /**
+     * Set callback for showing background task picker
+     */
+    setOnShowBackgroundTaskPickerCallback(callback) {
+        this.onShowBackgroundTaskPickerCallback = callback;
+    }
+    /**
+     * Set callback for showing background task cancel picker
+     */
+    setOnShowBackgroundTaskCancelPickerCallback(callback) {
+        this.onShowBackgroundTaskCancelPickerCallback = callback;
+    }
+    /**
+     * Toggle background mode
+     */
+    toggleBackgroundMode() {
+        this.backgroundMode = !this.backgroundMode;
+        if (this.onBackgroundModeChange) {
+            this.onBackgroundModeChange(this.backgroundMode);
+        }
+    }
+    /**
+     * Get current background mode state
+     */
+    getBackgroundMode() {
+        return this.backgroundMode;
+    }
+    /**
+     * Handle background task cancellation
+     */
+    handleBackgroundTaskCancel(taskId) {
+        const task = BackgroundTaskManager.getTask(taskId);
+        const success = BackgroundTaskManager.cancelTask(taskId);
+        if (success) {
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(`🛑 Cancelled background task: ${task?.command || taskId}`);
+            }
+        }
+        else {
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(`❌ Failed to cancel task. It may have already completed.`);
+            }
+        }
+    }
+    /**
+     * Handle background task selection - show task output in focus mode
+     */
+    handleBackgroundTaskSelection(taskId) {
+        const task = BackgroundTaskManager.getTask(taskId);
+        if (!task) {
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(`❌ Task not found: ${taskId}`);
+            }
+            return;
+        }
+        // Get the full output from the task
+        const output = BackgroundTaskManager.getTaskOutput(taskId);
+        // If we have the view callback, use it to show in focus mode (InteractiveShell)
+        if (this.onBackgroundTaskViewCallback) {
+            // Create event handlers for the App.tsx useEffect to subscribe to
+            let onOutputHandler;
+            let onCompleteHandler;
+            // Subscribe to future output updates for this task
+            const outputListener = (taskIdEvent, chunk) => {
+                if (taskIdEvent === taskId && onOutputHandler) {
+                    onOutputHandler(chunk);
+                }
+            };
+            // Subscribe to task completion
+            const completeListener = (taskIdEvent, exitCode) => {
+                if (taskIdEvent === taskId && onCompleteHandler) {
+                    onCompleteHandler(exitCode);
+                    // Cleanup listeners
+                    BackgroundTaskManager.off('taskOutput', outputListener);
+                    BackgroundTaskManager.off('taskCompleted', completeListener);
+                }
+            };
+            BackgroundTaskManager.on('taskOutput', outputListener);
+            BackgroundTaskManager.on('taskCompleted', completeListener);
+            // Invoke the callback to set up shellState in App.tsx
+            this.onBackgroundTaskViewCallback({
+                id: taskId,
+                command: task.command,
+                cwd: task.cwd,
+                output,
+                isRunning: task.isRunning,
+                onOutput: (handler) => { onOutputHandler = handler; },
+                onComplete: (handler) => { onCompleteHandler = handler; }
+            });
+            // If task is already complete, immediately trigger completion
+            if (!task.isRunning && task.exitCode !== undefined) {
+                setTimeout(() => {
+                    if (onCompleteHandler) {
+                        onCompleteHandler(task.exitCode);
+                    }
+                }, 100);
+            }
+        }
+        else {
+            // Fallback: show as static message
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(`📺 Viewing output for: ${task.command}\n\n${output || '(no output yet)'}`);
+            }
+        }
+    }
+    /**
+     * Set callback for showing a background task in focus mode
+     */
+    setOnBackgroundTaskViewCallback(callback) {
+        this.onBackgroundTaskViewCallback = callback;
+    }
     /**
      * Handle chat rename operation
      */
@@ -2177,6 +2607,104 @@ Start by listing the directory structure to understand what you're working with.
             }
         }
     }
+    /**
+     * Handle background mode execution - runs command in background and returns immediately
+     * Supports both local and remote shells (SSH, WSL, Docker)
+     */
+    handleBackgroundModeExecution(command) {
+        if (!command.trim()) {
+            return;
+        }
+        // Get current context to determine if we're in a remote shell
+        const currentContext = this.contextManager.getCurrentContext();
+        let taskId;
+        let effectiveCwd;
+        let remoteContextDisplay;
+        if (currentContext.type === 'local') {
+            // Local execution - use PTY
+            effectiveCwd = this.cwd;
+            taskId = BackgroundTaskManager.startTask(command, effectiveCwd);
+        }
+        else {
+            // Remote execution - use appropriate remote PTY
+            const metadata = currentContext.metadata;
+            effectiveCwd = metadata?.workingDirectory || '~';
+            // Build remote context display string
+            if (currentContext.type === 'ssh' && metadata) {
+                remoteContextDisplay = `${metadata.username || 'user'}@${metadata.hostname || 'remote'}`;
+            }
+            else if (currentContext.type === 'wsl' && metadata) {
+                remoteContextDisplay = `wsl:${metadata.distroName || 'wsl'}`;
+            }
+            else if (currentContext.type === 'docker' && metadata) {
+                remoteContextDisplay = `docker:${metadata.containerId?.substring(0, 12) || 'container'}`;
+            }
+            // Create the remote PTY process and register with BackgroundTaskManager
+            if (currentContext.type === 'ssh') {
+                const sshClient = currentContext.handler?.client;
+                if (!sshClient) {
+                    if (this.onResponseCallback) {
+                        this.onResponseCallback('❌ SSH client not available for background task');
+                    }
+                    return;
+                }
+                // Start remote task first to get callbacks
+                const remoteTask = BackgroundTaskManager.startRemoteTask(command, effectiveCwd, remoteContextDisplay || 'ssh');
+                taskId = remoteTask.id;
+                // Create SSH PTY with the callbacks from BackgroundTaskManager
+                const sshPty = runSSHCommand(sshClient, command, effectiveCwd, remoteTask.onData, remoteTask.onExit);
+                remoteTask.setRemotePty(sshPty);
+            }
+            else if (currentContext.type === 'wsl') {
+                const distribution = metadata?.distroName || 'Ubuntu';
+                // Start remote task first to get callbacks
+                const remoteTask = BackgroundTaskManager.startRemoteTask(command, effectiveCwd, remoteContextDisplay || 'wsl');
+                taskId = remoteTask.id;
+                // Create WSL PTY with the callbacks from BackgroundTaskManager
+                const wslPty = runWSLCommand(distribution, command, effectiveCwd, remoteTask.onData, remoteTask.onExit);
+                remoteTask.setRemotePty(wslPty);
+            }
+            else if (currentContext.type === 'docker') {
+                const containerId = metadata?.containerId;
+                if (!containerId) {
+                    if (this.onResponseCallback) {
+                        this.onResponseCallback('❌ Docker container ID not available for background task');
+                    }
+                    return;
+                }
+                // Start remote task first to get callbacks
+                const remoteTask = BackgroundTaskManager.startRemoteTask(command, effectiveCwd, remoteContextDisplay || 'docker');
+                taskId = remoteTask.id;
+                // Create Docker PTY with the callbacks from BackgroundTaskManager
+                const dockerPty = runDockerCommand(containerId, command, effectiveCwd, remoteTask.onData, remoteTask.onExit);
+                remoteTask.setRemotePty(dockerPty);
+            }
+            else {
+                // Unknown remote type - fall back to local
+                effectiveCwd = this.cwd;
+                taskId = BackgroundTaskManager.startTask(command, effectiveCwd);
+            }
+        }
+        // Notify user that task started
+        const count = BackgroundTaskManager.getRunningCount();
+        const locationInfo = remoteContextDisplay
+            ? `\n📍 Running on: ${remoteContextDisplay}`
+            : '';
+        if (this.onDirectMessageCallback) {
+            this.onDirectMessageCallback(`🚀 Background task started: ${command}${locationInfo}\n\nTask ID: ${taskId}\nUse /background-task list to see running tasks.`);
+        }
+        // Optionally record to history for AI context
+        this.recordShellCommandToHistory(command, '[Running in background]', effectiveCwd);
+        // Reset to Auto mode after starting task
+        this.backgroundMode = false;
+        if (this.onBackgroundModeChange) {
+            this.onBackgroundModeChange(false);
+        }
+        // Enable Auto mode in InputBox
+        if (this.onSetAutoMode) {
+            this.onSetAutoMode(true);
+        }
+    }
     /**
      * 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