centaurus-cli 2.9.1 → 2.9.2

package/dist/cli-adapter.js

@@ -19,6 +19,9 @@ import { taskCompleteTool } from './tools/task-complete.js';
 import { readBinaryFileTool } from './tools/read-binary-file.js';
 import { createImageTool } from './tools/create-image.js';
 import { backgroundCommandTool } from './tools/background-command.js';
+import { subAgentTool } from './tools/sub-agent.js';
+import { SubAgentManager } from './services/sub-agent-manager.js';
+import { ShellInputAgent } from './services/shell-input-agent.js';
 import { apiClient } from './services/api-client.js';
 import { conversationManager } from './services/conversation-manager.js';
 import { aiServiceClient } from './services/ai-service-client.js';
@@ -48,6 +51,7 @@ export class CentaurusCLI {
     pendingPlanRequest = null; // Stores original user request during planning phase
     commandMode = false;
     backgroundMode = false; // Background shell mode for running commands in background
+    shellIdCounter = 1;
     previousMode = 'execution';
     onResponseCallback;
     onDirectMessageCallback; // For slash commands - adds directly to history
@@ -94,7 +98,18 @@ export class CentaurusCLI {
     onShowBackgroundTaskCancelPickerCallback;
     onBackgroundTaskViewCallback;
     onTokenCountUpdate; // Report actual AI context token count to UI
+    currentTokenCount = 0; // Track current token count for context limit checking
+    contextLimitReached = false; // Track if context limit has been reached
+    onContextLimitReached; // Notify UI about context limit state
     onSessionQuotaUpdate;
+    // MCP screen callbacks
+    onShowMCPAddScreen;
+    onShowMCPRemoveScreen;
+    onShowMCPEnableScreen;
+    onShowMCPDisableScreen;
+    onShowMCPListScreen;
+    onSubAgentCountChange; // Callback for sub-agent count changes
+    onPromptAnswered; // Callback when AI answers a shell prompt
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -115,6 +130,11 @@ export class CentaurusCLI {
         });
         // Initialize MCP
         this.initializeMCP();
+        // Initialize ShellInputAgent with tool registry and wire shell input callback
+        ShellInputAgent.initialize(this.toolRegistry);
+        ShellInputAgent.setOnShellInput((shellId, input) => {
+            this.writeToShellStdin(input);
+        });
     }
     setOnResponseCallback(callback) {
         this.onResponseCallback = callback;
@@ -186,9 +206,131 @@ export class CentaurusCLI {
     setOnTokenCountUpdate(callback) {
         this.onTokenCountUpdate = callback;
     }
+    setOnContextLimitReached(callback) {
+        this.onContextLimitReached = callback;
+    }
+    setOnSubAgentCountChange(callback) {
+        this.onSubAgentCountChange = callback;
+    }
+    setOnPromptAnswered(callback) {
+        this.onPromptAnswered = callback;
+        // Wire this callback to ShellInputAgent
+        ShellInputAgent.setOnPromptAnswered(callback);
+    }
+    /**
+     * Calculate and update token count based on current conversation history
+     * This ensures UI is always in sync with the actual AI context
+     * Uses backend's accurate token counting API (Vertex AI countTokens)
+     */
+    async updateTokenCount() {
+        if (!this.onTokenCountUpdate)
+            return;
+        try {
+            // Get current model
+            const currentModel = this.configManager.get('modelName') || 'gemini-2.5-flash';
+            // Prepare messages for token counting
+            // Backend will automatically include system prompt when counting
+            // We just send the conversation history
+            const messagesForCounting = [...this.conversationHistory];
+            // Call backend API for accurate token counting
+            const tokenCount = await apiClient.countTokens(currentModel, messagesForCounting);
+            // Store locally for context limit checking
+            this.currentTokenCount = tokenCount;
+            // Update UI with accurate count
+            this.onTokenCountUpdate(tokenCount);
+            quickLog(`[${new Date().toISOString()}] [updateTokenCount] Accurate count: ${tokenCount} tokens for ${messagesForCounting.length} messages\n`);
+        }
+        catch (error) {
+            // Fallback to character-based estimation if API fails
+            const SYSTEM_PROMPT_ESTIMATE = 14000; // Backend injects ~14K char system prompt
+            // Calculate total characters from conversation history
+            let totalCharacters = 0;
+            for (const msg of this.conversationHistory) {
+                // Content
+                if (typeof msg.content === 'string') {
+                    totalCharacters += msg.content.length;
+                }
+                // Thinking content
+                if (msg.thinking) {
+                    totalCharacters += msg.thinking.length;
+                }
+                // Tool calls
+                if (msg.tool_calls) {
+                    for (const tc of msg.tool_calls) {
+                        totalCharacters += tc.name.length;
+                        if (tc.arguments) {
+                            totalCharacters += JSON.stringify(tc.arguments).length;
+                        }
+                    }
+                }
+                // Tool call ID
+                if (msg.role === 'tool' && msg.tool_call_id) {
+                    totalCharacters += msg.tool_call_id.length;
+                }
+            }
+            // Estimate tokens (1 token ≈ 4 chars)
+            // Only include system prompt estimate if there's conversation history
+            const systemPromptChars = this.conversationHistory.length > 0 ? SYSTEM_PROMPT_ESTIMATE : 0;
+            const estimatedTokens = Math.ceil((totalCharacters + systemPromptChars) / 4);
+            // Store locally for context limit checking
+            this.currentTokenCount = estimatedTokens;
+            this.onTokenCountUpdate(estimatedTokens);
+            quickLog(`[${new Date().toISOString()}] [updateTokenCount] Fallback estimate: ${estimatedTokens} tokens (API error: ${error})\n`);
+        }
+    }
+    /**
+     * Get current token count for context limit checking
+     */
+    getCurrentTokenCount() {
+        return this.currentTokenCount;
+    }
     setOnSessionQuotaUpdate(callback) {
         this.onSessionQuotaUpdate = callback;
     }
+    // MCP screen callback setters
+    setOnMCPAddScreenSetup(callback) {
+        this.onShowMCPAddScreen = callback;
+    }
+    setOnMCPRemoveScreenSetup(callback) {
+        this.onShowMCPRemoveScreen = callback;
+    }
+    setOnMCPEnableScreenSetup(callback) {
+        this.onShowMCPEnableScreen = callback;
+    }
+    setOnMCPDisableScreenSetup(callback) {
+        this.onShowMCPDisableScreen = callback;
+    }
+    setOnMCPListScreenSetup(callback) {
+        this.onShowMCPListScreen = callback;
+    }
+    // MCP server operation methods (called from UI)
+    mcpAddServer(config) {
+        if (this.mcpCommandHandler) {
+            return this.mcpCommandHandler.addServer(config);
+        }
+        return { success: false, error: 'MCP not initialized' };
+    }
+    mcpRemoveServer(name) {
+        if (this.mcpCommandHandler) {
+            this.mcpCommandHandler.removeServer(name);
+        }
+    }
+    mcpEnableServer(name) {
+        if (this.mcpCommandHandler) {
+            this.mcpCommandHandler.enableServer(name);
+        }
+    }
+    mcpDisableServer(name) {
+        if (this.mcpCommandHandler) {
+            this.mcpCommandHandler.disableServer(name);
+        }
+    }
+    mcpValidateConfig(jsonString) {
+        if (this.mcpCommandHandler) {
+            return this.mcpCommandHandler.validateServerConfig(jsonString);
+        }
+        return { valid: false, error: 'MCP not initialized' };
+    }
     /**
      * Notify UI about session quota status
      */
@@ -205,6 +347,32 @@ export class CentaurusCLI {
             const mcpConfigManager = new MCPConfigManager();
             const mcpServerManager = new MCPServerManager();
             this.mcpCommandHandler = new MCPCommandHandler(mcpConfigManager, mcpServerManager, this.toolRegistry);
+            // Wire MCP screen callbacks
+            this.mcpCommandHandler.setOnShowMCPAddScreen(() => {
+                if (this.onShowMCPAddScreen) {
+                    this.onShowMCPAddScreen();
+                }
+            });
+            this.mcpCommandHandler.setOnShowMCPRemoveScreen((servers) => {
+                if (this.onShowMCPRemoveScreen) {
+                    this.onShowMCPRemoveScreen(servers);
+                }
+            });
+            this.mcpCommandHandler.setOnShowMCPEnableScreen((servers) => {
+                if (this.onShowMCPEnableScreen) {
+                    this.onShowMCPEnableScreen(servers);
+                }
+            });
+            this.mcpCommandHandler.setOnShowMCPDisableScreen((servers) => {
+                if (this.onShowMCPDisableScreen) {
+                    this.onShowMCPDisableScreen(servers);
+                }
+            });
+            this.mcpCommandHandler.setOnShowMCPListScreen((servers) => {
+                if (this.onShowMCPListScreen) {
+                    this.onShowMCPListScreen(servers);
+                }
+            });
             // Initialize MCP servers and tools
             await this.mcpCommandHandler.initializeMCP();
         }
@@ -249,12 +417,22 @@ export class CentaurusCLI {
     getCommandMode() {
         return this.commandMode;
     }
+    /**
+     * Get current conversation history for shell input agent context
+     * Returns a copy to prevent modification
+     */
+    getConversationHistory() {
+        return [...this.conversationHistory];
+    }
     getCurrentWorkingDirectory() {
         return this.cwd;
     }
     getCurrentSubshellContext() {
         return this.contextManager.getCurrentContext();
     }
+    getCurrentInteractiveProcess() {
+        return this.currentInteractiveProcess;
+    }
     /**
      * Get the current conversation ID for file uploads
      */
@@ -371,6 +549,14 @@ export class CentaurusCLI {
         this.toolRegistry.register(readBinaryFileTool);
         this.toolRegistry.register(createImageTool);
         this.toolRegistry.register(backgroundCommandTool);
+        this.toolRegistry.register(subAgentTool);
+        // Initialize SubAgentManager with tool registry
+        SubAgentManager.initialize(this.toolRegistry);
+        SubAgentManager.setOnSubAgentCountChange((count) => {
+            if (this.onSubAgentCountChange) {
+                this.onSubAgentCountChange(count);
+            }
+        });
         // Load configuration
         const config = this.configManager.load();
         // Enable backend sync if authenticated
@@ -562,6 +748,35 @@ Press Enter to continue...
             this.notifySessionQuotaStatus();
             return;
         }
+        // Check context window limit before accepting new messages
+        // Get current model's context window
+        const currentModel = this.configManager.get('modelName') || 'gemini-2.5-flash';
+        const { getModelContextWindowSync } = await import('./config/models.js');
+        const maxTokens = getModelContextWindowSync(currentModel);
+        // Calculate current token usage percentage
+        // We need to estimate tokens for the new message too
+        const newMessageChars = message.length;
+        const estimatedNewMessageTokens = Math.ceil(newMessageChars / 4);
+        // Get current token count from state (updated by updateTokenCount)
+        const currentTokens = this.getCurrentTokenCount();
+        const projectedTokens = currentTokens + estimatedNewMessageTokens;
+        const usagePercent = (projectedTokens / maxTokens) * 100;
+        // Block new messages if context is ≥80% full
+        if (usagePercent >= 80) {
+            // Set context limit reached state
+            if (!this.contextLimitReached) {
+                this.contextLimitReached = true;
+                if (this.onContextLimitReached) {
+                    this.onContextLimitReached(true);
+                }
+            }
+            const contextLimitMessage = `\n⚠️ Context limit reached (${usagePercent.toFixed(1)}% of ${maxTokens.toLocaleString()} tokens used).\n\nYour conversation has grown too large for the AI to process effectively.\n\nPlease start a new chat to continue:\n  • Use /new to start a fresh conversation\n  • Or use /chat to switch to a different chat\n\nYour current conversation has been saved and you can return to it later.\n\nYou can still use:\n  • Slash commands (e.g., /help, /new, /chat)\n  • Terminal commands (in Command mode)`;
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(contextLimitMessage);
+            }
+            quickLog(`[${new Date().toISOString()}] [handleMessage] Context limit reached: ${usagePercent.toFixed(1)}% (${projectedTokens}/${maxTokens} tokens)\n`);
+            return;
+        }
         // Cancel any active request when a new message comes in
         // This enables "interrupt and replace" - new message takes priority
         if (this.currentAbortController) {
@@ -613,6 +828,12 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 contextManager: this.contextManager,
                 cliAdapter: this, // Pass CLI adapter reference for interactive process management
                 requireApproval: async (message, risky, preview, operationType, operationDetails) => {
+                    // Special bypass for shell input to running processes:
+                    // If the AI is sending input to an existing shell (via shell_input), we bypass the separate approval step.
+                    // The user already implicitly approved the interaction by running the command in agent control mode.
+                    if (operationType === 'execute_command' && operationDetails?.shell_input) {
+                        return true;
+                    }
                     if (this.onToolApprovalRequest) {
                         return await this.onToolApprovalRequest({ message, risky, preview, operationType, operationDetails });
                     }
@@ -646,11 +867,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             const mode = this.getMode();
             let finalAssistantMessage = '';
             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 narrationAttempts = 0; // Track how many times AI narrated without executing
-            let completionAttempts = 0; // Track how many times AI provided text summary without task_complete
             let thoughtStartTime = null; // Track when thinking started
             let thoughtContent = ''; // Accumulate thought content during streaming
             let currentTurnThinking = ''; // Persist thinking for the current turn to attach to assistant message
@@ -736,13 +953,11 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     quickLog(`[${new Date().toISOString()}] [CLI] Assistant messages with tool_calls: ${messageStats.assistantWithToolCalls}\n`);
                 }
                 catch (e) { }
-                // Report actual token count to UI (estimate: 1 token ≈ 4 chars)
-                // Include system prompt estimate (~14000 chars based on backend logs)
-                const SYSTEM_PROMPT_ESTIMATE = 14000; // Backend injects ~14K char system prompt
-                const estimatedTokens = Math.ceil((messageStats.totalCharacters + SYSTEM_PROMPT_ESTIMATE) / 4);
-                if (this.onTokenCountUpdate) {
-                    this.onTokenCountUpdate(estimatedTokens);
-                }
+                // Update token count using accurate API
+                // This will use backend's Vertex AI countTokens for precision
+                this.updateTokenCount().catch(err => {
+                    quickLog(`[${new Date().toISOString()}] [CLI] Failed to update token count: ${err}\n`);
+                });
                 // 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)) {
@@ -817,6 +1032,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     // Handle tool call chunks
                     if (chunk.type === 'tool_call') {
                         const toolCall = chunk.toolCall;
+                        // Kiro/Claude compatibility: Parse string arguments early so they are objects throughout the pipeline
+                        // This ensures logging, UI updates, and tool execution all see the parsed object
+                        if (toolCall.arguments && typeof toolCall.arguments === 'string') {
+                            try {
+                                toolCall.arguments = JSON.parse(toolCall.arguments);
+                            }
+                            catch (e) {
+                                // Ignore parsing error, will be handled by downstream logic
+                            }
+                        }
                         // Debug: Log every tool_call chunk received
                         try {
                             quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL CHUNK RECEIVED (REAL-TIME): ${toolCall?.name || 'unknown'}\n`);
@@ -856,9 +1081,11 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         // REAL-TIME EXECUTION: Execute tool immediately during streaming
                         // This reduces latency by not waiting for the entire stream to finish
                         try {
-                            // Extract and display reason_text if present (skip for task_complete)
+                            // Extract and display reason_text if present (skip for task_complete and shell_input)
                             const reasonText = toolCall.arguments.reason_text;
-                            if (reasonText && this.onResponseStreamCallback) {
+                            // Don't show reason text for shell inputs (hidden from history per user request)
+                            const isShellInput = toolCall.name === 'execute_command' && toolCall.arguments.shell_input;
+                            if (reasonText && !isShellInput && this.onResponseStreamCallback) {
                                 this.onResponseStreamCallback(reasonText + '\n\n');
                             }
                             // Show 'executing' status immediately
@@ -866,6 +1093,14 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             // Log tool execution start
                             conversationLogger.logToolExecutionStart(toolCall.name, toolCall.id);
                             // Execute the tool (it will request approval if needed via requireApproval callback)
+                            // SPECIAL: Intercept sub_agent spawn to enforce approval
+                            if (toolCall.name === 'sub_agent' && toolCall.arguments?.action === 'spawn') {
+                                const approved = await context.requireApproval(`Spawn Sub-Agent`, true, // risky
+                                undefined, 'execute_command', { command: `spawn sub-agent` });
+                                if (!approved) {
+                                    throw new Error('User rejected sub-agent spawn request');
+                                }
+                            }
                             const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                             if (result.success) {
                                 conversationLogger.logToolResult(toolCall.name, toolCall.id, result.result, true);
@@ -947,8 +1182,6 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     assistantMessageLength: assistantMessage.length,
                     hasToolCalls: toolCalls.length > 0,
                     willContinue: toolCalls.length > 0,
-                    narrationAttempts,
-                    completionAttempts,
                 });
                 // If there are tool calls, execute them
                 if (toolCalls.length > 0) {
@@ -961,11 +1194,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         // 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) {
-                        // Silently limit tool calls
-                        toolCalls = toolCalls.slice(0, MAX_TOOL_CALLS_PER_TURN);
-                    }
+                    // Tool call limit removed - let AI use as many tools as needed per turn
                     const toolResults = [...inStreamToolResults]; // Start with in-stream results
                     const handledToolCallIds = new Set(); // Only for special tools (create_plan, mark_task_complete)
                     let userCancelledOperation = false;
@@ -989,25 +1218,24 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         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);
-                                // If task_complete has a summary, use that as the final message
-                                // If no summary provided, PRESERVE the already-streamed assistantMessage text
-                                if (taskCompleteSummary) {
-                                    // AI provided a summary - suppress any other text and use the summary
-                                    assistantMessage = '';
-                                    // IMPORTANT: Clear the already-streamed text from UI before showing summary
-                                    // This prevents duplicate content (streamed text + summary)
-                                    if (this.onClearStreamedResponse) {
-                                        this.onClearStreamedResponse();
-                                    }
-                                    // Stream the summary to UI so it's visible
-                                    if (this.onResponseStreamCallback) {
-                                        this.onResponseStreamCallback(taskCompleteSummary);
-                                    }
+                                // SUBAGENT BLOCKING: Check if any sub-agents are still running
+                                const runningSubAgents = SubAgentManager.getRunningSubAgents();
+                                if (runningSubAgents.length > 0) {
+                                    // Block task_complete and provide feedback
+                                    const agentIds = runningSubAgents.map(a => a.id).join(', ');
+                                    toolResults.push({
+                                        tool_call_id: toolCall.id,
+                                        name: toolCall.name,
+                                        result: `Cannot complete task: ${runningSubAgents.length} sub-agent(s) still running. IDs: ${agentIds}. Check their status periodically with sub_agent(action="status", agent_id="...") and wait for completion before calling task_complete.`,
+                                    });
+                                    handledToolCallIds.add(toolCall.id);
+                                    continue; // Skip task_complete execution, keep loop running
                                 }
-                                // If no summary, keep assistantMessage as-is (it was already streamed to UI)
+                                taskCompleted = true;
+                                conversationLogger.logTaskComplete('');
+                                // task_complete no longer has a summary parameter
+                                // The AI streams all response text BEFORE calling task_complete()
+                                // So we just preserve whatever assistantMessage was already streamed
                                 // Execute the tool for proper result handling
                                 await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                                 // Clear the plan when task is complete
@@ -1240,7 +1468,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                             tool_call_id: toolCall.id,
                                             name: toolCall.name,
                                             result: completion.allComplete
-                                                ? 'All tasks completed! Call task_complete with a summary of what was accomplished.'
+                                                ? 'All tasks completed! Output your summary of what was accomplished, then call task_complete().'
                                                 : completion.nextSubtask
                                                     ? `Subtask ${completion.taskNumber} completed. Next subtask: ${completion.nextSubtask}`
                                                     : completion.nextTask
@@ -1250,7 +1478,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         // 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.';
+                                                'All tasks in the plan are now completed! Output your summary of what was accomplished, then call task_complete().';
                                         }
                                     }
                                     catch (parseError) {
@@ -1314,12 +1542,14 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                     remoteContext = `docker:${metadata.containerId?.substring(0, 12) || 'container'}`;
                                 }
                             }
-                            // Notify UI: tool is executing (send before execution starts)
+                            // Notify UI: tool executing
                             if (this.onToolExecutionUpdate) {
-                                // Add cwd to arguments for execute_command tool, and remoteContext for all tools
-                                const toolArgs = toolCall.name === 'execute_command'
-                                    ? { ...toolCall.arguments, cwd: effectiveCwd, remoteContext }
-                                    : { ...toolCall.arguments, remoteContext };
+                                let toolArgs = { ...toolCall.arguments, remoteContext };
+                                // Special handling for execute_command
+                                if (toolCall.name === 'execute_command') {
+                                    // Add effective CWD
+                                    toolArgs.cwd = effectiveCwd;
+                                }
                                 this.onToolExecutionUpdate({
                                     toolName: toolCall.name,
                                     status: 'executing',
@@ -1329,6 +1559,31 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             // Log tool execution start
                             conversationLogger.logToolExecutionStart(toolCall.name, toolCall.id);
                             // Execute the tool (it will request approval if needed)
+                            // SPECIAL: Intercept sub_agent spawn to enforce approval
+                            if (toolCall.name === 'sub_agent' && toolCall.arguments?.action === 'spawn') {
+                                const approved = await context.requireApproval(`Spawn Sub-Agent`, true, // risky
+                                undefined, 'execute_command', { command: `spawn sub-agent` });
+                                if (!approved) {
+                                    // User rejected - log result as error and skip execution
+                                    conversationLogger.logToolResult(toolCall.name, toolCall.id, null, false, 'User rejected');
+                                    // Notify UI: tool failed
+                                    if (this.onToolExecutionUpdate) {
+                                        this.onToolExecutionUpdate({
+                                            toolName: toolCall.name,
+                                            status: 'error',
+                                            error: 'User rejected',
+                                            arguments: toolCall.arguments
+                                        });
+                                    }
+                                    toolResults.push({
+                                        tool_call_id: toolCall.id,
+                                        name: toolCall.name,
+                                        result: 'User rejected sub-agent spawn request',
+                                        error: 'User rejected'
+                                    });
+                                    continue;
+                                }
+                            }
                             const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                             if (result.success) {
                                 // Log successful tool result
@@ -1442,6 +1697,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             }
                         }
                     }
+                    // STOP AGENT LOOP if shell_input was provided
+                    // Interactive shell input implies handing control back to the shell/user
+                    const hasShellInput = toolCalls.some(tc => tc.name === 'execute_command' && tc.arguments && tc.arguments.shell_input);
+                    if (hasShellInput) {
+                        try {
+                            quickLog(`[${new Date().toISOString()}] [CLI] Input sent to shell. Stopping agent loop to await output.\n`);
+                        }
+                        catch (e) { }
+                        taskCompleted = true;
+                    }
                     // If task_complete was called, stop the agentic loop immediately
                     if (taskCompleted) {
                         // Set the final message: use summary if provided, otherwise use the streamed assistantMessage
@@ -1556,8 +1821,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         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' +
+                            '2. Output your response text, then call task_complete()\n\n' +
+                            '**If you have completed the task**, output your summary now, then call task_complete().\n' +
                             '**If more work is needed**, execute the next tool call immediately.';
                         conversationLogger.logSystemPrompt('silent_stop_prompt', silentStopPrompt);
                         this.conversationHistory.push({
@@ -1565,113 +1830,17 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             content: silentStopPrompt,
                         });
                     }
-                    // Case 2: Text-only response (Narration or Summary)
+                    // Case 2: Text-only response - accept it immediately as final
                     else {
-                        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' +
-                                    '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,
-                                });
-                            }
-                        }
-                        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
-                            // If it has substantial length, assume it's a summary attempt
-                            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;
-                                }
-                                // This looks like a final answer - prompt to call task_complete
-                                const completionPrompt = '✅ **Possible Completion Detected**: You provided a text response but did not call `task_complete`.\n\n' +
-                                    '**To finish the conversation, you MUST call the `task_complete` tool.**\n\n' +
-                                    'Please call `task_complete` now with your summary as the argument.';
-                                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,
-                                });
-                            }
-                        }
+                        // Log that we're accepting this as a final answer
+                        conversationLogger.logNarrationDetection('final_answer', {
+                            turn: turnCount,
+                            messagePreview: assistantMessage.substring(0, 200),
+                            action: 'accepting_immediately',
+                        });
+                        // Accept the text as the final message and break
+                        finalAssistantMessage = assistantMessage;
+                        break;
                     }
                     // Rebuild messages array with updated history
                     // Backend will inject system prompt
@@ -1687,8 +1856,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                 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' +
+                    '2. Output your response text, then call task_complete()\n\n' +
+                    '**If you have completed the task**, output your summary now, then call task_complete().\n' +
                     '**If more work is needed**, execute the next tool call immediately.';
                 this.conversationHistory.push({
                     role: 'user',
@@ -2092,7 +2261,7 @@ Start by listing the directory structure to understand what you're working with.
                         '• 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' +
+                        '• Output summary text, then call task_complete() when done\n' +
                         '• Inject intelligent error recovery hints\n\n' +
                         'This is the industry-standard autonomous agent mode.'
                     : '⚠️  Autonomous Mode disabled\n\n' +
@@ -3034,6 +3203,19 @@ Start by listing the directory structure to understand what you're working with.
                 this.onCwdChange(chat.cwd);
             }
         }
+        // Reset context limit state when loading a chat
+        // We'll recalculate it based on the loaded conversation
+        if (this.contextLimitReached) {
+            this.contextLimitReached = false;
+            if (this.onContextLimitReached) {
+                this.onContextLimitReached(false);
+            }
+        }
+        // Update token count to reflect loaded conversation
+        // This will also check if the loaded chat is near the limit
+        this.updateTokenCount().catch(err => {
+            quickLog(`[${new Date().toISOString()}] [loadChatFromPicker] Failed to update token count: ${err}\n`);
+        });
         return true;
     }
     /**
@@ -3202,6 +3384,17 @@ Start by listing the directory structure to understand what you're working with.
         this.uiMessageHistory = [];
         this.localCwdBeforeRemote = null;
         this.lastConnectionCommand = null;
+        // Reset context limit state
+        if (this.contextLimitReached) {
+            this.contextLimitReached = false;
+            if (this.onContextLimitReached) {
+                this.onContextLimitReached(false);
+            }
+        }
+        // Update token count to reflect empty conversation
+        this.updateTokenCount().catch(err => {
+            quickLog(`[${new Date().toISOString()}] [startNewChat] Failed to update token count: ${err}\n`);
+        });
     }
     /**
      * Update UI message history (called from App.tsx via callback)