centaurus-cli 2.6.2 → 2.7.0

package/dist/cli-adapter.js

@@ -2,6 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import * as shellUtils from './utils/shell.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { ConfigManager } from './config/manager.js';
@@ -9,6 +10,7 @@ import { ToolRegistry } from './tools/registry.js';
 import { readFileTool, writeFileTool, editFileTool, listDirectoryTool } from './tools/file-ops.js';
 import { executeCommandTool, grepSearchTool } from './tools/command.js';
 import { webSearchTool, fetchUrlTool } from './tools/web-search.js';
+import { taskCompleteTool } from './tools/task-complete.js';
 import { apiClient } from './services/api-client.js';
 import { conversationManager } from './services/conversation-manager.js';
 import { aiServiceClient } from './services/ai-service-client.js';
@@ -43,11 +45,13 @@ export class CentaurusCLI {
     onPlanModeChange;
     onPlanApprovalRequest;
     onPasswordRequest;
+    currentInteractiveProcess;
     conversationStarted = false;
     contextManager;
     commandDetector;
     aiContextInjector;
     onSubshellContextChange;
+    currentAbortController;
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -116,6 +120,16 @@ export class CentaurusCLI {
             this.sshHandler.setPasswordRequestCallback(callback);
         }
     }
+    writeToShellStdin(input) {
+        if (this.currentInteractiveProcess) {
+            try {
+                this.currentInteractiveProcess.write(input);
+            }
+            catch (error) {
+                // Silently ignore - process might have already exited
+            }
+        }
+    }
     getPlanMode() {
         return this.planMode;
     }
@@ -169,6 +183,7 @@ export class CentaurusCLI {
         this.toolRegistry.register(grepSearchTool);
         this.toolRegistry.register(webSearchTool);
         this.toolRegistry.register(fetchUrlTool);
+        this.toolRegistry.register(taskCompleteTool);
         // Load configuration
         const config = this.configManager.load();
         // Enable backend sync if authenticated
@@ -243,8 +258,7 @@ Press Enter to continue...
             this.conversationStarted = true;
         }
         catch (error) {
-            console.error('Failed to start conversation in backend:', error);
-            // Continue without backend persistence
+            // Silently continue without backend persistence
         }
     }
     /**
@@ -264,8 +278,7 @@ Press Enter to continue...
             });
         }
         catch (error) {
-            console.error('Failed to save message to backend:', error);
-            // Continue without backend persistence
+            // Silently continue without backend persistence
         }
     }
     getModel() {
@@ -273,6 +286,15 @@ Press Enter to continue...
         // Return the stored model name, or fall back to model ID
         return config.modelName || config.model || 'gemini-2.5-flash';
     }
+    /**
+     * Cancel the current AI request
+     */
+    cancelCurrentRequest() {
+        if (this.currentAbortController) {
+            this.currentAbortController.abort();
+            this.currentAbortController = undefined;
+        }
+    }
     async handleMessage(message) {
         // Handle command mode - execute commands directly
         if (this.commandMode) {
@@ -300,6 +322,7 @@ Press Enter to continue...
             const context = {
                 cwd: this.cwd,
                 contextManager: this.contextManager,
+                cliAdapter: this, // Pass CLI adapter reference for interactive process management
                 requireApproval: async (message, risky, preview, operationType, operationDetails) => {
                     if (this.onToolApprovalRequest) {
                         return await this.onToolApprovalRequest({ message, risky, preview, operationType, operationDetails });
@@ -322,16 +345,15 @@ 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 enhanced system prompt with environment context
-            // Always use the enhanced system prompt for all models
-            const systemPromptPath = path.join(__dirname, '..', 'prompts', 'system-prompt-enhanced.md');
+            // 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
-                console.warn('Failed to load system-prompt-enhanced.md, using fallback prompt');
                 systemPrompt = 'You are Centaurus, a Senior Site Reliability Engineer (SRE) and Full-Stack Architect embedded in a CLI.';
             }
             // Enhance system prompt with environment context
@@ -351,12 +373,15 @@ Press Enter to continue...
             const environmentContext = this.getEnvironmentContext();
             const mode = this.getMode();
             let finalAssistantMessage = '';
-            const MAX_TURNS = 100; // Allow up to 100 turns for complex tasks
+            const MAX_TURNS = 500; // Allow up to 500 turns for complex tasks
             const MAX_TOOL_CALLS_PER_TURN = 5; // Limit tool calls per turn to prevent overthinking
+            const MAX_NARRATION_ATTEMPTS = 3; // Maximum times we'll prompt AI to stop narrating
             let turnCount = 0;
-            let streamBuffer = ''; // Buffer to handle TASK_COMPLETE marker split across chunks
+            let narrationAttempts = 0; // Track how many times AI narrated without executing
             let thoughtStartTime = null; // Track when thinking started
             let thoughtContent = ''; // Accumulate thought content
+            // Create AbortController for this request
+            this.currentAbortController = new AbortController();
             // Multi-turn tool execution loop
             while (turnCount < MAX_TURNS) {
                 turnCount++;
@@ -364,7 +389,7 @@ Press Enter to continue...
                 let toolCalls = [];
                 // 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)) {
+                for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode, selectedModelThinkingConfig, this.currentAbortController.signal)) {
                     // Handle error chunks
                     if (chunk.type === 'error') {
                         throw new Error(chunk.message);
@@ -398,28 +423,15 @@ Press Enter to continue...
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
-                        assistantMessage += chunk.content;
-                        // Send chunk to UI in real-time (but filter out completion marker)
-                        if (this.onResponseStreamCallback) {
-                            // Add to buffer
-                            streamBuffer += chunk.content;
-                            // Check if buffer contains complete TASK_COMPLETE marker
-                            if (streamBuffer.includes('<TASK_COMPLETE>')) {
-                                // Remove the marker and flush buffer
-                                const cleanBuffer = streamBuffer.replace(/<TASK_COMPLETE>/g, '');
-                                if (cleanBuffer) {
-                                    this.onResponseStreamCallback(cleanBuffer);
-                                }
-                                streamBuffer = '';
-                            }
-                            else if (streamBuffer.length > 20) {
-                                // If buffer is getting long without marker, flush it
-                                // Keep last 20 chars in case marker is split
-                                const toFlush = streamBuffer.slice(0, -20);
-                                if (toFlush) {
-                                    this.onResponseStreamCallback(toFlush);
-                                }
-                                streamBuffer = streamBuffer.slice(-20);
+                        // Filter out <TASK_COMPLETE> markers (AI shouldn't output these)
+                        let filteredContent = chunk.content;
+                        filteredContent = filteredContent.replace(/<\/?TASK_COMPLETE>/gi, '');
+                        filteredContent = filteredContent.trim();
+                        if (filteredContent) {
+                            assistantMessage += filteredContent;
+                            // Send chunk to UI in real-time
+                            if (this.onResponseStreamCallback) {
+                                this.onResponseStreamCallback(filteredContent);
                             }
                         }
                     }
@@ -455,28 +467,20 @@ Press Enter to continue...
                         else {
                             fs.appendFileSync('cli_frontend_logs.txt', `[${new Date().toISOString()}] [CLI] Stream done but no thinking was in progress\n`);
                         }
-                        // Flush any remaining buffer
-                        if (streamBuffer && this.onResponseStreamCallback) {
-                            const cleanBuffer = streamBuffer.replace(/<TASK_COMPLETE>/g, '');
-                            if (cleanBuffer) {
-                                this.onResponseStreamCallback(cleanBuffer);
-                            }
-                            streamBuffer = '';
-                        }
                         break;
                     }
                 }
-                // Three-tier completion detection
-                // Tier 1: Check for explicit completion marker
-                if (this.hasCompletionMarker(assistantMessage)) {
-                    finalAssistantMessage = this.removeCompletionMarker(assistantMessage);
-                    break;
-                }
                 // If there are tool calls, execute them and continue loop
                 if (toolCalls.length > 0) {
+                    // CRITICAL: AI should ONLY communicate via reason_text and task_complete summary
+                    // Any text output alongside tool calls should be suppressed
+                    if (assistantMessage && assistantMessage.trim()) {
+                        // Suppress text output - AI should only use reason_text
+                        assistantMessage = ''; // Clear ALL text output - AI should only use reason_text
+                    }
                     // Limit tool calls per turn to prevent overthinking
                     if (toolCalls.length > MAX_TOOL_CALLS_PER_TURN) {
-                        console.warn(`⚠️  Model attempted ${toolCalls.length} tool calls, limiting to ${MAX_TOOL_CALLS_PER_TURN}`);
+                        // Silently limit tool calls
                         toolCalls = toolCalls.slice(0, MAX_TOOL_CALLS_PER_TURN);
                     }
                     // Helper function to truncate large results
@@ -491,20 +495,58 @@ Press Enter to continue...
                     };
                     const toolResults = [];
                     let userCancelledOperation = false;
+                    let taskCompleted = false;
+                    let taskCompleteSummary = '';
                     for (let i = 0; i < toolCalls.length; i++) {
                         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 || '';
+                                // CRITICAL: Suppress any text that came before task_complete in this turn
+                                // The AI should ONLY communicate through the task_complete summary
+                                assistantMessage = '';
+                                // Stream the summary to UI so it's visible
+                                if (taskCompleteSummary && this.onResponseStreamCallback) {
+                                    this.onResponseStreamCallback(taskCompleteSummary);
+                                }
+                                // Execute the tool for proper result handling
+                                await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+                                // Stop processing remaining tools
+                                break;
+                            }
+                            // 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');
+                            }
+                            // 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;
+                                this.onToolExecutionUpdate({
+                                    toolName: toolCall.name,
+                                    status: 'executing',
+                                    arguments: toolArgs
+                                });
+                            }
                             // Execute the tool (it will request approval if needed)
-                            // Don't send 'executing' status here - it causes duplication with approval UI
                             const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                             if (result.success) {
                                 // 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;
                                     this.onToolExecutionUpdate({
                                         toolName: toolCall.name,
                                         status: 'completed',
                                         result: result.result,
-                                        arguments: toolCall.arguments
+                                        arguments: toolArgs
                                     });
                                 }
                                 // Parse result if it's a string (avoid double-stringification)
@@ -533,11 +575,15 @@ Press Enter to continue...
                                 }
                                 // Notify UI: tool failed
                                 if (this.onToolExecutionUpdate) {
+                                    // Add cwd to arguments for execute_command tool
+                                    const toolArgs = toolCall.name === 'execute_command'
+                                        ? { ...toolCall.arguments, cwd: this.cwd }
+                                        : toolCall.arguments;
                                     this.onToolExecutionUpdate({
                                         toolName: toolCall.name,
                                         status: 'error',
                                         error: result.error,
-                                        arguments: toolCall.arguments
+                                        arguments: toolArgs
                                     });
                                 }
                                 toolResults.push({
@@ -558,11 +604,15 @@ Press Enter to continue...
                             }
                             // Notify UI: tool failed
                             if (this.onToolExecutionUpdate) {
+                                // Add cwd to arguments for execute_command tool
+                                const toolArgs = toolCall.name === 'execute_command'
+                                    ? { ...toolCall.arguments, cwd: this.cwd }
+                                    : toolCall.arguments;
                                 this.onToolExecutionUpdate({
                                     toolName: toolCall.name,
                                     status: 'error',
                                     error: error.message,
-                                    arguments: toolCall.arguments
+                                    arguments: toolArgs
                                 });
                             }
                             toolResults.push({
@@ -576,6 +626,12 @@ Press Enter to continue...
                             }
                         }
                     }
+                    // If task_complete was called, stop the agentic loop immediately
+                    if (taskCompleted) {
+                        // Set the final message to the summary from task_complete
+                        finalAssistantMessage = taskCompleteSummary;
+                        break;
+                    }
                     // If user cancelled an operation, stop the agentic loop immediately
                     if (userCancelledOperation) {
                         // Add assistant message to history
@@ -600,6 +656,11 @@ Press Enter to continue...
                         finalAssistantMessage = 'Operation cancelled by user. The task was not completed.';
                         break;
                     }
+                    // Send assistant message to UI first (if there's text)
+                    if (assistantMessage && this.onResponseStreamCallback) {
+                        // Send the message that came with the tool calls
+                        this.onResponseStreamCallback(assistantMessage);
+                    }
                     // Add assistant message with tool calls to conversation history
                     this.conversationHistory.push({
                         role: 'assistant',
@@ -614,7 +675,7 @@ Press Enter to continue...
                             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, respond with "<TASK_COMPLETE>" followed by a summary.'
+                            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.'
                         };
                         this.conversationHistory.push({
                             role: 'tool',
@@ -622,8 +683,14 @@ Press Enter to continue...
                         });
                     }
                     // Rebuild messages array with updated history
-                    // Backend will inject system prompt automatically
-                    messages = [...this.conversationHistory];
+                    // IMPORTANT: Re-add system prompt for each turn
+                    messages = [
+                        {
+                            role: 'system',
+                            content: enhancedSystemPrompt,
+                        },
+                        ...this.conversationHistory
+                    ];
                     // Re-inject subshell context for the next turn
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
                     // Add delay between turns to prevent rate limiting
@@ -631,63 +698,139 @@ Press Enter to continue...
                     // Continue to next turn to let AI process results
                     continue;
                 }
-                // No tool calls - apply three-tier completion detection
+                // No tool calls - AI must make tool calls or finish
                 if (assistantMessage) {
-                    // Tier 2: Check for strong completion phrases
-                    if (this.hasStrongCompletionPhrase(assistantMessage)) {
-                        finalAssistantMessage = assistantMessage;
-                        break;
-                    }
-                    // Tier 3: Check if response seems incomplete (only within first 15 turns)
-                    if (this.seemsIncomplete(assistantMessage, turnCount)) {
-                        // Add assistant message to history
-                        this.conversationHistory.push({
-                            role: 'assistant',
-                            content: assistantMessage,
-                        });
-                        // Add continuation prompt to messages
-                        const continuationPrompt = 'Continue with the remaining steps. Execute all necessary tools to complete the entire task.';
-                        this.conversationHistory.push({
-                            role: 'user',
-                            content: continuationPrompt,
-                        });
-                        // Rebuild messages array with continuation prompt
-                        messages = [...this.conversationHistory];
-                        // Re-inject subshell context for continuation
-                        messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
-                        // Add delay before continuation
-                        await new Promise(resolve => setTimeout(resolve, 500));
-                        // Continue loop to process continuation
-                        continue;
+                    // CRITICAL: AI should NOT output text without tool calls
+                    // The ONLY valid text output is through task_complete summary
+                    // Suppress this text and prompt AI to use tools
+                    // Add assistant message to history (for AI context, but don't show to user)
+                    this.conversationHistory.push({
+                        role: 'assistant',
+                        content: assistantMessage,
+                    });
+                    // Check if this looks like it should have been a task_complete
+                    const looksLikeFinalAnswer = assistantMessage.length < 500 &&
+                        !assistantMessage.includes('?') &&
+                        (assistantMessage.includes('!') || assistantMessage.match(/\./g)?.length || 0 > 1);
+                    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++;
+                        // If AI keeps narrating without executing, force completion immediately
+                        if (narrationAttempts >= MAX_NARRATION_ATTEMPTS) {
+                            // Force task completion with error message
+                            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' +
+                                '1. Try rephrasing your request more specifically\n' +
+                                '2. Break the task into smaller, concrete steps\n' +
+                                '3. Provide explicit file paths if known\n' +
+                                '4. Check if the model supports tool calling properly\n\n' +
+                                '**Last message**: ' + assistantMessage;
+                            break;
+                        }
+                        // First narration attempt - give a strong warning with specific guidance
+                        if (narrationAttempts === 1) {
+                            const completionPrompt = '🛑 **CRITICAL ERROR**: You output text without using tools.\n\n' +
+                                '**COMMUNICATION RULE VIOLATION**: You can ONLY communicate through:\n' +
+                                '1. `reason_text` parameter in tool calls\n' +
+                                '2. `summary` parameter in task_complete tool\n\n' +
+                                '**Your text output was HIDDEN from the user.**\n\n' +
+                                '**MANDATORY CORRECTION**:\n' +
+                                '- If you need to DO something: Call the tool with `reason_text`\n' +
+                                '- If you are DONE: Call `task_complete(summary="your message")`\n' +
+                                '- NEVER output plain text - it will be hidden\n\n' +
+                                '**Example for greeting**:\n' +
+                                '```\n' +
+                                '<thought>User said hello, I should greet back</thought>\n' +
+                                '(Call task_complete with summary="Hello! How can I help you today?")\n' +
+                                '```\n\n' +
+                                '**Your NEXT response MUST use tools.**';
+                            this.conversationHistory.push({
+                                role: 'user',
+                                content: completionPrompt,
+                            });
+                        }
+                        else {
+                            // Second narration attempt - final warning before forced completion
+                            const completionPrompt = '🚨 **FINAL WARNING** (Attempt ' + narrationAttempts + '/' + MAX_NARRATION_ATTEMPTS + '): You are STILL narrating instead of executing.\n\n' +
+                                '**This is your LAST chance**:\n' +
+                                '1. Execute a tool call NOW, or\n' +
+                                '2. Call task_complete() to end\n\n' +
+                                'If you output narration text again, the task will be forcibly terminated.';
+                            this.conversationHistory.push({
+                                role: 'user',
+                                content: completionPrompt,
+                            });
+                        }
                     }
-                    // Tier 3 fallback: Prompt AI for explicit completion (after turn 2)
-                    if (turnCount >= 2) {
-                        // Add assistant message to history
-                        this.conversationHistory.push({
-                            role: 'assistant',
-                            content: assistantMessage,
-                        });
-                        // Prompt AI to either continue or confirm completion
-                        const completionPrompt = 'Are there any remaining steps to complete this task? If yes, continue with them now. If the task is fully complete, respond with "<TASK_COMPLETE>" followed by a brief summary.';
-                        this.conversationHistory.push({
-                            role: 'user',
-                            content: completionPrompt,
-                        });
-                        // Rebuild messages array
-                        messages = [...this.conversationHistory];
-                        // Re-inject subshell context for completion check
-                        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;
+                    else {
+                        // AI output a response without narration - it should finish
+                        // Reset narration counter since this is a valid response
+                        narrationAttempts = 0;
+                        // Check if the message looks like a final answer/summary
+                        const isFinalAnswer = assistantMessage.length > 50 &&
+                            (assistantMessage.includes('found') ||
+                                assistantMessage.includes('identified') ||
+                                assistantMessage.includes('completed') ||
+                                assistantMessage.includes('summary') ||
+                                assistantMessage.includes('result'));
+                        if (isFinalAnswer) {
+                            // This looks like a final answer - prompt to call task_complete
+                            const completionPrompt = '✅ Your response looks complete. Call task_complete() now to finalize the conversation.\n\n' +
+                                'If there are more steps needed, execute the next tool immediately.';
+                            this.conversationHistory.push({
+                                role: 'user',
+                                content: completionPrompt,
+                            });
+                        }
+                        else {
+                            // Short message without clear intent - ask for clarification or completion
+                            const completionPrompt = 'Your response is unclear. Either:\n' +
+                                '1. Execute the next tool call if more work is needed, or\n' +
+                                '2. Call task_complete() if the task is done';
+                            this.conversationHistory.push({
+                                role: 'user',
+                                content: completionPrompt,
+                            });
+                        }
                     }
-                    // Response seems complete (turn 1 or 2 without clear signals)
-                    finalAssistantMessage = assistantMessage;
+                    // Rebuild messages array
+                    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;
+                }
+                // 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
+                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.';
+                this.conversationHistory.push({
+                    role: 'user',
+                    content: silentStopPrompt,
+                });
+                // Rebuild messages array
+                messages = [...this.conversationHistory];
+                // Re-inject subshell context
+                messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
+                // Add delay before prompting
+                await new Promise(resolve => setTimeout(resolve, 500));
+                // Increment turn count and continue (give AI one more chance)
+                turnCount++;
+                if (turnCount >= MAX_TURNS) {
+                    // If we've hit max turns, force completion
+                    finalAssistantMessage = '⚠️ **Task Incomplete**: The AI stopped responding after multiple prompts.\n\n' +
+                        'The task may be partially complete. Please review the work done and provide more specific instructions if needed.';
                     break;
                 }
-                // No tool calls and no message - something went wrong
-                break;
+                continue;
             }
             // Check if max turns was reached
             if (turnCount >= MAX_TURNS) {
@@ -696,15 +839,18 @@ Press Enter to continue...
                 finalAssistantMessage = (finalAssistantMessage || 'Task processing limit reached.') + warningMessage;
             }
             // Send final message to user (without tool execution logs)
-            // Always remove the completion marker before displaying
-            const finalMessage = this.removeCompletionMarker(finalAssistantMessage || 'Task completed.');
-            // Save to conversation history
-            this.conversationHistory.push({
-                role: 'assistant',
-                content: finalMessage,
-            });
-            // Save assistant message to backend
-            await this.saveMessageToBackend('assistant', finalMessage);
+            // If finalAssistantMessage is empty (task_complete with no summary), don't show anything
+            const finalMessage = finalAssistantMessage;
+            // Only save and display if there's a message
+            if (finalMessage) {
+                // Save to conversation history
+                this.conversationHistory.push({
+                    role: 'assistant',
+                    content: finalMessage,
+                });
+                // Save assistant message to backend
+                await this.saveMessageToBackend('assistant', finalMessage);
+            }
             // Parse response for plan mode
             if (this.planMode) {
                 const planData = this.parsePlanResponse(finalMessage);
@@ -723,14 +869,25 @@ Press Enter to continue...
                     }
                 }
             }
-            // Send response back to UI
-            if (this.onResponseCallback) {
+            // Send response back to UI (only if there's a message)
+            if (this.onResponseCallback && finalMessage) {
                 this.onResponseCallback(finalMessage);
             }
         }
         catch (error) {
+            // Check if this was an abort/cancellation
+            if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                if (this.onResponseCallback) {
+                    this.onResponseCallback('⚠️ Request cancelled by user.');
+                }
+                return;
+            }
             throw new Error(`AI Error: ${error.message}`);
         }
+        finally {
+            // Clean up abort controller
+            this.currentAbortController = undefined;
+        }
     }
     async handleSlashCommand(command) {
         const parts = command.slice(1).split(' ');
@@ -746,6 +903,7 @@ Press Enter to continue...
                     `/model      - Select from available Google models\n` +
                     `/plan       - Toggle plan mode for complex implementations\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` +
@@ -864,6 +1022,26 @@ Press Enter to continue...
                         '• Advanced validation\n' +
                         '• Enhanced tool descriptions';
                 break;
+            case 'autonomous':
+                // Toggle autonomous mode (Silent Operator)
+                const currentAutonomous = this.configManager.get('autonomousMode');
+                const newAutonomous = !currentAutonomous; // Toggle (default is false)
+                this.configManager.set('autonomousMode', newAutonomous);
+                responseMessage = newAutonomous
+                    ? '✅ Autonomous Mode enabled (Silent Operator)\n\n' +
+                        'The AI will now:\n' +
+                        '• Work silently without narrating actions\n' +
+                        '• Use Touch-First safety (never guess file paths)\n' +
+                        '• Apply surgical precision to file edits\n' +
+                        '• Call task_complete when done with comprehensive summary\n' +
+                        '• Inject intelligent error recovery hints\n\n' +
+                        'This is the industry-standard autonomous agent mode.'
+                    : '⚠️  Autonomous Mode disabled\n\n' +
+                        'The AI will use the standard enhanced prompt with:\n' +
+                        '• Verbose communication after each action\n' +
+                        '• Standard tool descriptions\n' +
+                        '• Manual completion detection';
+                break;
             case 'clear':
                 this.conversationHistory = [];
                 this.conversationStarted = false;
@@ -891,11 +1069,11 @@ Press Enter to continue...
                             responseMessage = `❌ Failed to update configuration: ${error.message}`;
                         }
                     }
-                    else if (configKey === 'enhancedQuality') {
+                    else if (configKey === 'enhancedQuality' || configKey === 'autonomousMode') {
                         // Parse boolean value
                         const boolValue = configValue.toLowerCase() === 'true' || configValue === '1';
                         try {
-                            this.configManager.set('enhancedQuality', boolValue);
+                            this.configManager.set(configKey, boolValue);
                             responseMessage = `✅ Configuration updated: ${configKey} = ${boolValue}`;
                         }
                         catch (error) {
@@ -903,7 +1081,7 @@ Press Enter to continue...
                         }
                     }
                     else {
-                        responseMessage = `❌ Error: Unknown config key: ${configKey}\nValid keys: model, enhancedQuality`;
+                        responseMessage = `❌ Error: Unknown config key: ${configKey}\nValid keys: model, enhancedQuality, autonomousMode`;
                     }
                 }
                 else {
@@ -916,6 +1094,7 @@ Press Enter to continue...
                         `Version: ${currentVersion}\n` +
                         `Model: ${config.model || 'gemini-2.5-flash (default)'}\n` +
                         `Enhanced Quality: ${config.enhancedQuality !== false ? '✅ Enabled' : '❌ Disabled'}\n` +
+                        `Autonomous Mode: ${config.autonomousMode === true ? '✅ Enabled' : '❌ Disabled'}\n` +
                         `Authentication: ${apiClient.isAuthenticated() ? '✅ Signed in' : '❌ Not signed in'}`;
                 }
                 break;
@@ -994,107 +1173,6 @@ Press Enter to continue...
             return 'plan';
         return 'default';
     }
-    /**
-     * Check if response contains completion marker
-     * Returns true if the <TASK_COMPLETE> marker is found in the text
-     */
-    hasCompletionMarker(text) {
-        return text.includes('<TASK_COMPLETE>');
-    }
-    /**
-     * Remove completion marker from text
-     * Strips the <TASK_COMPLETE> marker from display text
-     */
-    removeCompletionMarker(text) {
-        return text.replace(/<TASK_COMPLETE>/g, '').trim();
-    }
-    /**
-     * Check if response contains strong completion phrases
-     * Returns true if the text contains phrases that strongly indicate task completion
-     * Used as fallback when completion marker is not present
-     */
-    hasStrongCompletionPhrase(text) {
-        const strongCompletionPhrases = [
-            'task complete',
-            'task is complete',
-            'tasks complete',
-            'tasks are complete',
-            'all done',
-            'everything is done',
-            'everything is ready',
-            'everything is set up',
-            'everything is complete',
-            'all set',
-            'all finished',
-            'finished everything',
-            'completed everything',
-            'completed all',
-            'done with everything',
-            'implementation complete',
-            'implementation is complete',
-            'setup complete',
-            'setup is complete',
-            'all tasks completed',
-            'all steps completed',
-            'work is complete',
-            'work complete',
-            'fully implemented',
-            'fully complete',
-            'ready to use',
-            'ready to go',
-            'successfully completed',
-            'completed successfully'
-        ];
-        const lowerText = text.toLowerCase();
-        return strongCompletionPhrases.some(phrase => lowerText.includes(phrase));
-    }
-    /**
-     * Check if response seems incomplete
-     * Returns true if the text contains phrases that suggest the AI stopped prematurely
-     * Only triggers within first 15 turns to prevent infinite loops
-     */
-    seemsIncomplete(text, turnCount) {
-        // Only check for incomplete responses within first 15 turns
-        if (turnCount > 15) {
-            return false;
-        }
-        const incompletePhrases = [
-            'i created',
-            'i\'ve created',
-            'created the',
-            'i made',
-            'i\'ve made',
-            'i wrote',
-            'i\'ve written',
-            'next i',
-            'now i',
-            'i will',
-            'i\'ll',
-            'let me',
-            'i should',
-            'first',
-            'step 1',
-            'step 2',
-            'step 3',
-            'i\'ll create',
-            'i\'ll make',
-            'i\'ll write',
-            'i\'ll add',
-            'i\'ll implement',
-            'i need to',
-            'i\'ll need to',
-            'next step',
-            'following step',
-            'then i',
-            'after that',
-            'i\'m creating',
-            'i\'m making',
-            'i\'m writing',
-            'i\'m adding'
-        ];
-        const lowerText = text.toLowerCase();
-        return incompletePhrases.some(phrase => lowerText.includes(phrase));
-    }
     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`;
     }
@@ -1146,6 +1224,13 @@ Press Enter to continue...
             }
         }
     }
+    /**
+     * Set the current interactive process
+     * This is called by the execute_command tool when starting an interactive command
+     */
+    setCurrentInteractiveProcess(process) {
+        this.currentInteractiveProcess = process;
+    }
     /**
      * Handle command execution in command mode
      */
@@ -1242,26 +1327,84 @@ Press Enter to continue...
                     return;
                 }
             }
-            // Execute the command through Context Manager
-            const result = await this.contextManager.executeCommand(command);
-            // Format and send the result
-            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 that command is executing
+            if (this.onToolExecutionUpdate) {
+                this.onToolExecutionUpdate({
+                    toolName: 'execute_command',
+                    status: 'executing',
+                    arguments: { command, cwd: this.cwd }
+                });
             }
-            if (result.exitCode !== 0) {
-                output += `\n\n❌ Exit Code: ${result.exitCode}`;
-            }
-            else if (!output.trim()) {
-                output = '✅ Command executed successfully (no output)';
+            const currentContext = this.contextManager.getCurrentContext();
+            // Execute with streaming support for local commands
+            if (currentContext.type === 'local') {
+                // Use interactive execution to support stdin
+                let output = '';
+                await new Promise((resolve) => {
+                    this.currentInteractiveProcess = shellUtils.executeCommandInteractive(command, this.cwd, (data) => {
+                        // PTY-style: single merged stream
+                        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: this.cwd }
+                                });
+                            }
+                            else {
+                                this.onToolExecutionUpdate({
+                                    toolName: 'execute_command',
+                                    status: 'completed',
+                                    result: output || 'Command executed successfully',
+                                    arguments: { command, cwd: this.cwd }
+                                });
+                            }
+                        }
+                        this.currentInteractiveProcess = undefined;
+                        resolve();
+                    });
+                });
             }
-            if (this.onResponseCallback) {
-                this.onResponseCallback(output);
+            else {
+                // Subshell execution (no streaming yet)
+                const result = await this.contextManager.executeCommand(command);
+                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 }
+                        });
+                    }
+                }
             }
         }
         catch (error) {