erosolar-cli 2.1.167 → 2.1.169

package/dist/core/agent.js

@@ -4,350 +4,7 @@ import { safeErrorMessage } from './secretStore.js';
  * Maximum number of context overflow recovery attempts
  */
 const MAX_CONTEXT_RECOVERY_ATTEMPTS = 3;
-/**
- * Maximum number of auto-continuation attempts when model expresses intent but doesn't act
- * Increased to allow more recovery attempts for complex tasks
- */
-const MAX_AUTO_CONTINUE_ATTEMPTS = 8;
-/**
- * Threshold for short completion - responses shorter than this can be valid completions.
- * Anything longer after tool work needs scrutiny.
- */
-const SHORT_COMPLETION_THRESHOLD = 80;
-const AUTO_CONTINUE_ESCALATION_ATTEMPT = 4;
 // Streaming runs without timeouts - we let the model take as long as it needs
-/**
- * Patterns that indicate the model intends to take action but hasn't yet
- * These suggest the model should be prompted to continue
- */
-const INTENT_WITHOUT_ACTION_PATTERNS = [
-    // TEXT-FORMATTED TOOL CALLS: Model outputs tool call as text instead of using API
-    // These are CRITICAL to catch - model is trying to call tools but failing to do so properly
-    // Pattern: "_tool_call_" or similar markers followed by function-like syntax
-    /_tool_call_\s*\n?\s*\w+\(/im,
-    // Pattern: "tool_call:" or "Tool call:" followed by function name
-    /tool[_\s]?call:?\s*\n?\s*\w+\(/im,
-    // Pattern: function call syntax at start of line like "read_file(..." without being in code block
-    /^\s*(read_file|write_file|edit_file|execute_bash|list_files|search|grep|glob)\s*\(/im,
-    // Pattern: "Executing X..." or "Calling X..." without actual tool call
-    /\b(executing|calling)\s+(read_file|write_file|edit_file|execute_bash|list_files|search|grep|glob)\b/i,
-    // Pattern: indented tool call syntax like "  read_file(package.json)"
-    /^\s{2,}(read_file|write_file|edit_file|execute_bash|list_files|Bash|Read|Write|Edit|Grep|Glob)\s*\([^)]*\)\s*$/im,
-    // "Let me X" patterns - model is stating what it will do
-    /\blet me\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|examine|review|run)/i,
-    // "I'll X" / "I will X" patterns - include all apostrophe variants (straight ', left ', right ')
-    /\bi['''\u2018\u2019]ll\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now|use|inspect|examine|run)/i,
-    /\bi will\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now|use|inspect|examine|run)/i,
-    // "Will X" without "I" (common pattern)
-    /\bwill\s+(run|use|read|search|check|inspect|examine|list|find|analyze|create|write|look)\s/i,
-    // "I'm going to X" patterns - include all apostrophe variants
-    /\bi['''\u2018\u2019]m going to\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|run)/i,
-    // "Now I'll X" / "First, I'll X" patterns
-    /\b(now|first|next)\s*(,)?\s*i['''\u2018\u2019]ll\s+/i,
-    // Explicit continuation signals
-    /\bhere['''\u2018\u2019]s (the|my) (plan|approach|solution|implementation)/i,
-    // "Approach:" header indicates planning without action
-    /\bapproach:/i,
-    // Numbered steps suggesting action to come
-    /^\s*\d+\.\s+(create|write|implement|add|update|edit|modify|fix|show|read|check)/im,
-    // Bullet points suggesting planned actions
-    /^[\s•\-\*]+\s*(create|write|implement|add|update|edit|modify|fix|shows?|reads?|checks?)\s/im,
-    // Statements about needing to do something
-    /\bneed\s+(to\s+)?(identify|search|find|check|read|look|inspect|analyze|examine|review|list|remove)/i,
-    // "Should be X" - model is describing action but not taking it
-    /\bshould be\s+(deleted|removed|fixed|updated|changed|cleaned|cleared)/i,
-    // "Can be X" - same pattern
-    /\bcan be\s+(deleted|removed|fixed|updated|changed|cleaned|cleared)/i,
-    // Questions that should trigger investigation instead of asking user
-    /\bwhat (files?|areas?|code|patterns?)\s+(should|would you like|do you want)/i,
-    // GIVING UP PATTERNS - model is asking for clarification instead of investigating
-    /\bplease\s+(point me to|show me|tell me|specify|clarify|provide)/i,
-    /\bwithout\s+(more|additional|further)\s+(details?|info|information|context|guidance)/i,
-    /\bcan you\s+(clarify|specify|tell me|point me|show me)/i,
-    /\blet me know\s+(what|which|where|how)/i,
-    /\b(no|can['\u2018\u2019]t|cannot)\s+(obvious|clear|specific|find|identify|determine)/i,
-    // "I don't have enough" type responses
-    /\bdon['\u2018\u2019]t have\s+(enough|sufficient|the)\s+(info|information|context|details)/i,
-    // "Could you" requests for clarification
-    /\bcould you\s+(provide|specify|clarify|point|tell|show)/i,
-];
-/**
- * Patterns that indicate the model gave a premature summary without concrete findings.
- * These summaries wrap up too quickly without file:line citations or code snippets.
- */
-const PREMATURE_CONCLUSION_PATTERNS = [
-    // "Performed/Did a quick X" - surface-level investigation claim
-    /\b(performed|did)\s+a\s+(quick|brief|fast)\s+(search|grep|scan|review|check)/i,
-    // "Validated by running" - claiming verification without showing details
-    /\bvalidated\s+by\s+running/i,
-    // Mentioning matches but not examining them: "found X matches" without file paths
-    /\bfound\s+\d+\s+(match|result|item|file|issue)/i,
-    // Summary without substance: "cleaned up", "removed", "fixed" but no specifics
-    // Allow any words between the article and the target noun (e.g., "removed the .tsbuildinfo build cache")
-    /\b(cleaned up|removed|fixed)\s+(the|a|some)?\s*\S*\s*(file|cache|build|artifact)/i,
-];
-/**
- * Check if response looks like a premature conclusion without concrete findings.
- * Looks for summary language without actual file:line citations.
- */
-function isPrematureConclusion(content) {
-    // Must match a premature conclusion pattern
-    const matchesPremature = PREMATURE_CONCLUSION_PATTERNS.some(p => p.test(content));
-    if (!matchesPremature) {
-        return false;
-    }
-    // Check if there are actual file:line citations (e.g., "src/foo.ts:42")
-    const hasFileCitation = /\b\w+\.(ts|js|tsx|jsx|py|go|rs|java|c|cpp|h|md|json|yaml|yml):\d+\b/.test(content);
-    if (hasFileCitation) {
-        return false; // Has concrete findings, not premature
-    }
-    // Check for code blocks with actual code
-    const hasCodeBlock = /```[\s\S]{20,}```/.test(content);
-    if (hasCodeBlock) {
-        return false; // Has code snippets, not premature
-    }
-    // Short response with no concrete findings = premature conclusion
-    return content.length < 500;
-}
-// Short, forceful prompts - model should just act
-const AUTO_CONTINUE_PROMPTS = [
-    'Continue.',
-    'Keep going. Call tools.',
-    'You stopped mid-task. Continue with tools.',
-    'Do not summarize. Act with tools or ask a specific question.',
-    'Use tools to complete the task.',
-];
-// Specific prompt for when model outputs text-formatted tool calls instead of using the API
-const TEXT_TOOL_CALL_PROMPT = 'You wrote a tool call as text. Use the actual tool API - call the function directly, do not write it as text.';
-// Forceful prompt used when the model keeps narrating or stalling after several attempts
-const AUTO_CONTINUE_FORCE_PROMPT = 'You are stuck narrating. Immediately call the necessary tools to finish the task. If truly done, respond with a concise final answer citing any file paths/lines touched. Do not ask for confirmation.';
-const SHORT_RESPONSE_PROMPT = 'Based on the tool results above, provide your complete response. Summarize findings and suggest next steps if applicable.';
-/**
- * Select an auto-continue prompt and user-facing message based on attempt count and reason.
- * Escalates to a forceful instruction after repeated stalls.
- */
-function buildAutoContinueInstruction(attempt, reason) {
-    const promptIndex = Math.max(0, Math.min(attempt - 1, AUTO_CONTINUE_PROMPTS.length - 1));
-    let prompt;
-    switch (reason) {
-        case 'text_tool_call':
-            prompt = TEXT_TOOL_CALL_PROMPT;
-            break;
-        case 'short_response':
-            prompt = SHORT_RESPONSE_PROMPT;
-            break;
-        default:
-            prompt = AUTO_CONTINUE_PROMPTS[promptIndex];
-            break;
-    }
-    const isEscalated = attempt >= AUTO_CONTINUE_ESCALATION_ATTEMPT;
-    if (isEscalated) {
-        prompt = AUTO_CONTINUE_FORCE_PROMPT;
-    }
-    const baseMessage = {
-        after_tools_narration: 'Model narrated after tools instead of completing. Prompting to continue...',
-        intent_without_action: "Model expressed intent but didn't act. Prompting to continue...",
-        text_tool_call: 'Model wrote tool call as text instead of using API. Prompting to use actual tools...',
-        short_response: 'Model responded too briefly. Prompting for a complete answer...',
-    };
-    const message = isEscalated
-        ? `${baseMessage[reason]} Escalating to force tool use and completion.`
-        : baseMessage[reason];
-    return { prompt, message };
-}
-/**
- * Generate a short, UI-safe preview of planning/intent text.
- * Keeps only the first line and truncates long content.
- */
-function buildPlanningPreview(content, maxLength = 140) {
-    const trimmed = (content || '').trim();
-    if (!trimmed) {
-        return null;
-    }
-    const firstLine = trimmed.split('\n').find(line => line.trim()) ?? '';
-    const collapsed = firstLine.replace(/\s+/g, ' ').trim();
-    if (!collapsed) {
-        return null;
-    }
-    const needsEllipsis = collapsed.length > maxLength;
-    const preview = collapsed.slice(0, maxLength).trim();
-    return needsEllipsis ? `${preview}...` : preview;
-}
-/**
- * Detect if content contains text-formatted tool calls that should have been actual API calls.
- * This is a PROGRAMMATIC check - if the model outputs "read_file(package.json)" as text,
- * it clearly intended to call a tool but failed to use the proper API.
- */
-function hasTextFormattedToolCall(content) {
-    // Patterns that indicate the model wrote a tool call as text instead of using the API
-    const textToolCallPatterns = [
-        // "_tool_call_" marker with function syntax
-        /_tool_call_\s*\n?\s*\w+\(/im,
-        // "tool_call:" followed by function name
-        /tool[_\s]?call:?\s*\n?\s*\w+\(/im,
-        // Common tool function call syntax at line start (not in code block)
-        /^\s*(read_file|write_file|edit_file|execute_bash|list_files)\s*\([^)]+\)/im,
-        // Indented tool call like "  read_file(package.json)"
-        /^\s{2,}(read_file|write_file|edit_file|execute_bash|list_files|Bash|Read|Write|Edit|Grep|Glob)\s*\([^)]*\)\s*$/im,
-        // "Executing/Calling tool_name..." without actual execution
-        /\b(executing|calling)\s+(read_file|write_file|edit_file|execute_bash)\s*\.{3}?\s*$/im,
-    ];
-    // Skip if the content is inside a code block (```...```)
-    const withoutCodeBlocks = content.replace(/```[\s\S]*?```/g, '');
-    return textToolCallPatterns.some(p => p.test(withoutCodeBlocks));
-}
-/**
- * Patterns that indicate genuine completion of a task.
- * These are short, definitive statements that signal work is done.
- */
-const COMPLETION_SIGNAL_PATTERNS = [
-    // Explicit done signals
-    /^(done|complete|finished|all set)[.!]?$/i,
-    // Short confirmations with specifics
-    /^(removed|deleted|fixed|created|updated|added)\s+.{1,50}[.!]?$/i,
-    // "X is now Y" short statements
-    /^.{1,30}\s+is\s+now\s+.{1,30}[.!]?$/i,
-    // Task completion with count
-    /^(cleaned|removed|fixed|updated)\s+\d+\s+.{1,30}[.!]?$/i,
-];
-/**
- * Patterns that indicate errors, failures, or incomplete work.
- * When these are present, auto-continue should kick in to fix the issues.
- * This is a PROGRAMMATIC check - if errors are reported, the task is NOT complete.
- */
-const ERROR_INDICATOR_PATTERNS = [
-    // Build/compile errors
-    /\b(error|errors|fail(s|ed|ure|ing)?|broken|crash(es|ed|ing)?)\b/i,
-    // Test failures
-    /\b(test(s)?\s+(fail|failing|failed)|failing\s+test)/i,
-    // TypeScript/compilation errors
-    /\b(typescript|ts|type)\s+error/i,
-    /\bts\(\d+,\d+\)/i, // TS error format like ts(700,45)
-    // Remaining/unresolved issues
-    /\b(persists?|remains?|still\s+(has|have|is|are|broken|failing))\b/i,
-    /\b(unresolved|outstanding|remaining)\s+(error|issue|problem)/i,
-    // Explicit incomplete signals
-    /\b(didn'?t|did\s+not|couldn'?t|could\s+not|wasn'?t|was\s+not)\s+(work|succeed|complete|finish|pass)/i,
-    /\b(skipped|blocked|cannot|unable\s+to)\b/i,
-];
-/**
- * Check if response contains error indicators that mean work is NOT complete.
- * This is a simple, programmatic check - no complex NLP needed.
- */
-function containsErrorIndicators(content) {
-    return ERROR_INDICATOR_PATTERNS.some(p => p.test(content));
-}
-/**
- * Check if response is a genuine completion signal (short, definitive statement).
- * Returns true if the model is signaling it's actually done with the task.
- * IMPORTANT: Returns false if error indicators are present - model should continue.
- */
-function isCompletionSignal(content) {
-    const trimmed = content.trim();
-    // PROGRAMMATIC: If errors are reported, this is NOT a valid completion
-    if (containsErrorIndicators(trimmed)) {
-        return false;
-    }
-    // Very short responses (<50 chars) with completion patterns are genuine signals
-    if (trimmed.length < 50) {
-        return COMPLETION_SIGNAL_PATTERNS.some(p => p.test(trimmed));
-    }
-    // Responses asking user for direction are valid stops
-    if (/\b(would you like|shall I|want me to|anything else)\b/i.test(trimmed) && trimmed.length < 200) {
-        return true;
-    }
-    // File:line citations indicate concrete work was shown
-    const hasCitation = /\b\w+\.(ts|js|tsx|jsx|py|go|rs|java|c|cpp|h|md|json|yaml|yml):\d+\b/.test(trimmed);
-    if (hasCitation) {
-        return true;
-    }
-    return false;
-}
-/**
- * PROGRAMMATIC CHECK: After tool calls, should we auto-continue?
- *
- * SIMPLE RULE: After tools, model should ONLY stop if:
- * 1. It asks the user a question (ends with ?)
- * 2. It gives a very short completion (< 80 chars) WITHOUT planning words
- *
- * Everything else = CONTINUE. This is intentionally aggressive.
- * The model should either be DONE (short message) or ASKING (question).
- * Long explanations after tool work = continue to force action.
- */
-function shouldContinueAfterTools(content) {
-    const trimmed = content.trim();
-    // No content after tools = continue to get results
-    if (trimmed.length === 0) {
-        return true;
-    }
-    // ALWAYS CONTINUE: Error indicators mean work isn't done
-    if (containsErrorIndicators(trimmed)) {
-        return true;
-    }
-    // ALWAYS CONTINUE: Intent/planning patterns mean model wants to do more
-    if (INTENT_WITHOUT_ACTION_PATTERNS.some(p => p.test(trimmed))) {
-        return true;
-    }
-    // VALID STOP: Model asking user a question (ends with ?)
-    if (/\?\s*$/.test(trimmed)) {
-        return false;
-    }
-    // VALID STOP: Explicit user-direction phrases
-    if (/\b(would you like|shall I|want me to|do you want|should I|what would you prefer)\b/i.test(trimmed)) {
-        return false;
-    }
-    // VALID STOP: Very short completion (< 80 chars) - likely "Done." or similar
-    // But ONLY if it doesn't have planning words
-    if (trimmed.length < SHORT_COMPLETION_THRESHOLD) {
-        const hasPlanningWords = /\b(i'll|i will|let me|i need|i'm going|will now|going to|first|next|now i)\b/i.test(trimmed);
-        if (!hasPlanningWords) {
-            return false; // Short and not planning = valid completion
-        }
-        // Short but has planning words = continue
-        return true;
-    }
-    // CONTINUE: Long response after tools = likely narrating/summarizing
-    // Force model to either ask a question or give a short completion
-    return true;
-}
-function shouldAutoContinue(content, hasToolCalls, hasReasoningContent = false) {
-    // Strip <thinking> blocks to get actual response content
-    const withoutThinking = content.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim();
-    // Empty content shouldn't trigger auto-continue
-    if (withoutThinking.length === 0) {
-        return { shouldContinue: false };
-    }
-    // HIGHEST PRIORITY: Check for text-formatted tool calls
-    // This is when the model writes "read_file(package.json)" as text instead of calling the API
-    if (hasTextFormattedToolCall(withoutThinking)) {
-        return { shouldContinue: true, reason: 'text_tool_call' };
-    }
-    // PROGRAMMATIC: If response reports errors/failures, auto-continue to fix them
-    // This is critical - if model reports "error persists" or "build failed", it should continue
-    if (containsErrorIndicators(withoutThinking)) {
-        return { shouldContinue: true, reason: 'error_indicators' };
-    }
-    // If model output thinking/reasoning without much content, likely needs prompting
-    if (hasReasoningContent && withoutThinking.length < 30) {
-        return { shouldContinue: true, reason: 'short_reasoning' };
-    }
-    // Check for intent patterns - model wants to do more work
-    const hasMoreIntent = INTENT_WITHOUT_ACTION_PATTERNS.some(p => p.test(withoutThinking));
-    // Even if tools were called, continue if narrative expresses MORE intent
-    // e.g., model calls grep but then says "I need to remove..." - should continue
-    if (hasToolCalls) {
-        return { shouldContinue: hasMoreIntent, reason: hasMoreIntent ? 'intent_patterns' : undefined };
-    }
-    // No tool calls - check for intent or premature conclusion
-    if (hasMoreIntent) {
-        return { shouldContinue: true, reason: 'intent_patterns' };
-    }
-    // Check for premature conclusions - model summarized without concrete findings
-    if (isPrematureConclusion(withoutThinking)) {
-        return { shouldContinue: true, reason: 'premature_conclusion' };
-    }
-    return { shouldContinue: false };
-}
 /**
  * Check if an error is a context overflow error
  */
@@ -422,7 +79,6 @@ export class AgentRuntime {
     modelId;
     workingDirectory;
     cancellationRequested = false;
-    _autoContinueEnabled = false;
     // Loop detection: track last tool calls to detect stuck loops
     lastToolCallSignature = null;
     repeatedToolCallCount = 0;
@@ -436,8 +92,6 @@ export class AgentRuntime {
     // Key: tool signature (name + JSON args), Value: result string
     toolResultCache = new Map();
     static TOOL_CACHE_MAX_SIZE = 50; // Keep last 50 tool results
-    // Track if first tool call callback has been fired this turn
-    firstToolCallFired = false;
     constructor(options) {
         this.provider = options.provider;
         this.toolRuntime = options.toolRuntime;
@@ -446,7 +100,6 @@ export class AgentRuntime {
         this.providerId = options.providerId ?? 'unknown';
         this.modelId = options.modelId ?? 'unknown';
         this.workingDirectory = options.workingDirectory ?? process.cwd();
-        this._autoContinueEnabled = options.autoContinue ?? false;
         const trimmedPrompt = options.systemPrompt.trim();
         this.baseSystemPrompt = trimmedPrompt || null;
         if (trimmedPrompt) {
@@ -472,37 +125,14 @@ export class AgentRuntime {
     isRunning() {
         return this.activeRun !== null;
     }
-    /**
-     * Check if auto-continuation is enabled.
-     */
-    isAutoContinueEnabled() {
-        return this._autoContinueEnabled;
-    }
-    /**
-     * Enable or disable auto-continuation.
-     */
-    setAutoContinue(enabled) {
-        this._autoContinueEnabled = enabled;
-    }
     async send(text, useStreaming = false) {
         const prompt = text.trim();
         if (!prompt) {
             return '';
         }
-        // CRITICAL: Fire acknowledgement callback IMMEDIATELY - before ANY other processing
-        // This guarantees the user sees feedback the moment their request is received
-        if (this.callbacks.onRequestReceived) {
-            const maxLength = 160;
-            const normalized = prompt.replace(/\s+/g, ' ');
-            const preview = normalized.length > maxLength
-                ? `${normalized.slice(0, maxLength - 3)}...`
-                : normalized;
-            this.callbacks.onRequestReceived(preview);
-        }
-        // Reset cancellation flag, loop tracking, and first tool call flag at start of new request
+        // Reset cancellation flag and loop tracking at start of new request
         this.cancellationRequested = false;
         this.resetBehavioralLoopTracking();
-        this.firstToolCallFired = false;
         // Handle multi-line paste: show summary to user, send full content to AI
         if (isMultilinePaste(prompt)) {
             const processed = processPaste(prompt);
@@ -534,7 +164,6 @@ export class AgentRuntime {
     }
     async processConversation() {
         let contextRecoveryAttempts = 0;
-        let autoContinueAttempts = 0;
         let transientRetryAttempts = 0;
         while (true) {
             // Check for cancellation at start of each iteration
@@ -579,29 +208,13 @@ export class AgentRuntime {
                         this.lastToolCallSignature = toolSignature;
                         this.repeatedToolCallCount = 1;
                     }
-                    // Always emit narration if present - it shows the AI's thought process before tools
+                    // Emit narration if present - it shows the AI's thought process before tools
                     const narration = response.content?.trim();
-                    const hasNarration = !!narration;
-                    const shouldPromptAfterTools = this._autoContinueEnabled &&
-                        autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS &&
-                        shouldContinueAfterTools(narration ?? '');
-                    // Fire first tool call callback if not yet fired this turn
-                    // ALWAYS emit acknowledgement before first tool - ensures user sees immediate feedback
-                    if (!this.firstToolCallFired && this.callbacks.onBeforeFirstToolCall) {
-                        this.firstToolCallFired = true;
-                        const toolNames = response.toolCalls.map(t => t.name);
-                        const injectedAck = this.callbacks.onBeforeFirstToolCall(toolNames, hasNarration);
-                        // ALWAYS emit acknowledgement if returned - provides immediate user feedback
-                        if (injectedAck) {
-                            this.emitAssistantMessage(injectedAck, { isFinal: false, usage, contextStats });
-                        }
-                    }
                     if (narration) {
                         this.emitAssistantMessage(narration, {
                             isFinal: false,
                             usage,
                             contextStats,
-                            suppressDisplay: shouldPromptAfterTools,
                         });
                     }
                     const assistantMessage = {
@@ -613,23 +226,6 @@ export class AgentRuntime {
                     }
                     this.messages.push(assistantMessage);
                     await this.resolveToolCalls(response.toolCalls);
-                    // PROGRAMMATIC CONTINUATION: After tool work, model must either:
-                    // 1. Call more tools (already handled by continue above)
-                    // 2. Give a short completion signal
-                    // 3. Ask user for direction
-                    // PROGRAMMATIC: If model outputs narrative instead of concrete findings, continue
-                    if (shouldPromptAfterTools) {
-                        autoContinueAttempts++;
-                        const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'after_tools_narration');
-                        this.messages.push({
-                            role: 'user',
-                            content: instruction.prompt,
-                        });
-                        this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
-                        continue;
-                    }
-                    // Reset auto-continue counter since model is actively working
-                    autoContinueAttempts = 0;
                     continue;
                 }
                 const reply = response.content?.trim() ?? '';
@@ -638,41 +234,6 @@ export class AgentRuntime {
                     this.lastToolCallSignature = null;
                     this.repeatedToolCallCount = 0;
                 }
-                // If model returned empty or very short AND auto-continue is enabled, prompt it to respond
-                // This is disabled by default to prevent loops
-                if (this._autoContinueEnabled && reply.length < 10 && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                    autoContinueAttempts++;
-                    const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'short_response');
-                    this.messages.push({ role: 'assistant', content: reply || '' });
-                    this.messages.push({
-                        role: 'user',
-                        content: instruction.prompt,
-                    });
-                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
-                    continue;
-                }
-                // Check if model expressed intent to act but didn't call tools
-                // This catches "Let me create..." without actual tool calls
-                // Also catches text-formatted tool calls like "_tool_call_\nread_file(...)"
-                // Only auto-continue if the feature is enabled
-                const continueResult = shouldAutoContinue(reply, false);
-                if (this._autoContinueEnabled && continueResult.shouldContinue && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                    autoContinueAttempts++;
-                    const planningPreview = buildPlanningPreview(reply);
-                    this.messages.push({ role: 'assistant', content: reply });
-                    // Choose prompt based on reason - text tool calls get a specific, forceful prompt
-                    const continueReason = continueResult.reason === 'text_tool_call' ? 'text_tool_call' : 'intent_without_action';
-                    const instruction = buildAutoContinueInstruction(autoContinueAttempts, continueReason);
-                    this.messages.push({
-                        role: 'user',
-                        content: instruction.prompt,
-                    });
-                    const uiMessage = planningPreview
-                        ? `${instruction.message} Next action: ${planningPreview}`
-                        : instruction.message;
-                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, uiMessage);
-                    continue;
-                }
                 if (reply) {
                     this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats });
                 }
@@ -711,7 +272,6 @@ export class AgentRuntime {
             return this.processConversation();
         }
         let contextRecoveryAttempts = 0;
-        let autoContinueAttempts = 0;
         let transientRetryAttempts = 0;
         while (true) {
             // Check for cancellation at start of each iteration
@@ -779,20 +339,8 @@ export class AgentRuntime {
                             }
                         }
                         else if (chunk.type === 'tool_call' && chunk.toolCall) {
-                            // FIRST TOOL CALL: ALWAYS inject acknowledgement for immediate user feedback
+                            // On first tool call, flush any buffered content
                             if (toolCalls.length === 0) {
-                                const hasNarration = !!(fullContent.trim() || reasoningContent.trim());
-                                // Fire callback and ALWAYS inject acknowledgement BEFORE anything else
-                                if (!this.firstToolCallFired && this.callbacks.onBeforeFirstToolCall) {
-                                    this.firstToolCallFired = true;
-                                    const injectedAck = this.callbacks.onBeforeFirstToolCall([chunk.toolCall.name], hasNarration);
-                                    // ALWAYS inject acknowledgement if returned - ensures immediate user feedback
-                                    if (injectedAck) {
-                                        // Inject acknowledgement as the FIRST thing user sees
-                                        this.callbacks.onStreamChunk?.(injectedAck + '\n', 'content');
-                                        fullContent = injectedAck + '\n' + fullContent; // Add to content for context
-                                    }
-                                }
                                 // Emit complete reasoning block first
                                 if (reasoningContent.trim()) {
                                     this.callbacks.onStreamChunk?.(reasoningContent, 'reasoning');
@@ -864,16 +412,12 @@ export class AgentRuntime {
                     // (wasStreamed=true prevents duplicate display)
                     // Note: Acknowledgement injection happens during streaming (when first tool_call chunk arrives)
                     const narration = combinedContent.trim();
-                    const shouldPromptAfterTools = this._autoContinueEnabled &&
-                        autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS &&
-                        shouldContinueAfterTools(narration ?? '');
                     if (narration) {
                         this.emitAssistantMessage(narration, {
                             isFinal: false,
                             usage,
                             contextStats,
                             wasStreamed: true,
-                            suppressDisplay: shouldPromptAfterTools,
                         });
                     }
                     const assistantMessage = {
@@ -883,69 +427,14 @@ export class AgentRuntime {
                     };
                     this.messages.push(assistantMessage);
                     await this.resolveToolCalls(toolCalls);
-                    // PROGRAMMATIC CONTINUATION: After tool work, model must either:
-                    // 1. Call more tools (already handled by continue above)
-                    // 2. Give a short completion signal
-                    // 3. Ask user for direction
-                    // PROGRAMMATIC: If model outputs narrative instead of concrete findings, continue
-                    if (shouldPromptAfterTools) {
-                        autoContinueAttempts++;
-                        const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'after_tools_narration');
-                        this.messages.push({
-                            role: 'user',
-                            content: instruction.prompt,
-                        });
-                        this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
-                        continue;
-                    }
-                    // Reset auto-continue counter since model appears to be done
-                    autoContinueAttempts = 0;
                     continue;
                 }
-                // Check if model expressed intent to act but didn't call tools
-                // This catches "Let me create..." without actual tool calls
-                // Only auto-continue if the feature is enabled
                 const reply = combinedContent.trim();
                 // Reset loop detection when we get a text response (not just tool calls)
                 if (reply.length >= 10) {
                     this.lastToolCallSignature = null;
                     this.repeatedToolCallCount = 0;
                 }
-                // If model returned empty or very short AND auto-continue is enabled, prompt it to respond
-                // This is disabled by default to prevent loops
-                if (this._autoContinueEnabled && reply.length < 10 && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                    autoContinueAttempts++;
-                    const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'short_response');
-                    this.messages.push({ role: 'assistant', content: reply || '' });
-                    this.messages.push({
-                        role: 'user',
-                        content: instruction.prompt,
-                    });
-                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
-                    continue;
-                }
-                // PROGRAMMATIC CHECK: Text-only responses after tool work need scrutiny
-                // If model outputs substantial narrative without tools, it's likely summarizing
-                // Check if this is a genuine completion or a premature summary
-                // Also catches text-formatted tool calls like "_tool_call_\nread_file(...)"
-                if (this._autoContinueEnabled && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                    // Intent patterns still catch "let me X" without tools
-                    const streamContinueResult = shouldAutoContinue(reply, false);
-                    if (streamContinueResult.shouldContinue) {
-                        autoContinueAttempts++;
-                        const planningPreview = buildPlanningPreview(reply);
-                        this.messages.push({ role: 'assistant', content: reply });
-                        // Choose prompt based on reason - text tool calls get a specific, forceful prompt
-                        const continueReason = streamContinueResult.reason === 'text_tool_call' ? 'text_tool_call' : 'intent_without_action';
-                        const instruction = buildAutoContinueInstruction(autoContinueAttempts, continueReason);
-                        this.messages.push({ role: 'user', content: instruction.prompt });
-                        const uiMessage = planningPreview
-                            ? `${instruction.message} Next action: ${planningPreview}`
-                            : instruction.message;
-                        this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, uiMessage);
-                        continue;
-                    }
-                }
                 // Final message - mark as streamed to avoid double-display in UI
                 if (reply) {
                     this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats, wasStreamed: true });
@@ -1131,7 +620,7 @@ export class AgentRuntime {
         return false; // Always show thinking/narration
     }
     emitAssistantMessage(content, metadata) {
-        if (!content) {
+        if (!content || !content.trim()) {
             return;
         }
         const elapsedMs = this.activeRun ? Date.now() - this.activeRun.startedAt : undefined;