centaurus-cli 2.9.0 → 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';
@@ -38,6 +41,7 @@ import { conversationLogger, quickLog } from './utils/conversation-logger.js';
 import { localChatStorage } from './services/local-chat-storage.js';
 import { logWarning } from './utils/logger.js';
 import { BackgroundTaskManager } from './services/background-task-manager.js';
+import { sessionQuotaManager } from './services/session-quota-manager.js';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
@@ -47,10 +51,12 @@ 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
     onResponseStreamCallback;
+    onClearStreamedResponse; // Clear streamed text when task_complete has summary
     onThoughtStreamCallback;
     onThoughtCompleteCallback;
     onCommandModeChange;
@@ -92,6 +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();
@@ -112,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;
@@ -122,6 +145,9 @@ export class CentaurusCLI {
     setOnResponseStreamCallback(callback) {
         this.onResponseStreamCallback = callback;
     }
+    setOnClearStreamedResponse(callback) {
+        this.onClearStreamedResponse = callback;
+    }
     setOnThoughtStreamCallback(callback) {
         this.onThoughtStreamCallback = callback;
     }
@@ -180,11 +206,173 @@ 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
+     */
+    notifySessionQuotaStatus() {
+        if (this.onSessionQuotaUpdate) {
+            const remaining = sessionQuotaManager.getRemainingMessages();
+            const canSend = sessionQuotaManager.canSendMessage();
+            const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+            this.onSessionQuotaUpdate(remaining, canSend, timeRemaining);
+        }
+    }
     async initializeMCP() {
         try {
             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();
         }
@@ -229,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
      */
@@ -351,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
@@ -367,6 +573,11 @@ export class CentaurusCLI {
         const dockerHandler = new DockerHandler();
         this.contextManager.registerHandler('docker', dockerHandler);
         this.commandDetector.registerHandler(dockerHandler);
+        // Fetch rate limits configuration from backend (async, non-blocking)
+        // Uses cached values if backend is unreachable
+        sessionQuotaManager.fetchConfigFromBackend().catch(() => {
+            // Silently fall back to cached/default config
+        });
         // Note: No need to initialize AI provider - using backend proxy via aiServiceClient
     }
     /**
@@ -526,6 +737,46 @@ Press Enter to continue...
         if (!apiClient.isAuthenticated()) {
             throw new Error('Authentication required. Please sign in to use AI features.');
         }
+        // Check session quota before making any AI request
+        if (!sessionQuotaManager.canSendMessage()) {
+            const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+            const message = `\n⚠️ Session quota reached. You have used all ${sessionQuotaManager.getCurrentConfig().maxMessagesPerSession} messages for this session.\n\nYour quota will reset in ${timeRemaining}.\n\nYou can still use:\n  • Slash commands (e.g., /help, /session-limits, /exit)\n  • Terminal commands (in Command mode)\n\nUse /session-limits to check your quota status.`;
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(message);
+            }
+            // Notify UI about quota status
+            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) {
@@ -577,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 });
                     }
@@ -610,14 +867,11 @@ 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
+            let currentTurnThinkingSignature = ''; // Persist thinking signature for Claude extended thinking
             // ANTI-LOOP: Track duplicate tool calls to detect infinite loops
             const MAX_DUPLICATE_CALLS = 2; // Max times same operation allowed on same target
             const fileWriteTracker = new Map(); // Track writes per file
@@ -634,11 +888,31 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             // Multi-turn tool execution loop
             while (turnCount < MAX_TURNS) {
                 turnCount++;
+                // Track session quota - each AI call in the agent loop counts as 1 message
+                sessionQuotaManager.incrementMessageCount();
+                this.notifySessionQuotaStatus();
+                // Check if session quota is now exhausted after incrementing
+                if (!sessionQuotaManager.canSendMessage() && turnCount > 1) {
+                    // Quota exhausted mid-loop, stop and inform user
+                    const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+                    const quotaMessage = `\n\n⚠️ **Session quota reached** during agent execution.\n\nYou have used all ${sessionQuotaManager.getCurrentConfig().maxMessagesPerSession} messages for this session.\nQuota will reset in ${timeRemaining}.\n\nYour current task may be incomplete. You can resume when your quota resets.\n\nUse /session-limits to check your quota status.`;
+                    if (this.onResponseCallback) {
+                        this.onResponseCallback(quotaMessage);
+                    }
+                    logWarning('Agent loop stopped due to session quota exhaustion');
+                    return;
+                }
                 // Refresh environment context to capture any CWD changes from previous turns
                 // This is sent to backend which will inject it into the system prompt
                 environmentContext = this.getEnvironmentContext();
                 let assistantMessage = '';
                 let toolCalls = [];
+                // REAL-TIME TOOL EXECUTION: Track execution state and results during streaming
+                const inStreamToolResults = []; // Results from tools executed during streaming
+                const inStreamHandledIds = new Set(); // IDs of tools already executed in-stream
+                let toolsExecutedInStream = false; // Flag to indicate tools were executed during stream
+                let pendingTextBuffer = ''; // Buffer for text while tool is executing
+                let isToolExecuting = false; // Flag to pause text streaming during tool execution
                 // DEBUG: Log message history state before AI call
                 const messageStats = {
                     totalMessages: messages.length,
@@ -679,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)) {
@@ -717,6 +989,12 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         }
                         continue;
                     }
+                    // Handle thinking_signature chunks (Claude extended thinking)
+                    if (chunk.type === 'thinking_signature') {
+                        // Store the signature for this turn - it must be passed back with thinking content
+                        currentTurnThinkingSignature = chunk.signature;
+                        continue;
+                    }
                     // Handle text chunks
                     if (chunk.type === 'text') {
                         // If we were thinking and now got text, finalize the thought
@@ -738,18 +1016,35 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         if (filteredContent) {
                             assistantMessage += filteredContent;
                             conversationLogger.logAITextChunk(filteredContent);
-                            // Send chunk to UI in real-time
-                            if (this.onResponseStreamCallback) {
-                                this.onResponseStreamCallback(filteredContent);
+                            // REAL-TIME TOOL EXECUTION: If a tool is executing, accumulate text
+                            // This text will be flushed after the tool completes
+                            if (isToolExecuting) {
+                                pendingTextBuffer += filteredContent;
+                            }
+                            else {
+                                // Normal streaming - send chunk to UI in real-time
+                                if (this.onResponseStreamCallback) {
+                                    this.onResponseStreamCallback(filteredContent);
+                                }
                             }
                         }
                     }
                     // 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: ${toolCall?.name || 'unknown'}, toolCalls.length before push: ${toolCalls.length}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL CHUNK RECEIVED (REAL-TIME): ${toolCall?.name || 'unknown'}\n`);
                         }
                         catch (e) { }
                         conversationLogger.logToolCall(toolCall?.name || 'unknown', toolCall?.id || 'unknown', toolCall?.arguments || {});
@@ -766,18 +1061,98 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             thoughtContent = '';
                         }
                         toolCalls.push(chunk.toolCall);
-                        // IMMEDIATELY notify UI that a tool call was received (pending status)
-                        // This shows tool calls in the UI as they stream in, not after the stream ends
-                        if (this.onToolExecutionUpdate && toolCall) {
-                            this.onToolExecutionUpdate({
-                                toolName: toolCall.name,
-                                status: 'pending', // 'pending' means received but not yet executing
-                                arguments: toolCall.arguments
+                        // SPECIAL TOOLS: Skip in-stream execution for tools that need post-stream handling
+                        // These tools have special logic (setting flags, clearing state, etc.) that must run post-stream
+                        const SPECIAL_TOOLS = ['task_complete', 'create_plan', 'mark_task_complete'];
+                        if (SPECIAL_TOOLS.includes(toolCall.name)) {
+                            // Just notify UI with pending status, execute in post-stream loop
+                            if (this.onToolExecutionUpdate) {
+                                this.onToolExecutionUpdate({
+                                    toolName: toolCall.name,
+                                    status: 'pending',
+                                    arguments: toolCall.arguments
+                                });
+                            }
+                            continue; // Skip to next chunk, handle this tool in post-stream loop
+                        }
+                        // Mark that we're executing a tool (text will accumulate)
+                        isToolExecuting = true;
+                        toolsExecutedInStream = true;
+                        // 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 and shell_input)
+                            const reasonText = toolCall.arguments.reason_text;
+                            // 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
+                            this.notifyToolStatus(toolCall.name, 'executing', toolCall.arguments);
+                            // 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);
+                                // Notify UI: tool succeeded
+                                this.notifyToolStatus(toolCall.name, 'completed', toolCall.arguments, result.result);
+                                // Parse and truncate result for AI
+                                let parsedResult = result.result;
+                                if (typeof result.result === 'string') {
+                                    try {
+                                        parsedResult = JSON.parse(result.result);
+                                    }
+                                    catch {
+                                        parsedResult = result.result;
+                                    }
+                                }
+                                inStreamToolResults.push({
+                                    tool_call_id: toolCall.id,
+                                    name: toolCall.name,
+                                    result: this.truncateResult(parsedResult),
+                                });
+                            }
+                            else {
+                                conversationLogger.logToolResult(toolCall.name, toolCall.id, null, false, result.error);
+                                // Notify UI: tool failed
+                                this.notifyToolStatus(toolCall.name, 'error', toolCall.arguments, undefined, result.error);
+                                inStreamToolResults.push({
+                                    tool_call_id: toolCall.id,
+                                    name: toolCall.name,
+                                    result: `Error: ${result.error}`,
+                                });
+                            }
+                            inStreamHandledIds.add(toolCall.id);
+                        }
+                        catch (error) {
+                            conversationLogger.logError(`Tool execution: ${toolCall.name}`, error);
+                            this.notifyToolStatus(toolCall.name, 'error', toolCall.arguments, undefined, error.message);
+                            inStreamToolResults.push({
+                                tool_call_id: toolCall.id,
+                                name: toolCall.name,
+                                result: `Error: ${error.message}`,
                             });
+                            inStreamHandledIds.add(toolCall.id);
+                        }
+                        // Tool execution complete - flush pending text
+                        isToolExecuting = false;
+                        if (pendingTextBuffer && this.onResponseStreamCallback) {
+                            this.onResponseStreamCallback(pendingTextBuffer);
+                            pendingTextBuffer = '';
                         }
-                        // Debug: Log after push
+                        // Debug: Log after execution
                         try {
-                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL PUSHED: ${toolCall?.name || 'unknown'}, toolCalls.length after push: ${toolCalls.length}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL EXECUTED IN-STREAM: ${toolCall?.name || 'unknown'}\n`);
                         }
                         catch (e) { }
                     }
@@ -807,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) {
@@ -821,40 +1194,48 @@ 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);
-                    }
-                    const toolResults = [];
-                    const handledToolCallIds = new Set(); // Track tool calls that were handled directly (e.g., create_plan, mark_task_complete)
+                    // 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;
                     let taskCompleted = false;
                     let taskCompleteSummary = '';
                     for (let i = 0; i < toolCalls.length; i++) {
+                        const toolCall = toolCalls[i];
+                        // REAL-TIME EXECUTION: Skip tools that were already executed in-stream
+                        if (inStreamHandledIds.has(toolCall.id)) {
+                            try {
+                                quickLog(`[${new Date().toISOString()}] [CLI] *** SKIPPING TOOL (already executed in-stream): ${toolCall.name}\n`);
+                            }
+                            catch (e) { }
+                            continue;
+                        }
                         // Debug: Log which tool we're about to execute
                         try {
                             quickLog(`[${new Date().toISOString()}] [CLI] *** ABOUT TO EXECUTE TOOL [${i + 1}/${toolCalls.length}]: ${toolCalls[i].name}\n`);
                         }
                         catch (e) { }
-                        const toolCall = toolCalls[i];
                         try {
                             // Check if this is task_complete FIRST (before displaying anything)
                             if (toolCall.name === 'task_complete') {
-                                taskCompleted = true;
-                                taskCompleteSummary = toolCall.arguments.summary || '';
-                                conversationLogger.logTaskComplete(taskCompleteSummary);
-                                // If task_complete has a summary, use that as the final message
-                                // If no summary provided, PRESERVE the already-streamed assistantMessage text
-                                if (taskCompleteSummary) {
-                                    // AI provided a summary - suppress any other text and use the summary
-                                    assistantMessage = '';
-                                    // Stream the summary to UI so it's visible
-                                    if (this.onResponseStreamCallback) {
-                                        this.onResponseStreamCallback(taskCompleteSummary);
-                                    }
+                                // 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
@@ -898,6 +1279,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                 if (currentTurnThinking) {
                                                     planAssistantMsg.thinking = currentTurnThinking;
                                                 }
+                                                if (currentTurnThinkingSignature) {
+                                                    planAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                                }
                                                 this.conversationHistory.push(planAssistantMsg);
                                                 // Add plan approval response
                                                 this.conversationHistory.push({
@@ -942,6 +1326,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                             if (currentTurnThinking) {
                                                 planAssistantMsg.thinking = currentTurnThinking;
                                             }
+                                            if (currentTurnThinkingSignature) {
+                                                planAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                            }
                                             this.conversationHistory.push(planAssistantMsg);
                                             this.conversationHistory.push({
                                                 role: 'tool',
@@ -970,6 +1357,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         if (currentTurnThinking) {
                                             errorAssistantMsg.thinking = currentTurnThinking;
                                         }
+                                        if (currentTurnThinkingSignature) {
+                                            errorAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                        }
                                         this.conversationHistory.push(errorAssistantMsg);
                                         this.conversationHistory.push({
                                             role: 'tool',
@@ -991,6 +1381,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                     if (currentTurnThinking) {
                                         resultAssistantMsg.thinking = currentTurnThinking;
                                     }
+                                    if (currentTurnThinkingSignature) {
+                                        resultAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                    }
                                     this.conversationHistory.push(resultAssistantMsg);
                                     this.conversationHistory.push({
                                         role: 'tool',
@@ -1049,6 +1442,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                 if (currentTurnThinking) {
                                                     nextPhaseAssistantMsg.thinking = currentTurnThinking;
                                                 }
+                                                if (currentTurnThinkingSignature) {
+                                                    nextPhaseAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                                }
                                                 this.conversationHistory.push(nextPhaseAssistantMsg);
                                                 this.conversationHistory.push({
                                                     role: 'tool',
@@ -1072,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
@@ -1082,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) {
@@ -1146,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',
@@ -1161,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
@@ -1274,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
@@ -1291,6 +1724,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         if (currentTurnThinking) {
                             cancelledAssistantMsg.thinking = currentTurnThinking;
                         }
+                        if (currentTurnThinkingSignature) {
+                            cancelledAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                        }
                         this.conversationHistory.push(cancelledAssistantMsg);
                         // Add tool results to history
                         for (const toolResult of toolResults) {
@@ -1338,6 +1774,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         if (currentTurnThinking) {
                             assistantHistoryMsg.thinking = currentTurnThinking;
                         }
+                        // Include thinking signature from this turn (required for Claude extended thinking)
+                        if (currentTurnThinkingSignature) {
+                            assistantHistoryMsg.thinkingSignature = currentTurnThinkingSignature;
+                        }
+                        // Log signature info for debugging multi-turn flows
+                        const geminiSigCount = unhandledToolCalls.filter(tc => !!tc.thoughtSignature).length;
+                        try {
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** STORING ASSISTANT MSG: ${unhandledToolCalls.length} tool_calls, Gemini signatures: ${geminiSigCount}, Claude thinking: ${!!currentTurnThinking}, Claude sig: ${!!currentTurnThinkingSignature}\n`);
+                        }
+                        catch (e) { }
                         this.conversationHistory.push(assistantHistoryMsg);
                     }
                     // Add tool results to conversation history as tool messages
@@ -1375,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({
@@ -1384,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
@@ -1506,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',
@@ -1594,6 +1944,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     `/mcp        - Manage configured MCP servers and tools\n` +
                     `/docs       - Open Centaurus documentation in browser\n` +
                     `/copy-chat-context - Copy chat as readable text to clipboard\n` +
+                    `/session-limits - View session quota usage and limits\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` +
@@ -1607,6 +1958,32 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     `Ctrl+Z      - Undo last input change\n` +
                     `Ctrl+A      - Select all text`;
                 break;
+            case 'session-limits': {
+                const config = sessionQuotaManager.getCurrentConfig();
+                const messagesUsed = sessionQuotaManager.getMessagesUsed();
+                const remaining = sessionQuotaManager.getRemainingMessages();
+                const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+                const maxMessages = config.maxMessagesPerSession;
+                // Calculate percentage used (cap at 100% for display)
+                const percentUsed = maxMessages > 0 ? Math.min(100, Math.round((messagesUsed / maxMessages) * 100)) : 0;
+                // Create a visual progress bar (clamp to valid range)
+                const barLength = 20;
+                const filledLength = Math.min(barLength, Math.max(0, Math.round((messagesUsed / maxMessages) * barLength)));
+                const emptyLength = barLength - filledLength;
+                const progressBar = '█'.repeat(filledLength) + '░'.repeat(emptyLength);
+                // Status message based on quota
+                const quotaStatus = remaining <= 0
+                    ? '\n\n⚠️ Session quota exhausted! AI requests are blocked until reset.'
+                    : '';
+                responseMessage = `📊 Session Limits\n\n` +
+                    `Plan:            free\n` +
+                    `Session Window:  ${config.sessionDurationMs / (60 * 60 * 1000)} hours\n\n` +
+                    `Messages Used:   ${messagesUsed} / ${maxMessages} (${percentUsed}%)\n` +
+                    `Messages Left:   ${Math.max(0, remaining)}\n` +
+                    `Progress:        [${progressBar}]\n` +
+                    `Time Remaining:  ${timeRemaining || 'Session not started'}${quotaStatus}`;
+                break;
+            }
             case 'init':
                 try {
                     // Define the context file names in priority order
@@ -1884,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' +
@@ -2826,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;
     }
     /**
@@ -2994,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)