erosolar-cli 2.1.176 → 2.1.177

package/dist/shell/interactiveShell.js

@@ -4,6 +4,7 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { AgentOrchestrator } from '../core/agentOrchestrator.js';
 import { display } from '../ui/display.js';
 import { theme } from '../ui/theme.js';
 import { getTerminalColumns } from '../ui/layout.js';
@@ -12,13 +13,12 @@ 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, WRITE_TOOLS, } from './taskCompletionDetector.js';
+import { 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';
@@ -124,7 +124,6 @@ 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 = [];
@@ -2276,14 +2275,17 @@ export class InteractiveShell {
         // 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).');
-            }
+        if (explicitContinuous) {
             await this.processContinuousRequest(trimmed);
             this.syncRendererInput();
             return;
         }
+        if (autoContinuous) {
+            display.showSystemMessage('⚡ Actionable request detected; orchestrating until complete (Ctrl+C to stop).');
+            await this.processRequest(trimmed, { orchestrate: true });
+            this.syncRendererInput();
+            return;
+        }
         // Direct execution for all inputs, including multi-line pastes
         await this.processRequest(trimmed);
         this.syncRendererInput();
@@ -2358,7 +2360,7 @@ export class InteractiveShell {
             return false;
         }
         const mutatingToolUsed = toolsUsed.some((tool) => WRITE_TOOL_NAMES.has(tool.toLowerCase()));
-        const planOnly = this.flowOrchestrator.isPlanOnlyResponse(response);
+        const planOnly = this.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) {
@@ -5832,7 +5834,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
         this.clearInlinePanel();
         this.syncRendererInput();
     }
-    async processRequest(request) {
+    async processRequest(request, options) {
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'request', text: request });
             return;
@@ -5884,10 +5886,23 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
         this.beginAiRuntime();
         let responseText = '';
         let autoFollowThrough = null;
+        let orchestratorResult = null;
+        const orchestrate = options?.orchestrate ?? false;
         try {
             // Start streaming - no header needed, the input area already provides context
             this.startStreamingHeartbeat('Streaming response');
-            responseText = await agent.send(request, true);
+            if (orchestrate) {
+                const orchestrator = new AgentOrchestrator(agent);
+                orchestratorResult = await orchestrator.runToCompletion(request, {
+                    streaming: true,
+                    maxPasses: options?.maxPasses ?? 4,
+                    enforceActions: true,
+                });
+                responseText = orchestratorResult.finalResponse;
+            }
+            else {
+                responseText = await agent.send(request, true);
+            }
             this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
             await this.awaitPendingCleanup();
             this.captureHistorySnapshot();
@@ -5899,14 +5914,24 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
                 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.getExecutedTools(responseText);
+            const toolsUsed = orchestratorResult
+                ? orchestratorResult.passes.flatMap(pass => pass.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);
+            if (!orchestrate) {
+                autoFollowThrough = this.maybeAutoFollowThrough(request, responseText, toolsUsed);
+            }
+            if (orchestratorResult && orchestratorResult.exitReason !== 'complete') {
+                const exitDetail = orchestratorResult.exitReason === 'max-passes'
+                    ? 'Reached orchestrator pass limit; showing last response.'
+                    : 'Received empty replies while orchestrating; showing last response.';
+                display.showSystemMessage(`⚠️ ${exitDetail}`);
+            }
             // AlphaZero: Check for failure in response
             const failure = detectFailure(responseText, {
                 toolCalls: this.currentToolCalls,
@@ -5938,7 +5963,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
             }
         }
         catch (error) {
-            const handled = this.handleProviderError(error, () => this.processRequest(request));
+            const handled = this.handleProviderError(error, () => this.processRequest(request, options));
             if (!handled) {
                 // Pass full error object for enhanced formatting with stack trace
                 display.showError(error instanceof Error ? error.message : String(error), error);
@@ -5992,7 +6017,7 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
      * Context is automatically managed - overflow errors trigger auto-recovery.
      */
     async processContinuousRequest(initialRequest) {
-        const MAX_ITERATIONS = 100; // Safety limit to prevent truly infinite loops
+        const MAX_PASSES = 100; // Safety limit to prevent truly infinite loops
         if (this.isProcessing) {
             this.enqueueFollowUpAction({ type: 'continuous', text: initialRequest });
             return;
@@ -6001,49 +6026,9 @@ Execute the plan you outlined. Use the available tools (bash, edits, git) to tak
             display.showWarning('Configure an API key via /secrets before sending requests.');
             return;
         }
-        this.inlinePanelScopeActive = false;
-        this.clearInlinePanel();
-        const agent = this.agent;
-        if (!agent) {
-            return;
-        }
-        this.toolsUsedThisRun = [];
-        this.currentToolCalls = [];
-        this.lastUserQuery = initialRequest;
-        this.clearToolUsageMeta();
-        this.isProcessing = true;
-        this.uiUpdates.setMode('processing');
-        this.streamingTokenCount = 0; // Reset token counter for new request
-        this.terminalInput.setStreaming(true);
-        if (this.suppressNextNetworkReset) {
-            this.suppressNextNetworkReset = false;
-        }
-        else {
-            this.resetNetworkRetryState();
-        }
-        const overallStartTime = Date.now();
-        // Clear previous parallel agents and start fresh for continuous mode
-        const parallelManager = getParallelAgentManager();
-        parallelManager.clear();
-        parallelManager.startBatch();
-        // Initialize the task completion detector
-        const completionDetector = getTaskCompletionDetector();
-        completionDetector.reset();
-        // Display user prompt in scrollback (Claude Code style)
-        this.logUserPrompt(initialRequest);
         display.showSystemMessage(`Continuous mode active. Ctrl+C to stop.`);
-        this.uiAdapter.startProcessing('Continuous execution mode');
-        this.setProcessingStatus();
-        this.beginAiRuntime();
-        // No streaming header - just start streaming directly
-        this.startStreamingHeartbeat('Streaming');
-        this.flowOrchestrator.start(initialRequest);
-        let iteration = 0;
-        try {
-            // Enhance initial prompt with git context for self-improvement tasks
-            let currentPrompt = initialRequest;
-            if (this.isSelfImprovementRequest(initialRequest)) {
-                currentPrompt = `${initialRequest}
+        const preparedRequest = this.isSelfImprovementRequest(initialRequest)
+            ? `${initialRequest}
 
 IMPORTANT: You have full git access. After making improvements:
 1. Use bash to run: git status (see changes)
@@ -6052,124 +6037,9 @@ IMPORTANT: You have full git access. After making improvements:
 4. Use bash to run: git push (when milestone reached)
 
 Commit frequently with descriptive messages. Push when ready.
-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 {
-                    // Send the request and capture the response (streaming disabled)
-                    display.showThinking('Responding...');
-                    this.refreshStatusLine(true);
-                    const response = await agent.send(currentPrompt, true);
-                    this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
-                    await this.awaitPendingCleanup();
-                    this.captureHistorySnapshot();
-                    this.autosaveIfEnabled();
-                    // Track metrics
-                    const elapsedMs = Date.now() - overallStartTime;
-                    this.alphaZeroMetrics.recordMessage(elapsedMs);
-                    if (!response?.trim()) {
-                        display.showWarning('Model returned an empty response. Retrying this iteration...');
-                        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.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)}%`);
-                    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;
-                    }
-                    if (decision.type === 'stagnation-stop') {
-                        display.showWarning(decision.message);
-                        break;
-                    }
-                    if (decision.type === 'execute-plan') {
-                        display.showSystemMessage(decision.message);
-                        currentPrompt = decision.prompt;
-                        await new Promise(resolve => setTimeout(resolve, 500));
-                        continue;
-                    }
-                    if (decision.type === 'verify') {
-                        display.showSystemMessage(decision.message);
-                        currentPrompt = decision.prompt;
-                        await new Promise(resolve => setTimeout(resolve, 500));
-                        continue;
-                    }
-                    if (decision.type === 'continue') {
-                        if (decision.message) {
-                            display.showSystemMessage(decision.message);
-                        }
-                        currentPrompt = decision.prompt;
-                    }
-                    // Small delay between iterations to prevent rate limiting
-                    await new Promise(resolve => setTimeout(resolve, 500));
-                }
-                catch (error) {
-                    display.stopThinking(false);
-                    // Handle context overflow specially - the agent should auto-recover
-                    // but if it propagates here, we continue the loop
-                    if (this.isContextOverflowError(error)) {
-                        display.showSystemMessage(`⚡ Context overflow handled. Continuing with reduced context...`);
-                        // The agent.ts should have already handled recovery
-                        // Continue to next iteration
-                        continue;
-                    }
-                    // For other errors, check if handled by provider error handler
-                    const handled = this.handleProviderError(error, () => this.processContinuousRequest(initialRequest));
-                    if (!handled) {
-                        display.showError(error instanceof Error ? error.message : String(error), error);
-                        break;
-                    }
-                }
-            }
-            if (iteration >= MAX_ITERATIONS) {
-                display.showWarning(`\n⚠️ Reached maximum iterations (${MAX_ITERATIONS}). Stopping to prevent infinite loop.`);
-            }
-        }
-        finally {
-            this.finishStreamingFormatter(undefined, { refreshPrompt: false, mode: 'complete' });
-            const totalElapsed = Date.now() - overallStartTime;
-            const minutes = Math.floor(totalElapsed / 60000);
-            const seconds = Math.floor((totalElapsed % 60000) / 1000);
-            display.showSystemMessage(`\n🏁 Continuous execution completed: ${iteration} iterations, ${minutes}m ${seconds}s total`);
-            // Reset completion detector for next task
-            resetTaskCompletionDetector();
-            this.uiUpdates.setMode('processing');
-            this.stopStreamingHeartbeat('complete', { quiet: true });
-            this.endAiRuntime();
-            this.isProcessing = false;
-            this.terminalInput.setStreaming(false);
-            this.uiAdapter.endProcessing('Ready for prompts');
-            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
-            this.ensureReadlineReady();
-            this.scheduleQueueProcessing();
-            this.maybeProcessPromptInbox();
-            this.refreshQueueIndicators();
-        }
+When truly finished with ALL tasks, explicitly state "TASK_FULLY_COMPLETE".`
+            : initialRequest;
+        await this.processRequest(preparedRequest, { orchestrate: true, maxPasses: MAX_PASSES });
     }
     /**
      * Resolve executed tools for the current turn. Prefer the actual tool
@@ -6191,6 +6061,129 @@ The previous reply was empty. Resume the task now: take the next action, call th
         }
         return this.extractToolsFromResponse(responseText);
     }
+    /**
+     * Detect plan-only responses that narrate intent without executing actions.
+     */
+    isPlanOnlyResponse(response) {
+        const normalized = response.trim().toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+        // If the assistant is clearly declaring completion, don't treat it as plan-only
+        const completionGuards = [
+            /\bnothing\s+(left|else)\s+(to\s+do|pending)\b/i,
+            /\b(already|now)\s+(clean|complete|done)\b/i,
+            /\b(no\s+(junk|issues?|changes?)\s+found)\b/i,
+        ];
+        if (completionGuards.some((pattern) => pattern.test(response))) {
+            return false;
+        }
+        const planIndicators = [
+            /\bplan\b/i,
+            /\bapproach\b/i,
+            /\bsteps?:\b/i,
+            /\bstep\s+1\b/i,
+            /\bstart by\b/i,
+            /\bfirst[, ]/i,
+            /\bthen\b/i,
+            /\bnext\b/i,
+            /\bi['’]?\s*will\b/i,
+            /\bi['’]?\s*ll\b/i,
+            /\bi['’]?\s*can\b.{0,40}\bthen\b/i,
+            /\bi['’]?\s*(?:will|ll)\s+begin\b/i,
+        ];
+        return planIndicators.some((pattern) => pattern.test(response));
+    }
+    /**
+     * 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".
+     */
+    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;
+            }
+        }
+        return false;
+    }
     /**
      * Extract tool names from a response by looking for tool call patterns
      */