centaurus-cli 2.7.3 → 2.8.1

package/dist/cli-adapter.js

@@ -7,13 +7,13 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { ConfigManager } from './config/manager.js';
 import { ToolRegistry } from './tools/registry.js';
-import { viewFileTool, writeToFileTool, editFileTool, listDirTool } from './tools/file-ops.js';
+import { viewFileTool, writeToFileTool, editFileTool, listDirTool, multiEditFileTool } from './tools/file-ops.js';
 import { runCommandTool } from './tools/command.js';
 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 { exitPlanModeTool, getPlanStatusTool, updatePlanStepTool } from './tools/plan-mode.js';
+import { createPlanTool, markTaskCompleteTool, getCurrentPlan, clearPlan, approvePlan, getPlanContextForPrompt } from './tools/plan-mode.js';
 import { webSearchTool, fetchUrlTool } from './tools/web-search.js';
 import { taskCompleteTool } from './tools/task-complete.js';
 import { apiClient } from './services/api-client.js';
@@ -27,16 +27,18 @@ import { SSHHandler } from './context/handlers/ssh-handler.js';
 import { WSLHandler } from './context/handlers/wsl-handler.js';
 import { DockerHandler } from './context/handlers/docker-handler.js';
 import { AIContextInjector } from './services/ai-context-injector.js';
-import { environmentContextInjector } from './services/environment-context-injector.js';
 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';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
     conversationHistory = [];
     cwd;
     planMode = false;
+    pendingPlanRequest = null; // Stores original user request during planning phase
     commandMode = false;
     previousMode = 'execution';
     onResponseCallback;
@@ -53,6 +55,8 @@ export class CentaurusCLI {
     onToolStreamingOutput;
     onPlanModeChange;
     onPlanApprovalRequest;
+    onPlanCreated;
+    onTaskCompleted;
     onPasswordRequest;
     currentInteractiveProcess;
     conversationStarted = false;
@@ -62,6 +66,7 @@ export class CentaurusCLI {
     onSubshellContextChange;
     currentAbortController;
     mcpCommandHandler;
+    onInteractiveEditorMode;
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -116,6 +121,12 @@ export class CentaurusCLI {
     setOnPlanApprovalRequest(callback) {
         this.onPlanApprovalRequest = callback;
     }
+    setOnPlanCreated(callback) {
+        this.onPlanCreated = callback;
+    }
+    setOnTaskCompleted(callback) {
+        this.onTaskCompleted = callback;
+    }
     setOnCommandModeChange(callback) {
         this.onCommandModeChange = callback;
     }
@@ -135,6 +146,9 @@ export class CentaurusCLI {
             this.sshHandler.setPasswordRequestCallback(callback);
         }
     }
+    setOnInteractiveEditorMode(callback) {
+        this.onInteractiveEditorMode = callback;
+    }
     async initializeMCP() {
         try {
             const mcpConfigManager = new MCPConfigManager();
@@ -256,15 +270,15 @@ export class CentaurusCLI {
         this.toolRegistry.register(viewFileTool);
         this.toolRegistry.register(writeToFileTool);
         this.toolRegistry.register(editFileTool);
+        this.toolRegistry.register(multiEditFileTool);
         this.toolRegistry.register(listDirTool);
         this.toolRegistry.register(runCommandTool);
         this.toolRegistry.register(grepSearchTool);
         this.toolRegistry.register(findFilesTool);
         this.toolRegistry.register(getDiffTool);
         this.toolRegistry.register(inspectSymbolTool);
-        this.toolRegistry.register(exitPlanModeTool);
-        this.toolRegistry.register(getPlanStatusTool);
-        this.toolRegistry.register(updatePlanStepTool);
+        this.toolRegistry.register(createPlanTool);
+        this.toolRegistry.register(markTaskCompleteTool);
         this.toolRegistry.register(webSearchTool);
         this.toolRegistry.register(fetchUrlTool);
         this.toolRegistry.register(taskCompleteTool);
@@ -394,6 +408,10 @@ Press Enter to continue...
         if (!apiClient.isAuthenticated()) {
             throw new Error('Authentication required. Please sign in to use AI features.');
         }
+        // Store original request if in planning mode (for execution phase after approval)
+        if (this.planMode && !this.pendingPlanRequest) {
+            this.pendingPlanRequest = message;
+        }
         // Add user message to history
         this.conversationHistory.push({
             role: 'user',
@@ -401,6 +419,9 @@ Press Enter to continue...
         });
         // Save user message to backend
         await this.saveMessageToBackend('user', message);
+        // Start logging session and log user message
+        conversationLogger.startSession();
+        conversationLogger.logUserMessage(message);
         try {
             const tools = this.toolRegistry.getSchemas();
             const context = {
@@ -429,27 +450,10 @@ Press Enter to continue...
             const selectedModelConfig = ALL_MODELS.find(m => m.id === selectedModelId && m.name === config.modelName);
             const selectedModel = selectedModelId;
             const selectedModelThinkingConfig = selectedModelConfig?.thinkingConfig;
-            // Create messages array and inject system prompt with environment context
-            // Always use the autonomous prompt (optimized for agentic code generation)
-            const systemPromptPath = path.join(__dirname, '..', 'prompts', 'system-prompt-autonomous.md');
-            let systemPrompt = '';
-            try {
-                systemPrompt = fs.readFileSync(systemPromptPath, 'utf-8');
-            }
-            catch (error) {
-                // Fallback to basic prompt if file not found
-                systemPrompt = 'You are Centaurus, a Senior Site Reliability Engineer (SRE) and Full-Stack Architect embedded in a CLI.';
-            }
-            // Enhance system prompt with environment context
-            const enhancedSystemPrompt = environmentContextInjector.getEnhancedSystemPrompt(systemPrompt);
-            // Build messages array with enhanced system prompt at the beginning
-            let messages = [
-                {
-                    role: 'system',
-                    content: enhancedSystemPrompt,
-                },
-                ...this.conversationHistory
-            ];
+            // Build messages array WITHOUT system prompt - backend will inject it
+            // The backend uses cli-system-prompt.md for CLI clients
+            // We pass environmentContext and mode separately so backend can inject them
+            let messages = [...this.conversationHistory];
             // Inject subshell context if in a subshell environment
             const currentContext = this.contextManager.getCurrentContext();
             messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
@@ -466,44 +470,61 @@ Press Enter to continue...
             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
+            // 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
+            const recentToolCalls = [];
+            // ANTI-LOOP: Track ALL duplicate tool calls (not just file ops)
+            const toolCallTracker = new Map(); // Hash -> count
+            const MAX_IDENTICAL_TOOL_CALLS = 3; // Max times exact same tool call allowed
             // Create AbortController for this request
             this.currentAbortController = new AbortController();
             // Multi-turn tool execution loop
             while (turnCount < MAX_TURNS) {
                 turnCount++;
                 // Refresh environment context to capture any CWD changes from previous turns
+                // This is sent to backend which will inject it into the system prompt
                 environmentContext = this.getEnvironmentContext();
-                // Refresh system prompt with new CWD
-                const refreshedSystemPrompt = environmentContextInjector.getEnhancedSystemPrompt(systemPrompt, this.cwd);
-                // Update the system message in the messages array
-                if (messages.length > 0 && messages[0].role === 'system') {
-                    messages[0].content = refreshedSystemPrompt;
-                }
                 let assistantMessage = '';
                 let toolCalls = [];
+                // 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),
+                    byRole: {
+                        system: messages.filter(m => m.role === 'system').length,
+                        user: messages.filter(m => m.role === 'user').length,
+                        assistant: messages.filter(m => m.role === 'assistant').length,
+                        tool: messages.filter(m => m.role === 'tool').length
+                    },
+                    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`);
+                }
+                catch (e) { }
                 // 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)) {
                     // Handle error chunks
                     if (chunk.type === 'error') {
+                        conversationLogger.logError('AI Stream', new Error(chunk.message));
                         throw new Error(chunk.message);
                     }
                     // Handle thought chunks (internal reasoning)
                     if (chunk.type === 'thought') {
-                        // Debug logging to file
-                        fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Received thought chunk: ${chunk.content.substring(0, 100)}\n`);
+                        conversationLogger.logThoughtChunk(chunk.content);
                         if (!thoughtStartTime) {
                             thoughtStartTime = Date.now();
                         }
                         thoughtContent += chunk.content;
                         // Send thought to UI callback if available
                         if (this.onThoughtStreamCallback) {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Calling onThoughtStreamCallback\n`);
                             this.onThoughtStreamCallback(chunk.content);
                         }
-                        else {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] WARNING: onThoughtStreamCallback is not set!\n`);
-                        }
                         continue;
                     }
                     // Handle text chunks
@@ -511,6 +532,7 @@ Press Enter to continue...
                         // If we were thinking and now got text, finalize the thought
                         if (thoughtStartTime) {
                             const thinkingDuration = Math.round((Date.now() - thoughtStartTime) / 1000);
+                            conversationLogger.logThoughtComplete(thinkingDuration);
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
@@ -523,6 +545,7 @@ Press Enter to continue...
                         filteredContent = filteredContent.trim();
                         if (filteredContent) {
                             assistantMessage += filteredContent;
+                            conversationLogger.logAITextChunk(filteredContent);
                             // Send chunk to UI in real-time
                             if (this.onResponseStreamCallback) {
                                 this.onResponseStreamCallback(filteredContent);
@@ -531,9 +554,17 @@ Press Enter to continue...
                     }
                     // Handle tool call chunks
                     if (chunk.type === 'tool_call') {
+                        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`);
+                        }
+                        catch (e) { }
+                        conversationLogger.logToolCall(toolCall?.name || 'unknown', toolCall?.id || 'unknown', toolCall?.arguments || {});
                         // If we were thinking and now got a tool call, finalize the thought
                         if (thoughtStartTime) {
                             const thinkingDuration = Math.round((Date.now() - thoughtStartTime) / 1000);
+                            conversationLogger.logThoughtComplete(thinkingDuration);
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
@@ -541,29 +572,48 @@ Press Enter to continue...
                             thoughtContent = '';
                         }
                         toolCalls.push(chunk.toolCall);
+                        // IMMEDIATELY notify UI that a tool call was received (pending status)
+                        // This shows tool calls in the UI as they stream in, not after the stream ends
+                        if (this.onToolExecutionUpdate && toolCall) {
+                            this.onToolExecutionUpdate({
+                                toolName: toolCall.name,
+                                status: 'pending', // 'pending' means received but not yet executing
+                                arguments: toolCall.arguments
+                            });
+                        }
+                        // 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`);
+                        }
+                        catch (e) { }
                     }
                     // Handle done chunk
                     if (chunk.type === 'done') {
                         // If we were thinking and stream ended, finalize the thought
                         if (thoughtStartTime) {
                             const thinkingDuration = Math.round((Date.now() - thoughtStartTime) / 1000);
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Stream done, finalizing thinking: ${thinkingDuration}s\n`);
+                            conversationLogger.logThoughtComplete(thinkingDuration);
                             if (this.onThoughtCompleteCallback) {
-                                fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Calling onThoughtCompleteCallback from done handler\n`);
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
-                            else {
-                                fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] WARNING: onThoughtCompleteCallback not set in done handler!\n`);
-                            }
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
-                        else {
-                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Stream done but no thinking was in progress\n`);
-                        }
+                        // Log AI text completion
+                        conversationLogger.logAITextComplete();
+                        conversationLogger.logStreamEnd('done');
                         break;
                     }
                 } // End of stream loop
+                // Log loop state after stream ends
+                conversationLogger.logLoopState(turnCount, {
+                    toolCallCount: toolCalls.length,
+                    assistantMessageLength: assistantMessage.length,
+                    hasToolCalls: toolCalls.length > 0,
+                    willContinue: toolCalls.length > 0,
+                    narrationAttempts,
+                    completionAttempts,
+                });
                 // If there are tool calls, execute them
                 if (toolCalls.length > 0) {
                     // CRITICAL: AI should ONLY communicate via reason_text and task_complete summary
@@ -578,16 +628,23 @@ Press Enter to continue...
                         toolCalls = toolCalls.slice(0, MAX_TOOL_CALLS_PER_TURN);
                     }
                     const toolResults = [];
+                    const handledToolCallIds = new Set(); // Track tool calls that were handled directly (e.g., create_plan, mark_task_complete)
                     let userCancelledOperation = false;
                     let taskCompleted = false;
                     let taskCompleteSummary = '';
                     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`);
+                        }
+                        catch (e) { }
                         const toolCall = toolCalls[i];
                         try {
                             // Check if this is task_complete FIRST (before displaying anything)
                             if (toolCall.name === 'task_complete') {
                                 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 = '';
@@ -597,19 +654,218 @@ Press Enter to continue...
                                 }
                                 // Execute the tool for proper result handling
                                 await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+                                // Clear the plan when task is complete
+                                clearPlan();
                                 // Stop processing remaining tools
                                 break;
                             }
+                            if (toolCall.name === 'create_plan') {
+                                // Execute the tool to create the plan
+                                const execResult = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+                                // Extract the actual result string (toolRegistry.execute returns { success, result })
+                                const result = execResult.success ? String(execResult.result) : `Error: ${execResult.error}`;
+                                // Parse the PLAN_CREATED response to get the plan
+                                if (typeof result === 'string' && result.startsWith('PLAN_CREATED:')) {
+                                    const planJson = result.substring('PLAN_CREATED:'.length);
+                                    try {
+                                        const plan = JSON.parse(planJson);
+                                        // Notify UI that a plan was created
+                                        if (this.onPlanCreated) {
+                                            this.onPlanCreated(plan);
+                                        }
+                                        // If we have approval callback, ask for approval
+                                        if (this.onPlanApprovalRequest) {
+                                            const approved = await this.onPlanApprovalRequest(plan);
+                                            if (approved) {
+                                                // Approve and activate the plan
+                                                approvePlan();
+                                                // Suppress any text output
+                                                assistantMessage = '';
+                                                // Switch out of plan mode to execution mode
+                                                this.planMode = false;
+                                                if (this.onPlanModeChange) {
+                                                    this.onPlanModeChange(false);
+                                                }
+                                                // Add assistant message with plan tool call to history
+                                                this.conversationHistory.push({
+                                                    role: 'assistant',
+                                                    content: '',
+                                                    tool_calls: [toolCall],
+                                                });
+                                                // Add plan approval response
+                                                this.conversationHistory.push({
+                                                    role: 'tool',
+                                                    tool_call_id: toolCall.id,
+                                                    content: 'Plan approved by user. Now switching to execution mode.',
+                                                });
+                                                // 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();
+                                                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.`;
+                                                this.conversationHistory.push({
+                                                    role: 'user',
+                                                    content: executionPrompt,
+                                                });
+                                                // Clear pending plan request
+                                                this.pendingPlanRequest = null;
+                                                // Update messages array for this turn
+                                                messages = [...this.conversationHistory];
+                                                // Continue the loop - AI will now execute with plan context
+                                                continue;
+                                            }
+                                            else {
+                                                // User wants to edit - stop the loop, they'll provide feedback
+                                                clearPlan();
+                                                finalAssistantMessage = 'Plan editing requested. Please provide your feedback or modifications.';
+                                                taskCompleted = true;
+                                                break;
+                                            }
+                                        }
+                                        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({
+                                                role: 'assistant',
+                                                content: '',
+                                                tool_calls: [toolCall],
+                                            });
+                                            this.conversationHistory.push({
+                                                role: 'tool',
+                                                tool_call_id: toolCall.id,
+                                                content: `Plan created: "${plan.title}" with ${plan.steps.length} tasks. Waiting for user approval.`,
+                                            });
+                                            // Mark this tool call as handled so it's not duplicated
+                                            handledToolCallIds.add(toolCall.id);
+                                            // Update messages for next iteration
+                                            messages = [...this.conversationHistory];
+                                            // Stop and wait for user to approve
+                                            finalAssistantMessage = `Plan created: ${plan.title}. Please approve to continue.`;
+                                            taskCompleted = true;
+                                            break;
+                                        }
+                                    }
+                                    catch (parseError) {
+                                        // Log error and add error result to history so AI knows
+                                        console.error('Failed to parse plan:', parseError);
+                                        // CRITICAL: Add tool result even on parse error to prevent silent loop
+                                        this.conversationHistory.push({
+                                            role: 'assistant',
+                                            content: '',
+                                            tool_calls: [toolCall],
+                                        });
+                                        this.conversationHistory.push({
+                                            role: 'tool',
+                                            tool_call_id: toolCall.id,
+                                            content: `Error parsing plan: ${parseError}. Please try again with valid plan format.`,
+                                        });
+                                        // Mark this tool call as handled so it's not duplicated
+                                        handledToolCallIds.add(toolCall.id);
+                                        messages = [...this.conversationHistory];
+                                    }
+                                }
+                                else {
+                                    // Tool returned non-PLAN_CREATED result - add it to history
+                                    this.conversationHistory.push({
+                                        role: 'assistant',
+                                        content: '',
+                                        tool_calls: [toolCall],
+                                    });
+                                    this.conversationHistory.push({
+                                        role: 'tool',
+                                        tool_call_id: toolCall.id,
+                                        content: result || 'create_plan executed but returned empty result.',
+                                    });
+                                    // Mark this tool call as handled so it's not duplicated
+                                    handledToolCallIds.add(toolCall.id);
+                                    messages = [...this.conversationHistory];
+                                }
+                                continue;
+                            }
+                            if (toolCall.name === 'mark_task_complete') {
+                                // Execute the tool
+                                const execResult = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+                                // Extract the actual result string (toolRegistry.execute returns { success, result })
+                                const result = execResult.success ? String(execResult.result) : `Error: ${execResult.error}`;
+                                // Parse the TASK_COMPLETED response
+                                if (typeof result === 'string' && result.startsWith('TASK_COMPLETED:')) {
+                                    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);
+                                        }
+                                        // 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
+                                        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}`,
+                                        });
+                                        // If all tasks are complete, prompt AI to call task_complete
+                                        if (completion.allComplete) {
+                                            toolResults[toolResults.length - 1].result =
+                                                'All tasks in the plan are now completed! Call task_complete with a summary of what was accomplished.';
+                                        }
+                                    }
+                                    catch (parseError) {
+                                        console.error('Failed to parse task completion:', parseError);
+                                    }
+                                }
+                                continue;
+                            }
+                            // ANTI-LOOP: Only detect EXACT identical tool calls (same name + same args)
+                            // This is a safety net - the backend fix (functionCall in messages) should prevent loops
+                            // We use a HIGH threshold to avoid blocking legitimate multi-step operations
+                            const toolArgsToTrack = { ...toolCall.arguments };
+                            delete toolArgsToTrack.reason_text; // Ignore reason_text - only matters for params
+                            const toolCallHash = `${toolCall.name}:${JSON.stringify(toolArgsToTrack)}`;
+                            const toolCallCount = (toolCallTracker.get(toolCallHash) || 0) + 1;
+                            toolCallTracker.set(toolCallHash, toolCallCount);
+                            // Only stop after 5 IDENTICAL calls (same tool + same exact args)
+                            if (toolCallCount > 5) {
+                                // Log the loop detection
+                                conversationLogger.logNarrationDetection('duplicate_tool_loop', {
+                                    toolName: toolCall.name,
+                                    callCount: toolCallCount,
+                                    maxAllowed: 5
+                                });
+                                // Force task completion with a helpful message
+                                const loopMessage = `⚠️ **Loop Detected**: The AI called \`${toolCall.name}\` with identical parameters ${toolCallCount} times.\n\n` +
+                                    `The system has stopped to prevent an infinite loop.\n\n` +
+                                    `**Tip**: Try rephrasing your request or ask about a specific aspect of the task.`;
+                                if (this.onResponseStreamCallback) {
+                                    this.onResponseStreamCallback(loopMessage);
+                                }
+                                // Set as completed and break
+                                finalAssistantMessage = loopMessage;
+                                taskCompleted = true;
+                                break;
+                            }
+                            // NOTE: File-specific loop detection REMOVED
+                            // The backend now includes functionCall parts in assistant messages,
+                            // so the AI should properly remember its previous actions and not repeat them.
                             // Extract and display reason_text if present (but skip for task_complete)
                             const reasonText = toolCall.arguments.reason_text;
                             if (reasonText && this.onResponseStreamCallback) {
                                 this.onResponseStreamCallback(reasonText + '\n\n');
                             }
+                            // Determine the effective CWD for this command (use remote context CWD if applicable)
+                            const currentCtx = this.contextManager.getCurrentContext();
+                            const effectiveCwd = currentCtx.type !== 'local'
+                                ? currentCtx.metadata?.workingDirectory || '~'
+                                : this.cwd;
                             // Notify UI: tool is executing (send before execution starts)
                             if (this.onToolExecutionUpdate) {
                                 // Add cwd to arguments for execute_command tool
                                 const toolArgs = toolCall.name === 'execute_command'
-                                    ? { ...toolCall.arguments, cwd: this.cwd }
+                                    ? { ...toolCall.arguments, cwd: effectiveCwd }
                                     : toolCall.arguments;
                                 this.onToolExecutionUpdate({
                                     toolName: toolCall.name,
@@ -617,14 +873,18 @@ Press Enter to continue...
                                     arguments: toolArgs
                                 });
                             }
+                            // Log tool execution start
+                            conversationLogger.logToolExecutionStart(toolCall.name, toolCall.id);
                             // Execute the tool (it will request approval if needed)
                             const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                             if (result.success) {
+                                // Log successful tool result
+                                conversationLogger.logToolResult(toolCall.name, toolCall.id, result.result, true);
                                 // Notify UI: tool succeeded (send full result to UI)
                                 if (this.onToolExecutionUpdate) {
                                     // Add cwd to arguments for execute_command tool
                                     const toolArgs = toolCall.name === 'execute_command'
-                                        ? { ...toolCall.arguments, cwd: this.cwd }
+                                        ? { ...toolCall.arguments, cwd: effectiveCwd }
                                         : toolCall.arguments;
                                     this.onToolExecutionUpdate({
                                         toolName: toolCall.name,
@@ -653,6 +913,8 @@ Press Enter to continue...
                                 });
                             }
                             else {
+                                // Log failed tool result
+                                conversationLogger.logToolResult(toolCall.name, toolCall.id, null, false, result.error);
                                 // Check if operation was cancelled by user
                                 if (result.error && result.error.includes('Operation cancelled by user')) {
                                     userCancelledOperation = true;
@@ -661,7 +923,7 @@ Press Enter to continue...
                                 if (this.onToolExecutionUpdate) {
                                     // Add cwd to arguments for execute_command tool
                                     const toolArgs = toolCall.name === 'execute_command'
-                                        ? { ...toolCall.arguments, cwd: this.cwd }
+                                        ? { ...toolCall.arguments, cwd: effectiveCwd }
                                         : toolCall.arguments;
                                     this.onToolExecutionUpdate({
                                         toolName: toolCall.name,
@@ -682,6 +944,8 @@ Press Enter to continue...
                             }
                         }
                         catch (error) {
+                            // Log tool execution error
+                            conversationLogger.logError(`Tool execution: ${toolCall.name}`, error);
                             // Check if operation was cancelled by user
                             if (error.message && error.message.includes('Operation cancelled by user')) {
                                 userCancelledOperation = true;
@@ -726,14 +990,10 @@ Press Enter to continue...
                         });
                         // Add tool results to history
                         for (const toolResult of toolResults) {
-                            const toolMessage = {
-                                tool_call_id: toolResult.tool_call_id,
-                                name: toolResult.name,
-                                result: toolResult.result,
-                            };
                             this.conversationHistory.push({
                                 role: 'tool',
-                                content: JSON.stringify(toolMessage),
+                                tool_call_id: toolResult.tool_call_id,
+                                content: typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result),
                             });
                         }
                         // Set final message indicating cancellation
@@ -746,35 +1006,42 @@ Press Enter to continue...
                         this.onResponseStreamCallback(assistantMessage);
                     }
                     // Add assistant message with tool calls to conversation history
-                    this.conversationHistory.push({
-                        role: 'assistant',
-                        content: assistantMessage || '',
-                        tool_calls: toolCalls, // Store tool calls for MaaS models
-                    });
+                    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`);
+                        }
+                        catch (e) { }
+                    }
+                    else {
+                        try {
+                            fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Adapting assistant message: NO toolCalls\n`);
+                        }
+                        catch (e) { }
+                    }
+                    // Filter out tool calls that were already handled directly (e.g., create_plan, mark_task_complete)
+                    const unhandledToolCalls = toolCalls.filter(tc => !handledToolCallIds.has(tc.id));
+                    // Only add assistant message if there are unhandled tool calls
+                    if (unhandledToolCalls.length > 0) {
+                        this.conversationHistory.push({
+                            role: 'assistant',
+                            content: assistantMessage || '',
+                            tool_calls: unhandledToolCalls, // Only include unhandled tool calls
+                        });
+                    }
                     // Add tool results to conversation history as tool messages
                     // Format: { tool_call_id, name, result: <object or string> }
-                    // Include system instruction to remind AI to continue if needed
                     for (const toolResult of toolResults) {
-                        const toolMessage = {
-                            tool_call_id: toolResult.tool_call_id,
-                            name: toolResult.name,
-                            result: toolResult.result,
-                            system_instruction: 'IMPORTANT: This tool executed successfully. If there are MORE steps needed to complete the task, continue executing the necessary tools. If the task is fully complete, call the task_complete tool with a comprehensive summary.'
-                        };
+                        // Add tool result to conversation history as tool message
+                        // IMPORTANT: tool_call_id must be a top-level property
                         this.conversationHistory.push({
                             role: 'tool',
-                            content: JSON.stringify(toolMessage),
+                            tool_call_id: toolResult.tool_call_id,
+                            content: typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result),
                         });
                     }
                     // Rebuild messages array with updated history
-                    // IMPORTANT: Re-add system prompt for each turn
-                    messages = [
-                        {
-                            role: 'system',
-                            content: enhancedSystemPrompt,
-                        },
-                        ...this.conversationHistory
-                    ];
+                    // Backend will inject system prompt
+                    messages = [...this.conversationHistory];
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
                     continue; // Loop back to AI service
@@ -786,12 +1053,17 @@ Press Enter to continue...
                         // No tool calls and no message - AI stopped silently
                         // This usually means the AI thinks it's done but didn't call task_complete
                         // Prompt it to either continue or complete
+                        conversationLogger.logNarrationDetection('silent_stop', {
+                            turn: turnCount,
+                            assistantMessageLength: 0,
+                        });
                         const silentStopPrompt = '⚠️ **SILENT STOP DETECTED**: You ended your turn without any output or tool calls.\n\n' +
                             '**This is not allowed.** You must either:\n' +
                             '1. Execute a tool call if more work is needed, OR\n' +
                             '2. Call task_complete() with a summary of what you accomplished\n\n' +
                             '**If you have completed the task**, call task_complete() NOW with a comprehensive summary.\n' +
                             '**If more work is needed**, execute the next tool call immediately.';
+                        conversationLogger.logSystemPrompt('silent_stop_prompt', silentStopPrompt);
                         this.conversationHistory.push({
                             role: 'user',
                             content: silentStopPrompt,
@@ -802,9 +1074,19 @@ Press Enter to continue...
                         const isNarration = /\b(I will|I'll|Let me|Let's|I need to|I'm going to|I should|I can)\b/i.test(assistantMessage);
                         if (isNarration) {
                             narrationAttempts++;
+                            conversationLogger.logNarrationDetection('narration', {
+                                turn: turnCount,
+                                narrationAttempts,
+                                maxAttempts: MAX_NARRATION_ATTEMPTS,
+                                messagePreview: assistantMessage.substring(0, 200),
+                            });
                             // If AI keeps narrating without executing, force completion immediately
                             if (narrationAttempts >= MAX_NARRATION_ATTEMPTS) {
                                 // Force task completion with error message
+                                conversationLogger.logNarrationDetection('narration', {
+                                    action: 'forced_completion',
+                                    reason: 'max_narration_attempts_reached',
+                                });
                                 finalAssistantMessage = '⚠️ **Task Incomplete**: The AI repeatedly described actions without executing them.\n\n' +
                                     '**What happened**: The AI entered a narration loop, describing what it wanted to do instead of using tool calls.\n\n' +
                                     '**Suggestions**:\n' +
@@ -859,9 +1141,18 @@ Press Enter to continue...
                             const isFinalAnswer = assistantMessage.length > 20;
                             if (isFinalAnswer) {
                                 completionAttempts++;
+                                conversationLogger.logNarrationDetection('final_answer', {
+                                    turn: turnCount,
+                                    completionAttempts,
+                                    messagePreview: assistantMessage.substring(0, 200),
+                                });
                                 // If AI keeps providing text summaries without calling task_complete, accept the text and finish
                                 // This prevents the infinite loop where the AI keeps summarizing in response to our prompt
                                 if (completionAttempts > 1) {
+                                    conversationLogger.logNarrationDetection('final_answer', {
+                                        action: 'accepting_text_as_final',
+                                        reason: 'multiple_completion_attempts',
+                                    });
                                     finalAssistantMessage = assistantMessage;
                                     break;
                                 }
@@ -886,13 +1177,12 @@ Press Enter to continue...
                             }
                         }
                     }
-                    // Rebuild messages array
+                    // Rebuild messages array with updated history
+                    // Backend will inject system prompt
                     messages = [...this.conversationHistory];
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
-                    // Add delay before prompting
-                    await new Promise(resolve => setTimeout(resolve, 500));
-                    // Continue loop to get AI's response
+                    // Continue loop to get AI's response (removed 500ms delay for faster response)
                     continue;
                 }
                 // No tool calls and no message - AI stopped silently
@@ -908,7 +1198,8 @@ Press Enter to continue...
                     role: 'user',
                     content: silentStopPrompt,
                 });
-                // Rebuild messages array
+                // Rebuild messages array with updated history
+                // Backend will inject system prompt
                 messages = [...this.conversationHistory];
                 // Re-inject subshell context
                 messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
@@ -943,32 +1234,19 @@ Press Enter to continue...
                 // Save assistant message to backend
                 await this.saveMessageToBackend('assistant', finalMessage);
             } // End of while loop
-            // Parse response for plan mode
-            if (this.planMode) {
-                const planData = this.parsePlanResponse(finalAssistantMessage);
-                if (planData && this.onPlanApprovalRequest) {
-                    // Ask user for approval
-                    const approved = await this.onPlanApprovalRequest(planData);
-                    if (approved) {
-                        // Switch to execution mode
-                        this.planMode = false;
-                        if (this.onPlanModeChange) {
-                            this.onPlanModeChange(false);
-                        }
-                        // Send message to start execution
-                        await this.handleMessage('Let\'s implement the plan we just discussed. Start with the first task.');
-                        return;
-                    }
-                }
-            }
+            // Log session end
+            conversationLogger.endSession(finalAssistantMessage, turnCount);
             // Send response back to UI (only if there's a message)
             if (this.onResponseCallback && finalAssistantMessage) {
                 this.onResponseCallback(finalAssistantMessage);
             }
         }
         catch (error) {
+            // Log the error
+            conversationLogger.logError('handleMessage', error);
             // Check if this was an abort/cancellation
             if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                conversationLogger.logError('handleMessage', new Error('Request cancelled by user'));
                 if (this.onResponseCallback) {
                     this.onResponseCallback('⚠️ Request cancelled by user.');
                 }
@@ -995,16 +1273,20 @@ Press Enter to continue...
                     `/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` +
                     `/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` +
                     `/logout     - Sign out, clear session, and exit CLI\n` +
                     `/exit       - Exit the application\n\n` +
                     `Keyboard Shortcuts:\n\n` +
-                    `Ctrl+D      - Toggle command mode (execute terminal commands directly)\n` +
-                    `Tab         - Autocomplete files/directories (in command mode)\n` +
+                    `Ctrl+D      - Cycle modes (Agent → Terminal → Auto)\n` +
                     `Ctrl+T      - Toggle auto-accept mode\n` +
-                    `?           - Show keyboard shortcuts help`;
+                    `Ctrl+C      - Cancel operation / Exit (press twice)\n` +
+                    `Tab         - Autocomplete files/directories (in command mode)\n` +
+                    `Ctrl+Z      - Undo last input change\n` +
+                    `Ctrl+A      - Select all text`;
                 break;
             case 'init':
                 try {
@@ -1392,6 +1674,22 @@ Start by listing the directory structure to understand what you're working with.
                     responseMessage = '❌ MCP is not initialized. Please restart the CLI.';
                 }
                 break;
+            case 'docs':
+                // Open documentation URL in default browser
+                const docsUrl = 'https://centaurus-web.vercel.app/docs';
+                const { exec } = await import('child_process');
+                const platform = process.platform;
+                if (platform === 'win32') {
+                    exec(`start "" "${docsUrl}"`);
+                }
+                else if (platform === 'darwin') {
+                    exec(`open "${docsUrl}"`);
+                }
+                else {
+                    exec(`xdg-open "${docsUrl}"`);
+                }
+                responseMessage = `📖 Opening documentation in your browser...\n\n${docsUrl}`;
+                break;
             case 'exit':
                 process.exit(0);
                 break;
@@ -1432,25 +1730,41 @@ Start by listing the directory structure to understand what you're working with.
         return 'default';
     }
     getPlanModeInstructions() {
-        return `\n\n## PLAN MODE ACTIVE\n\nYou are currently in PLAN MODE. In this mode, you should:\n\n1. **Explore the current directory** using list_directory and read_file tools to understand the codebase structure\n2. **Research the topic** using the web_search tool to gather best practices and implementation approaches\n3. **Create a detailed implementation plan** with ordered tasks\n\nWhen you've completed your planning, you MUST format your response in this EXACT format:\n\n<tasks>\n1. First task description\n2. Second task description\n3. Third task description\n...\n</tasks>\n\n<question>\nShall I proceed with implementing this plan?\n</question>\n\nIMPORTANT:\n- The <tasks> section must contain a numbered list of tasks in order\n- The <question> section must contain a yes/no question asking if you should proceed\n- Do NOT execute any implementation tasks in plan mode - only create the plan\n- Use tools to explore and research, but do not modify any files`;
-    }
-    parsePlanResponse(response) {
-        // Extract tasks
-        const tasksMatch = response.match(/<tasks>([\s\S]*?)<\/tasks>/);
-        if (!tasksMatch)
-            return null;
-        const tasksText = tasksMatch[1].trim();
-        const taskLines = tasksText.split('\n').filter(line => line.trim());
-        const tasks = taskLines.map(line => {
-            // Remove numbering (e.g., "1. ", "2. ")
-            return line.replace(/^\d+\.\s*/, '').trim();
-        }).filter(task => task);
-        // Extract question
-        const questionMatch = response.match(/<question>([\s\S]*?)<\/question>/);
-        if (!questionMatch)
-            return null;
-        const question = questionMatch[1].trim();
-        return { tasks, question };
+        return `\n\n## PLAN MODE ACTIVE (MODE=plan)
+
+You are currently in PLAN MODE. In this mode, you MUST:
+
+1. **DO NOT execute any implementation tools** (no write_to_file, edit_file, execute_command, etc.)
+2. **Call the \`create_plan\` tool** to present a structured plan to the user FIRST
+
+### How to Create a Plan:
+
+Analyze the user's request, then call \`create_plan\` with:
+- A clear title describing what will be accomplished
+- A brief summary of the approach
+- An ordered list of specific, actionable tasks
+
+Example:
+\`\`\`
+create_plan(
+  title: "Create Python CSV Filter Script",
+  summary: "Build a Python script that reads a CSV file, filters rows based on criteria, and writes output",
+  tasks: [
+    { description: "Create sample input.csv with test data", complexity: "low" },
+    { description: "Write csv_filter.py with read/filter/write logic", complexity: "medium" },
+    { description: "Execute and verify the script works correctly", complexity: "low" }
+  ]
+)
+\`\`\`
+
+### After Plan Approval:
+
+Once the user approves the plan:
+1. Execute each task in order
+2. After completing each task, call \`mark_task_complete(task_number: N)\`
+3. After all tasks are done, call \`task_complete\` with a summary
+
+**CRITICAL: In plan mode, ALWAYS call create_plan FIRST before any other tools.**`;
     }
     /**
      * Toggle command mode on/off
@@ -1496,6 +1810,24 @@ Start by listing the directory structure to understand what you're working with.
         if (!command.trim()) {
             return;
         }
+        // Check if this is an interactive editor command (vim, nano, etc.)
+        // These need full terminal control
+        const currentContextForEditor = this.contextManager.getCurrentContext();
+        if (isInteractiveEditorCommand(command)) {
+            if (this.onInteractiveEditorMode) {
+                if (currentContextForEditor.type === 'local') {
+                    // Local context: delegate to App for full terminal takeover
+                    this.onInteractiveEditorMode(true, command, this.cwd);
+                }
+                else {
+                    // Remote context (SSH, WSL, Docker) - pass remote context to App
+                    // Use the remote context's working directory, not the local Windows CWD
+                    const remoteCwd = currentContextForEditor.metadata?.workingDirectory || '~';
+                    this.onInteractiveEditorMode(true, command, remoteCwd, currentContextForEditor);
+                }
+                return;
+            }
+        }
         try {
             // Check for exit command in subshell
             if (command.trim() === 'exit') {
@@ -1585,15 +1917,19 @@ Start by listing the directory structure to understand what you're working with.
                     return;
                 }
             }
+            // Get current context to determine correct CWD for notification
+            const currentContext = this.contextManager.getCurrentContext();
+            const effectiveCwd = currentContext.type !== 'local'
+                ? currentContext.metadata?.workingDirectory || '~'
+                : this.cwd;
             // Notify UI that command is executing
             if (this.onToolExecutionUpdate) {
                 this.onToolExecutionUpdate({
                     toolName: 'execute_command',
                     status: 'executing',
-                    arguments: { command, cwd: this.cwd }
+                    arguments: { command, cwd: effectiveCwd, isPty: shellUtils.isPtyAvailable() }
                 });
             }
-            const currentContext = this.contextManager.getCurrentContext();
             // Execute with streaming support for local commands
             if (currentContext.type === 'local') {
                 // Use interactive execution to support stdin
@@ -1631,38 +1967,161 @@ Start by listing the directory structure to understand what you're working with.
                     });
                 });
             }
-            else {
-                // Subshell execution (no streaming yet)
-                const result = await this.contextManager.executeCommand(command);
+            else if (currentContext.type === 'wsl') {
+                // WSL execution with PTY for proper TTY handling (sudo, etc.)
+                const remoteCwd = currentContext.metadata?.workingDirectory || '~';
+                const distribution = currentContext.metadata?.distroName || 'Ubuntu';
                 let output = '';
-                if (result.stdout && result.stdout.trim()) {
-                    output += result.stdout;
-                }
-                if (result.stderr && result.stderr.trim()) {
-                    if (output)
-                        output += '\n';
-                    output += result.stderr;
-                }
-                // Notify UI of completion
-                if (this.onToolExecutionUpdate) {
-                    if (result.exitCode !== 0) {
-                        this.onToolExecutionUpdate({
-                            toolName: 'execute_command',
-                            status: 'error',
-                            result: output,
-                            error: `Exit Code: ${result.exitCode}`,
-                            arguments: { command, cwd: this.cwd }
-                        });
-                    }
-                    else {
-                        this.onToolExecutionUpdate({
-                            toolName: 'execute_command',
-                            status: 'completed',
-                            result: output || 'Command executed successfully',
-                            arguments: { command, cwd: this.cwd }
-                        });
-                    }
+                await new Promise((resolve) => {
+                    const wslPty = runWSLCommand(distribution, command, remoteCwd, (data) => {
+                        // Stream output to UI
+                        output += data;
+                        if (this.onToolStreamingOutput) {
+                            this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
+                        }
+                    }, (exitCode) => {
+                        // Notify UI of completion
+                        if (this.onToolExecutionUpdate) {
+                            if (exitCode !== 0) {
+                                this.onToolExecutionUpdate({
+                                    toolName: 'execute_command',
+                                    status: 'error',
+                                    result: output,
+                                    error: `Exit Code: ${exitCode}`,
+                                    arguments: { command, cwd: remoteCwd }
+                                });
+                            }
+                            else {
+                                this.onToolExecutionUpdate({
+                                    toolName: 'execute_command',
+                                    status: 'completed',
+                                    result: output || 'Command executed successfully',
+                                    arguments: { command, cwd: remoteCwd }
+                                });
+                            }
+                        }
+                        this.currentInteractiveProcess = undefined;
+                        resolve();
+                    });
+                    // Set up interactive process for stdin
+                    this.currentInteractiveProcess = {
+                        process: null,
+                        write: (data) => wslPty.write(data),
+                        kill: () => wslPty.kill(),
+                        signal: (sig) => {
+                            if (sig === 'SIGINT') {
+                                wslPty.write('\x03'); // Ctrl+C
+                            }
+                        },
+                        resize: (cols, rows) => wslPty.resize(cols, rows),
+                        isPty: true
+                    };
+                });
+            }
+            else if (currentContext.type === 'docker') {
+                // Docker execution with PTY for proper TTY handling
+                const remoteCwd = currentContext.metadata?.workingDirectory || '~';
+                const containerId = currentContext.metadata?.containerId || '';
+                let output = '';
+                await new Promise((resolve) => {
+                    const dockerPty = runDockerCommand(containerId, command, remoteCwd, (data) => {
+                        // Stream output to UI
+                        output += data;
+                        if (this.onToolStreamingOutput) {
+                            this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
+                        }
+                    }, (exitCode) => {
+                        // Notify UI of completion
+                        if (this.onToolExecutionUpdate) {
+                            if (exitCode !== 0) {
+                                this.onToolExecutionUpdate({
+                                    toolName: 'execute_command',
+                                    status: 'error',
+                                    result: output,
+                                    error: `Exit Code: ${exitCode}`,
+                                    arguments: { command, cwd: remoteCwd }
+                                });
+                            }
+                            else {
+                                this.onToolExecutionUpdate({
+                                    toolName: 'execute_command',
+                                    status: 'completed',
+                                    result: output || 'Command executed successfully',
+                                    arguments: { command, cwd: remoteCwd }
+                                });
+                            }
+                        }
+                        this.currentInteractiveProcess = undefined;
+                        resolve();
+                    });
+                    // Set up interactive process for stdin
+                    this.currentInteractiveProcess = {
+                        process: null,
+                        write: (data) => dockerPty.write(data),
+                        kill: () => dockerPty.kill(),
+                        signal: (sig) => {
+                            if (sig === 'SIGINT') {
+                                dockerPty.write('\x03'); // Ctrl+C
+                            }
+                        },
+                        resize: (cols, rows) => dockerPty.resize(cols, rows),
+                        isPty: true
+                    };
+                });
+            }
+            else if (currentContext.type === 'ssh') {
+                // SSH execution with PTY for proper TTY handling
+                const remoteCwd = currentContext.metadata?.workingDirectory || '~';
+                const sshClient = currentContext.handler?.client;
+                if (!sshClient) {
+                    throw new Error('SSH client not available');
                 }
+                let output = '';
+                await new Promise((resolve) => {
+                    const sshPty = runSSHCommand(sshClient, command, remoteCwd, (data) => {
+                        // Stream output to UI
+                        output += data;
+                        if (this.onToolStreamingOutput) {
+                            this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
+                        }
+                    }, (exitCode) => {
+                        // Notify UI of completion
+                        if (this.onToolExecutionUpdate) {
+                            if (exitCode !== 0) {
+                                this.onToolExecutionUpdate({
+                                    toolName: 'execute_command',
+                                    status: 'error',
+                                    result: output,
+                                    error: `Exit Code: ${exitCode}`,
+                                    arguments: { command, cwd: remoteCwd }
+                                });
+                            }
+                            else {
+                                this.onToolExecutionUpdate({
+                                    toolName: 'execute_command',
+                                    status: 'completed',
+                                    result: output || 'Command executed successfully',
+                                    arguments: { command, cwd: remoteCwd }
+                                });
+                            }
+                        }
+                        this.currentInteractiveProcess = undefined;
+                        resolve();
+                    });
+                    // Set up interactive process for stdin
+                    this.currentInteractiveProcess = {
+                        process: null,
+                        write: (data) => sshPty.write(data),
+                        kill: () => sshPty.kill(),
+                        signal: (sig) => {
+                            if (sig === 'SIGINT') {
+                                sshPty.write('\x03'); // Ctrl+C
+                            }
+                        },
+                        resize: (cols, rows) => sshPty.resize(cols, rows),
+                        isPty: true
+                    };
+                });
             }
         }
         catch (error) {