erosolar-cli 2.1.174 → 2.1.176

package/dist/shell/interactiveShell.js

@@ -12,12 +12,13 @@ import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue
 import { saveActiveProfilePreference, saveModelPreference, loadToolSettings, saveToolSettings, clearToolSettings, clearActiveProfilePreference, loadSessionPreferences, saveSessionPreferences, loadFeatureFlags, saveFeatureFlags, toggleFeatureFlag, FEATURE_FLAG_INFO, } from '../core/preferences.js';
 import { getLearningSummary, getRecentLearning, commitLearning, exportAllLearning, getLearningDir, } from '../core/learningPersistence.js';
 import { buildEnabledToolSet, evaluateToolPermissions, getToolToggleOptions, } from '../capabilities/toolRegistry.js';
+import { FlowOrchestrator } from '../runtime/flowOrchestrator.js';
 import { detectApiKeyError } from '../core/errors/apiKeyErrors.js';
 import { detectPromptBlockError, } from '../core/errors/promptBlockErrors.js';
 import { detectNetworkError } from '../core/errors/networkErrors.js';
 import { buildWorkspaceContext } from '../workspace.js';
 import { buildInteractiveSystemPrompt } from './systemPrompt.js';
-import { getTaskCompletionDetector, resetTaskCompletionDetector, } from './taskCompletionDetector.js';
+import { getTaskCompletionDetector, resetTaskCompletionDetector, WRITE_TOOLS, } from './taskCompletionDetector.js';
 import { discoverAllModels, quickCheckProviders, getCachedDiscoveredModels, sortModelsByPriority } from '../core/modelDiscovery.js';
 import { getModels, getSlashCommands, getProviders } from '../core/agentSchemaLoader.js';
 import { loadMcpServers } from '../mcp/config.js';
@@ -85,6 +86,10 @@ const CONTEXT_CLEANUP_SYSTEM_PROMPT = `Summarize earlier IDE collaboration so th
 - Respond in plain Markdown only (no tool or shell calls).`;
 const MAX_ATTACHMENT_BYTES = 200 * 1024; // 200KB per attachment
 const MAX_ATTACHMENT_CHARS = 16000; // Guardrail to avoid flooding context
+const WRITE_TOOL_NAMES = new Set(Array.from(WRITE_TOOLS)
+    .map((tool) => tool.toLowerCase())
+    // Bash/execute commands can be read-only; guard only on clear mutating tools
+    .filter((tool) => !tool.includes('bash') && !tool.startsWith('execute')));
 export class InteractiveShell {
     agent = null;
     profile;
@@ -119,6 +124,7 @@ export class InteractiveShell {
     uiUpdates;
     _fileChangeTracker = new FileChangeTracker(); // Reserved for future file tracking features
     alphaZeroMetrics; // Alpha Zero 2 performance tracking
+    flowOrchestrator = new FlowOrchestrator();
     maxNetworkRetries = 2;
     statusSubscription = null;
     followUpQueue = [];
@@ -157,6 +163,7 @@ export class InteractiveShell {
     // AlphaZero learning tracking
     currentTaskType = 'general';
     currentToolCalls = [];
+    toolsUsedThisRun = [];
     lastUserQuery = '';
     lastAssistantResponse = null;
     responseRendered = false;
@@ -2266,8 +2273,13 @@ export class InteractiveShell {
             await this.processSlashCommand(trimmed);
             return;
         }
-        // Check for continuous/infinite loop commands
-        if (this.isContinuousCommand(trimmed)) {
+        // Check for continuous/infinite loop commands or auto-escalation to completion mode
+        const explicitContinuous = this.isContinuousCommand(trimmed);
+        const autoContinuous = this.shouldAutoRunToCompletion(trimmed);
+        if (explicitContinuous || autoContinuous) {
+            if (autoContinuous && !explicitContinuous) {
+                display.showSystemMessage('⚡ Actionable request detected; running continuously until complete (Ctrl+C to stop).');
+            }
             await this.processContinuousRequest(trimmed);
             this.syncRendererInput();
             return;
@@ -2289,6 +2301,90 @@ export class InteractiveShell {
         ];
         return patterns.some(pattern => pattern.test(lower));
     }
+    /**
+     * Detects actionable requests that should auto-run until completion even without explicit cues.
+     * Filters out obvious questions and informational prompts to avoid over-triggering.
+     */
+    shouldAutoRunToCompletion(input) {
+        const normalized = input.trim().toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+        const isQuestion = /\?$/.test(normalized);
+        const startsWithInfoWord = /^(what|why|how|when|where|who|which|can|could|would|should|is|are|do|does|did)\b/.test(normalized);
+        // Multi-step maintenance/cleanup intents (order-agnostic to catch "junk to remove?" cases)
+        const maintenancePatterns = [
+            /\b(clean\s*up|cleanup|tidy|prune|trim|housekeep|housekeeping|sanitize)\b/,
+            /\b(junk|unused|dead|legacy|obsolete|temp|tmp|artifact|artifacts|cache|trash)\b.*\b(remove|delete|strip|drop|purge|clear|clean)\b/,
+            /\b(remove|delete|strip|drop|purge|clear|clean)\b.*\b(junk|unused|dead|legacy|obsolete|temp|tmp|artifact|artifacts|cache|trash)\b/,
+        ];
+        const strongMaintenanceIntent = maintenancePatterns.some((pattern) => pattern.test(normalized));
+        // General action intent in a code context
+        const actionVerb = /\b(fix|resolve|address|refactor|implement|upgrade|migrate|optimi[sz]e|modernize|stabilize|harden|ship|complete|finish|clean|remove|delete|prune|tidy|audit|cleanup)\b/;
+        const codeContext = /\b(repo|codebase|project|app|service|package|module|component|workspace|cli|tests?|source|files?|artifacts?)\b/;
+        const strongActionIntent = actionVerb.test(normalized) && codeContext.test(normalized) && normalized.length > 20;
+        // Allow maintenance/refactor tasks to auto-run even if phrased as questions ("got any junk to remove?")
+        if (strongMaintenanceIntent || strongActionIntent) {
+            // But still avoid purely informational questions like "what is this repo?"
+            if (startsWithInfoWord && !strongMaintenanceIntent) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Decide whether to automatically continue execution when the model stops after a plan/summary
+     * without taking actions. This keeps flows moving toward completion instead of stalling on planning.
+     */
+    shouldAutoEscalateToExecution(request, response, toolsUsed) {
+        // Only auto-escalate when the original request itself was action-oriented
+        if (!this.shouldAutoRunToCompletion(request)) {
+            return false;
+        }
+        if (!response || response.includes('TASK_FULLY_COMPLETE')) {
+            return false;
+        }
+        const lower = response.toLowerCase();
+        // Skip if the model explicitly says it is blocked
+        const blockerPatterns = [
+            /\bneed(s)?\s+(more\s+)?(info|information|details|clarification)\b/,
+            /\bmissing\s+(api\s*key|credentials?|access|permission|token)\b/,
+            /\b(no|not)\s+authorized\b/,
+            /\bcannot\s+(proceed|continue|start|run)\b/,
+            /\bblocked\b/,
+        ];
+        if (blockerPatterns.some((pattern) => pattern.test(lower))) {
+            return false;
+        }
+        const mutatingToolUsed = toolsUsed.some((tool) => WRITE_TOOL_NAMES.has(tool.toLowerCase()));
+        const planOnly = this.flowOrchestrator.isPlanOnlyResponse(response);
+        const lowActionDensity = response.split(/\s+/).length < 80;
+        // If it's clearly a plan-only response, continue regardless of prior tool usage
+        if (planOnly) {
+            return true;
+        }
+        // Thin responses without any mutating work should keep pushing toward completion
+        if (!mutatingToolUsed && lowActionDensity) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Build a follow-through request when the model stops after planning instead of executing.
+     */
+    maybeAutoFollowThrough(request, response, toolsUsed) {
+        if (!this.shouldAutoEscalateToExecution(request, response, toolsUsed)) {
+            return null;
+        }
+        const prompt = `${request.trim()}
+
+Execute the plan you outlined. Use the available tools (bash, edits, git) to take the next actions and keep going until the request is fully accomplished. Do not restate the plan—perform the steps and report progress. Reply with TASK_FULLY_COMPLETE only when the work is truly done.`;
+        return {
+            prompt,
+            reason: 'Plan-only or low-action response detected; auto-continuing to complete the task.',
+        };
+    }
     isExitCommand(input) {
         const lower = input.trim().toLowerCase();
         return (lower === 'exit' ||
@@ -5751,6 +5847,8 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
+        this.toolsUsedThisRun = [];
+        this.currentToolCalls = [];
         this.runtimeSession.toolRuntime.clearDiffSnapshots?.();
         if (this.suppressNextNetworkReset) {
             this.suppressNextNetworkReset = false;
@@ -5785,6 +5883,7 @@ export class InteractiveShell {
         this.setProcessingStatus();
         this.beginAiRuntime();
         let responseText = '';
+        let autoFollowThrough = null;
         try {
             // Start streaming - no header needed, the input area already provides context
             this.startStreamingHeartbeat('Streaming response');
@@ -5800,13 +5899,14 @@ export class InteractiveShell {
                 display.showWarning('The provider returned an empty response. Check your API key/provider selection or retry the prompt.');
             }
             // AlphaZero: Extract and track tool calls from response
-            const toolsUsed = this.extractToolsFromResponse(responseText);
+            const toolsUsed = this.getExecutedTools(responseText);
             this.currentToolCalls = toolsUsed.map(name => ({
                 name,
                 arguments: {},
                 success: true, // Assume success if we got here
                 duration: 0,
             }));
+            autoFollowThrough = this.maybeAutoFollowThrough(request, responseText, toolsUsed);
             // AlphaZero: Check for failure in response
             const failure = detectFailure(responseText, {
                 toolCalls: this.currentToolCalls,
@@ -5865,6 +5965,11 @@ export class InteractiveShell {
             this.updateToolUsageMeta(this.uiAdapter.getToolUsageSummary({ plain: true }));
             this.setIdleStatus();
             this.updateStatusMessage(null);
+            if (autoFollowThrough) {
+                display.showSystemMessage(`🔁 Auto-follow-through: ${autoFollowThrough.reason}`);
+                this.enqueueFollowUpAction({ type: 'continuous', text: autoFollowThrough.prompt });
+            }
+            this.toolsUsedThisRun = [];
             queueMicrotask(() => this.uiUpdates.setMode('idle'));
             // CRITICAL: Ensure readline prompt is active for user input
             // Erosolar-CLI style: New prompt naturally appears at bottom
@@ -5902,6 +6007,8 @@ export class InteractiveShell {
         if (!agent) {
             return;
         }
+        this.toolsUsedThisRun = [];
+        this.currentToolCalls = [];
         this.lastUserQuery = initialRequest;
         this.clearToolUsageMeta();
         this.isProcessing = true;
@@ -5930,13 +6037,8 @@ export class InteractiveShell {
         this.beginAiRuntime();
         // No streaming header - just start streaming directly
         this.startStreamingHeartbeat('Streaming');
+        this.flowOrchestrator.start(initialRequest);
         let iteration = 0;
-        let lastResponse = '';
-        let consecutiveNoProgress = 0;
-        const MAX_NO_PROGRESS = 5; // Increased to allow more attempts before giving up
-        let pendingVerification = false;
-        let verificationAttempts = 0;
-        const MAX_VERIFICATION_ATTEMPTS = 2;
         try {
             // Enhance initial prompt with git context for self-improvement tasks
             let currentPrompt = initialRequest;
@@ -5954,6 +6056,7 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
             }
             while (iteration < MAX_ITERATIONS) {
                 iteration++;
+                this.toolsUsedThisRun = [];
                 display.showSystemMessage(`\n📍 Iteration ${iteration}/${MAX_ITERATIONS}`);
                 this.updateStatusMessage(`Working on iteration ${iteration}...`);
                 try {
@@ -5970,104 +6073,52 @@ When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`;
                     this.alphaZeroMetrics.recordMessage(elapsedMs);
                     if (!response?.trim()) {
                         display.showWarning('Model returned an empty response. Retrying this iteration...');
-                        consecutiveNoProgress++;
                         currentPrompt = `${initialRequest}
 
 The previous reply was empty. Resume the task now: take the next action, call the necessary tools, and report progress.`;
                         continue;
                     }
                     // Extract tools used from the response (look for tool call patterns)
-                    const toolsUsed = this.extractToolsFromResponse(response);
-                    completionDetector.recordToolCall.bind(completionDetector);
+                    const toolsUsed = this.getExecutedTools(response);
                     toolsUsed.forEach(tool => completionDetector.recordToolCall(tool, true, true));
                     // Use intelligent completion detection
                     const completionAnalysis = completionDetector.analyzeCompletion(response, toolsUsed);
                     display.showSystemMessage(`📈 Completion confidence: ${(completionAnalysis.confidence * 100).toFixed(0)}%`);
-                    // Check for explicit TASK_FULLY_COMPLETE marker (highest priority)
-                    // BUT: Don't terminate if the response also indicates work is incomplete
-                    if (response.includes('TASK_FULLY_COMPLETE')) {
-                        const hasContradiction = this.responseIndicatesIncompleteWork(response);
-                        if (hasContradiction) {
-                            display.showSystemMessage(`\n⚠️ TASK_FULLY_COMPLETE detected but response indicates incomplete work. Continuing...`);
-                            // Override the completion signal - the AI is contradicting itself
-                            currentPrompt = `You marked the task as TASK_FULLY_COMPLETE but also indicated that work is still pending or not integrated. Please clarify:
-
-1. Is ALL the originally requested work actually complete and functional?
-2. If there are parts that are "ready but not integrated" or "implemented but not connected", those are NOT complete.
-3. Only say TASK_FULLY_COMPLETE when the user's original request is 100% fulfilled.
-
-What remains to be done? Continue with the next step.`;
-                            await new Promise(resolve => setTimeout(resolve, 500));
-                            continue;
-                        }
-                        display.showSystemMessage(`\n✅ Task explicitly marked complete after ${iteration} iteration(s).`);
+                    const decision = this.flowOrchestrator.decide({
+                        iteration,
+                        response,
+                        toolsUsed,
+                        completionAnalysis,
+                        verificationConfirmed: this.flowOrchestrator.isVerificationPending()
+                            ? completionDetector.isVerificationConfirmed(response)
+                            : false,
+                    });
+                    if (decision.type === 'stop') {
+                        display.showSystemMessage(decision.message);
                         break;
                     }
-                    // High confidence completion without verification needed
-                    if (completionAnalysis.isComplete && completionAnalysis.confidence >= 0.85) {
-                        display.showSystemMessage(`\n✅ Task completed with high confidence after ${iteration} iteration(s).`);
-                        display.showSystemMessage(`   Reason: ${completionAnalysis.reason}`);
+                    if (decision.type === 'stagnation-stop') {
+                        display.showWarning(decision.message);
                         break;
                     }
-                    // Medium confidence - run verification round
-                    if (completionAnalysis.shouldVerify && completionAnalysis.verificationPrompt && !pendingVerification) {
-                        if (verificationAttempts < MAX_VERIFICATION_ATTEMPTS) {
-                            display.showSystemMessage(`\n🔍 Running verification round (confidence: ${(completionAnalysis.confidence * 100).toFixed(0)}%)...`);
-                            pendingVerification = true;
-                            verificationAttempts++;
-                            currentPrompt = completionAnalysis.verificationPrompt;
-                            await new Promise(resolve => setTimeout(resolve, 500));
-                            continue;
-                        }
+                    if (decision.type === 'execute-plan') {
+                        display.showSystemMessage(decision.message);
+                        currentPrompt = decision.prompt;
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        continue;
                     }
-                    // If we were in verification mode, check the result
-                    if (pendingVerification) {
-                        pendingVerification = false;
-                        if (completionDetector.isVerificationConfirmed(response)) {
-                            display.showSystemMessage(`\n✅ Task completion verified by AI after ${iteration} iteration(s).`);
-                            break;
-                        }
-                        else {
-                            display.showSystemMessage(`🔄 Verification indicates more work needed. Continuing...`);
-                        }
+                    if (decision.type === 'verify') {
+                        display.showSystemMessage(decision.message);
+                        currentPrompt = decision.prompt;
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        continue;
                     }
-                    // Check for no progress (same response multiple times)
-                    const responseChanged = response !== lastResponse;
-                    if (!responseChanged) {
-                        consecutiveNoProgress++;
-                        if (consecutiveNoProgress >= MAX_NO_PROGRESS) {
-                            // Before giving up, ask one final verification
-                            if (verificationAttempts < MAX_VERIFICATION_ATTEMPTS) {
-                                display.showSystemMessage(`\n⚠️ No progress for ${MAX_NO_PROGRESS} iterations. Running final verification...`);
-                                currentPrompt = `I notice you may be stuck or finished. Please confirm:
-
-1. Is the original task FULLY complete?
-2. If yes, respond with exactly: "TASK_FULLY_COMPLETE"
-3. If no, what specific action should be taken next?
-
-Be explicit about the current state.`;
-                                verificationAttempts++;
-                                consecutiveNoProgress = 0;
-                                await new Promise(resolve => setTimeout(resolve, 500));
-                                continue;
-                            }
-                            display.showSystemMessage(`\n⚠️ No progress detected for ${MAX_NO_PROGRESS} iterations and verification exhausted. Stopping.`);
-                            break;
+                    if (decision.type === 'continue') {
+                        if (decision.message) {
+                            display.showSystemMessage(decision.message);
                         }
+                        currentPrompt = decision.prompt;
                     }
-                    else {
-                        consecutiveNoProgress = 0;
-                    }
-                    lastResponse = response;
-                    // Prepare next iteration prompt - explicitly encourage progress reporting
-                    currentPrompt = `Continue with the next step. Remember:
-- Use bash to run git commands (git status, git add, git commit, git push)
-- Commit your changes with descriptive messages after completing improvements
-- Push changes when a logical milestone is reached
-- If all tasks are complete, respond with exactly: "TASK_FULLY_COMPLETE"
-- If there are errors or blockers, explain what's preventing progress
-
-What's the next action?`;
                     // Small delay between iterations to prevent rate limiting
                     await new Promise(resolve => setTimeout(resolve, 500));
                 }
@@ -6110,6 +6161,7 @@ What's the next action?`;
             this.updateToolUsageMeta(this.uiAdapter.getToolUsageSummary({ plain: true }));
             this.setIdleStatus();
             this.updateStatusMessage(null);
+            this.toolsUsedThisRun = [];
             queueMicrotask(() => this.uiUpdates.setMode('idle'));
             // CRITICAL: Ensure readline prompt is active for user input
             // Erosolar-CLI style: New prompt naturally appears at bottom
@@ -6120,94 +6172,24 @@ What's the next action?`;
         }
     }
     /**
-     * Check if a response contains indicators that work is actually incomplete,
-     * even if it also contains TASK_FULLY_COMPLETE marker.
-     * This catches contradictory responses where the AI says "done" but also "not integrated yet".
+     * Resolve executed tools for the current turn. Prefer the actual tool
+     * execution callbacks; fall back to parsing the response when unavailable.
      */
-    responseIndicatesIncompleteWork(response) {
-        // Patterns that indicate work isn't actually complete
-        // Organized by category for maintainability
-        const incompletePatterns = [
-            // === INTEGRATION/DEPLOYMENT STATE ===
-            // "hasn't been integrated/implemented/connected yet"
-            /hasn'?t\s+been\s+(integrated|implemented|connected|deployed|added|completed|tested|verified)\s*(yet|still)?/i,
-            // "not yet integrated/implemented" or "not integrated"
-            /not\s+(yet\s+)?(integrated|implemented|connected|deployed|functional|working|complete|tested|verified)/i,
-            // "ready for integration" = NOT integrated
-            /ready\s+(for|to\s+be)\s+(integration|integrated|connected|deployed|testing|review)/i,
-            // "needs to be integrated"
-            /needs?\s+to\s+be\s+(integrated|connected|deployed|added|hooked|wired|tested|reviewed|merged)/i,
-            // Passive voice: "was not performed/completed"
-            /was\s+not\s+(performed|completed|implemented|deployed|integrated|tested)/i,
-            // "the [X] service hasn't been"
-            /the\s+\w+\s+(service|module|component|feature)\s+hasn'?t\s+been/i,
-            // === PARTIAL/INCOMPLETE STATE ===
-            // "still stores/uses/has" (current bad state persists)
-            /still\s+(stores?|uses?|has|contains?|needs?|requires?|missing|lacks?|broken)/i,
-            // Partial completion: "partially", "mostly", "almost"
-            /\b(partially|mostly|almost|nearly|not\s+fully)\s+(complete|done|finished|implemented|working)/i,
-            // Explicit partial: "part of", "some of", "half of"
-            /\b(only\s+)?(part|some|half|portion)\s+of\s+(the\s+)?(task|work|feature|implementation)/i,
-            // === QUALIFIER WORDS (uncertain completion) ===
-            // "should be complete", "appears complete", "theoretically"
-            /\b(should|might|may|could|appears?\s+to)\s+be\s+(complete|done|working|functional)/i,
-            /\btheoretically\s+(complete|done|working|functional)/i,
-            // "assuming", "if everything works"
-            /\b(assuming|provided|if)\s+(everything|it|this|that)\s+(works?|is\s+correct)/i,
-            // === SELF-CONTRADICTION PHRASES ===
-            // "done but...", "complete except...", "finished however..."
-            /\b(done|complete|finished)\s+(but|except|however|although|though)/i,
-            // "however" followed by incomplete indicator
-            /however[,\s].{0,50}?(hasn'?t|not\s+yet|still\s+needs?|pending|remains?|missing|broken|failing)/i,
-            // "but" followed by negative state
-            /\bbut\s+.{0,30}?(not|hasn'?t|won'?t|can'?t|doesn'?t|isn'?t|wasn'?t)/i,
-            // === FUTURE TENSE / DEFERRED WORK ===
-            // "will need to", "will require"
-            /will\s+(need\s+to|require|have\s+to)\s+(integrate|connect|deploy|complete|implement|test|fix)/i,
-            // Deferred: "left as", "deferred", "postponed", "out of scope"
-            /\b(left\s+as|deferred|postponed|out\s+of\s+scope|for\s+later|in\s+a\s+future)/i,
-            // Time-dependent: "after restart", "takes effect after", "once you"
-            /\b(after\s+(restart|reboot|redeploy)|takes?\s+effect\s+after|once\s+you)/i,
-            // === REMAINING WORK INDICATORS ===
-            // "remaining tasks", "outstanding items"
-            /\b(remaining|outstanding|pending|leftover)\s+(tasks?|items?|work|issues?|steps?)/i,
-            // "X more to do", "still have to"
-            /\b(more\s+to\s+do|still\s+have\s+to|yet\s+to\s+be\s+done)/i,
-            // Explicit blockers
-            /\b(blocker|blocked\s+by|waiting\s+(for|on)|depends?\s+on)/i,
-            // === ERROR/FAILURE STATE ===
-            // "failing tests", "build errors"
-            /\b(failing|broken|erroring)\s+(tests?|builds?|checks?|validations?)/i,
-            // "tests? (are )?(still )?failing"
-            /\btests?\s+(are\s+)?(still\s+)?failing/i,
-            // "errors? to (address|fix)"
-            /\b(errors?|warnings?|issues?)\s+to\s+(address|fix|resolve)/i,
-            // "doesn't work", "isn't working", "not working"
-            /\b(doesn'?t|isn'?t|not)\s+(work|working|functional|functioning)/i,
-            // === MANUAL STEPS REQUIRED ===
-            // "you'll need to", "manually run", "requires user"
-            /\b(you('ll|\s+will)\s+need\s+to|manually\s+(run|configure|set|update)|requires?\s+user)/i,
-            // "run this command", "execute the following"
-            /\b(run\s+this|execute\s+the\s+following|apply\s+the\s+migration)/i,
-            // === TODO/FIXME IN PROSE ===
-            // TODO or FIXME mentioned as remaining work (not in code blocks)
-            /\b(todo|fixme|hack|xxx):\s/i,
-            // "need to add", "should implement"
-            /\b(need\s+to|should|must)\s+(add|implement|create|write|build|fix)\b/i,
-            // === SCOPE LIMITATIONS ===
-            // "didn't have time", "ran out of time"
-            /\b(didn'?t|did\s+not)\s+have\s+(time|chance|opportunity)/i,
-            // "beyond scope", "outside scope"
-            /\b(beyond|outside)\s+(the\s+)?scope/i,
-            // "for now" (temporary state)
-            /\b(for\s+now|at\s+this\s+point|currently)\s*.{0,20}?(not|without|lacks?|missing)/i,
-        ];
-        for (const pattern of incompletePatterns) {
-            if (pattern.test(response)) {
-                return true;
+    getExecutedTools(responseText) {
+        if (this.toolsUsedThisRun.length) {
+            const seen = new Set();
+            const ordered = [];
+            for (const tool of this.toolsUsedThisRun) {
+                const normalized = tool?.trim();
+                if (!normalized || seen.has(normalized)) {
+                    continue;
+                }
+                seen.add(normalized);
+                ordered.push(normalized);
             }
+            return ordered;
         }
-        return false;
+        return this.extractToolsFromResponse(responseText);
     }
     /**
      * Extract tool names from a response by looking for tool call patterns
@@ -6842,6 +6824,7 @@ Return ONLY JSON array:
                 onToolExecution: (toolName, isStart, args) => {
                     // Update activity status to show what tool is being executed
                     if (isStart) {
+                        this.toolsUsedThisRun.push(toolName);
                         // Show more specific activity for long-running tools
                         let activity = `Running ${toolName}`;
                         if (toolName === 'execute_bash' && args?.['command']) {