testchimp-runner-core 0.0.43 → 0.0.45

package/dist/scenario-worker-class.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScenarioWorker = void 0;
 const events_1 = require("events");
-const page_info_utils_1 = require("./utils/page-info-utils");
 const browser_utils_1 = require("./utils/browser-utils");
 const llm_facade_1 = require("./llm-facade");
 const script_utils_1 = require("./script-utils");
-const model_constants_1 = require("./model-constants");
 const progress_reporter_1 = require("./progress-reporter");
 const backend_proxy_llm_provider_1 = require("./providers/backend-proxy-llm-provider");
 const orchestrator_1 = require("./orchestrator");
-const MAX_RETRIES_PER_STEP = 3; // 4 total attempts per sub-action: 3 DOM-only, then 1 potential vision attempt
-const MAX_SUBACTIONS_PER_STEP = 5; // Maximum sub-actions to attempt for a single step (reduced from 10 to prevent excessive retries)
-const MAX_FAILED_ATTEMPTS_PER_STEP = 12; // Hard limit on FAILED attempts per step across all sub-actions
 class ScenarioWorker extends events_1.EventEmitter {
     constructor(fileHandler, llmProvider, progressReporter, authConfig, backendUrl, options, outputChannel) {
         super();
         this.initialized = false;
         this.sessionId = null;
-        // Orchestrator mode
-        this.useOrchestrator = false;
         this.debugMode = false;
         // Use provided LLM provider or default to backend proxy (backward compatible)
         const actualLLMProvider = llmProvider || new backend_proxy_llm_provider_1.BackendProxyLLMProvider(authConfig, backendUrl);
@@ -27,13 +20,9 @@ class ScenarioWorker extends events_1.EventEmitter {
         this.fileHandler = fileHandler;
         this.progressReporter = progressReporter;
         this.outputChannel = outputChannel; // Set outputChannel for log routing
-        // Orchestrator setup
-        this.useOrchestrator = options?.useOrchestrator || false;
         this.orchestratorConfig = options?.orchestratorConfig;
         this.debugMode = options?.debugMode || false;
-        if (this.useOrchestrator) {
-            this.initializeOrchestrator();
-        }
+        this.initializeOrchestrator();
     }
     /**
      * Initialize orchestrator mode with tools
@@ -69,12 +58,20 @@ class ScenarioWorker extends events_1.EventEmitter {
         );
         // Minimal initialization logging - internal details not needed by consumer
     }
+    setLogger(logger) {
+        this.logger = logger;
+    }
     log(message) {
         // Let consumer add timestamps - just report the raw message
         const formattedMessage = `[ScenarioWorker] ${message}`;
-        // Always log to console for debug visibility
-        console.log(formattedMessage);
-        // Also route to outputChannel if provided
+        // Use logger if provided, otherwise fall back to console
+        if (this.logger) {
+            this.logger(formattedMessage, 'log');
+        }
+        else {
+            console.log(formattedMessage);
+        }
+        // Also route to outputChannel if provided (for VS Code extension)
         if (this.outputChannel) {
             this.outputChannel.appendLine(formattedMessage);
         }
@@ -82,26 +79,16 @@ class ScenarioWorker extends events_1.EventEmitter {
     logError(message) {
         // Let consumer add timestamps - just report the raw message
         const formattedMessage = `[ScenarioWorker] ERROR: ${message}`;
-        // Always log to console for debug visibility
-        console.error(formattedMessage);
-        // Also route to outputChannel if provided
-        if (this.outputChannel) {
-            this.outputChannel.appendLine(formattedMessage);
+        // Use logger if provided, otherwise fall back to console
+        if (this.logger) {
+            this.logger(formattedMessage, 'error');
         }
-    }
-    /**
-     * Capture screenshot as data URL
-     * Returns data:image/png;base64,... format
-     */
-    async captureStepScreenshot(page) {
-        try {
-            const screenshot = await page.screenshot({ type: 'png' });
-            const base64 = screenshot.toString('base64');
-            return `data:image/png;base64,${base64}`;
+        else {
+            console.error(formattedMessage);
         }
-        catch (error) {
-            this.log(`Failed to capture screenshot: ${error}`);
-            return undefined;
+        // Also route to outputChannel if provided (for VS Code extension)
+        if (this.outputChannel) {
+            this.outputChannel.appendLine(formattedMessage);
         }
     }
     /**
@@ -126,36 +113,6 @@ class ScenarioWorker extends events_1.EventEmitter {
         // Also log for visibility
         this.progressReporter?.log?.(`Job ${progress.jobId}: ${progress.status}`);
     }
-    /**
-     * Detect if a step is complex and benefits from proactive vision usage
-     * Complex steps: form filling, verification, navigation after actions
-     */
-    isComplexStep(stepDescription) {
-        const description = stepDescription.toLowerCase();
-        // Verification steps - often need visual confirmation
-        if (description.includes('verify') || description.includes('check') ||
-            description.includes('confirm') || description.includes('ensure')) {
-            return true;
-        }
-        // Form-related steps - multiple fields, complex interactions
-        if (description.includes('fill') && (description.includes('form') || description.includes('field'))) {
-            return true;
-        }
-        if (description.includes('enter') && description.includes('information')) {
-            return true;
-        }
-        // Steps that typically follow navigation (page may still be loading)
-        if (description.includes('click') && (description.includes('menu') ||
-            description.includes('tab') ||
-            description.includes('link'))) {
-            return true;
-        }
-        // Multi-step actions indicated by "and" or commas
-        if (description.includes(' and ') || description.split(',').length > 1) {
-            return true;
-        }
-        return false;
-    }
     async initialize() {
         try {
             this.sessionId = `scenario_worker_${Date.now()}`;
@@ -250,459 +207,116 @@ class ScenarioWorker extends events_1.EventEmitter {
                 this.log(`📚 Starting with existing learnings: ${screenCount} screens, ${patternCount} UX patterns`);
             }
             // 3a. ORCHESTRATOR MODE - Use orchestrator agent for execution
-            if (this.useOrchestrator && this.orchestratorAgent) {
-                this.log(`🤖 Using Orchestrator Mode (continueOnFailure: ${CONTINUE_ON_FAILURE})`);
-                // Initialize journey memory
-                const memory = {
-                    history: [],
-                    extractedData: {}
-                };
-                // Execute steps using orchestrator
-                for (let i = 0; i < steps.length; i++) {
-                    // Check if job was cancelled by user
-                    if (this.progressReporter?.shouldContinue) {
-                        const shouldContinue = await this.progressReporter.shouldContinue(job.id);
-                        if (!shouldContinue) {
-                            this.log(`🛑 Job ${job.id} cancelled by user - aborting execution`);
-                            overallSuccess = false;
-                            // Mark current and remaining steps as skipped
-                            for (let j = i; j < steps.length; j++) {
-                                steps[j].success = false;
-                                steps[j].error = 'Cancelled by user';
-                                steps[j].playwrightCommands = [];
-                            }
-                            break; // Exit loop
-                        }
-                    }
-                    // Only stop if consecutive failures exceed limit AND continueOnFailure is false
-                    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && !CONTINUE_ON_FAILURE) {
-                        this.log(`🛑 Stopping execution: ${consecutiveFailures} consecutive failures`);
-                        // Mark remaining steps as skipped
+            this.log(`🤖 Using Orchestrator Mode (continueOnFailure: ${CONTINUE_ON_FAILURE})`);
+            // Initialize journey memory
+            const memory = {
+                history: [],
+                extractedData: {}
+            };
+            // Execute steps using orchestrator
+            for (let i = 0; i < steps.length; i++) {
+                // Check if job was cancelled by user
+                if (this.progressReporter?.shouldContinue) {
+                    const shouldContinue = await this.progressReporter.shouldContinue(job.id);
+                    if (!shouldContinue) {
+                        this.log(`🛑 Job ${job.id} cancelled by user - aborting execution`);
+                        overallSuccess = false;
+                        // Mark current and remaining steps as skipped
                         for (let j = i; j < steps.length; j++) {
                             steps[j].success = false;
-                            steps[j].error = `Skipped due to ${consecutiveFailures} consecutive failures`;
+                            steps[j].error = 'Cancelled by user';
                             steps[j].playwrightCommands = [];
                         }
-                        overallSuccess = false;
-                        break;
-                    }
-                    // Warn if approaching limit (even with continueOnFailure)
-                    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && CONTINUE_ON_FAILURE) {
-                        this.log(`⚠️ ${consecutiveFailures} consecutive failures - continuing but scenario may have issues`);
-                    }
-                    const step = steps[i];
-                    step.stepNumber = i + 1;
-                    try {
-                        // LIFECYCLE: Call beforeStepStart if provided
-                        if (this.progressReporter?.beforeStepStart) {
-                            await this.progressReporter.beforeStepStart({
-                                stepNumber: step.stepNumber,
-                                description: step.description
-                            }, page);
-                        }
-                        // Use orchestrator to execute this step
-                        // Pass accumulated site learnings so agent can build upon them
-                        const result = await this.orchestratorAgent.executeStep(page, step.description, step.stepNumber, steps.length, steps.map(s => s.description), memory, job.id, undefined, // priorSteps
-                        undefined, // nextSteps
-                        undefined, // successfulCommandsInStep
-                        undefined, // failingCommand
-                        undefined, // remainingCommandsInStep
-                        siteLearnings // Pass accumulated learnings
-                        );
-                        // Update step with result
-                        step.success = result.success;
-                        step.playwrightCommands = result.commands;
-                        step.error = result.error;
-                        // Merge site learnings from this step
-                        if (result.siteLearnings) {
-                            siteLearnings = this.mergeSiteLearningsSimple(siteLearnings, result.siteLearnings);
-                        }
-                        if (result.success) {
-                            this.log(`✓ Step ${step.stepNumber} completed via orchestrator (${result.iterations} iterations, ${result.commands.length} commands)`);
-                            consecutiveFailures = 0;
-                        }
-                        else {
-                            this.log(`✗ Step ${step.stepNumber} failed via orchestrator: ${result.terminationReason}`);
-                            this.log(`   Reason: ${result.error || 'No error message'}`);
-                            this.log(`   Commands executed: ${result.commands.length}`);
-                            consecutiveFailures++;
-                            overallSuccess = false;
-                            // CRITICAL: Stop on agent_stuck or infeasible (explicit agent decision)
-                            // continueOnStepFailure only applies to command failures, not agent decisions
-                            if (result.terminationReason === 'agent_stuck' || result.terminationReason === 'infeasible') {
-                                this.log(`🛑 Stopping: Agent declared step ${result.terminationReason} - cannot continue`);
-                                // Mark remaining steps as skipped
-                                for (let j = i + 1; j < steps.length; j++) {
-                                    steps[j].success = false;
-                                    steps[j].error = `Skipped: Previous step was ${result.terminationReason}`;
-                                    steps[j].playwrightCommands = [];
-                                }
-                                break; // Exit loop
-                            }
-                        }
-                        // REPORT FINAL STEP RESULT (after orchestrator completes all iterations)
-                        // This gives the complete accumulated commands, not just one iteration
-                        await this.reportStepProgress({
-                            jobId: job.id,
-                            stepNumber: step.stepNumber,
-                            description: step.description,
-                            code: step.playwrightCommands?.join('\n') || '', // All accumulated commands
-                            status: step.success ? progress_reporter_1.StepExecutionStatus.SUCCESS : progress_reporter_1.StepExecutionStatus.FAILURE,
-                            error: step.error,
-                            agentIteration: result.iterations
-                        });
-                    }
-                    catch (error) {
-                        this.logError(`Orchestrator execution failed for step ${step.stepNumber}: ${error.message}`);
-                        step.success = false;
-                        step.error = error.message;
-                        consecutiveFailures++;
-                        overallSuccess = false;
+                        break; // Exit loop
                     }
-                    previousSteps.push(step);
                 }
-            }
-            else {
-                // 3b. LEGACY MODE - Use existing retry loop
-                // Execute each step (steps may require multiple commands)
-                for (let i = 0; i < steps.length; i++) {
-                    // Check if we should stop execution due to consecutive failures
-                    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-                        this.log(`🛑 Stopping execution: ${consecutiveFailures} consecutive failures detected`);
-                        this.log(`   Remaining ${steps.length - i} steps will be skipped to avoid wasting resources`);
-                        // Emit log events about early termination
-                        this.emit('log', job.id, `\n🛑 EARLY TERMINATION\n`);
-                        this.emit('log', job.id, `Reason: ${consecutiveFailures} consecutive step failures\n`);
-                        this.emit('log', job.id, `Steps attempted: ${i}\n`);
-                        this.emit('log', job.id, `Steps skipped: ${steps.length - i}\n\n`);
-                        // Mark remaining steps as skipped
-                        for (let j = i; j < steps.length; j++) {
-                            const skippedStep = steps[j];
-                            skippedStep.stepNumber = j + 1;
-                            skippedStep.success = false;
-                            skippedStep.error = `Skipped due to ${consecutiveFailures} consecutive failures in previous steps`;
-                            skippedStep.playwrightCommands = [];
-                            previousSteps.push(skippedStep);
-                        }
-                        overallSuccess = false;
-                        break; // Exit the loop
+                // Only stop if consecutive failures exceed limit AND continueOnFailure is false
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && !CONTINUE_ON_FAILURE) {
+                    this.log(`🛑 Stopping execution: ${consecutiveFailures} consecutive failures`);
+                    // Mark remaining steps as skipped
+                    for (let j = i; j < steps.length; j++) {
+                        steps[j].success = false;
+                        steps[j].error = `Skipped due to ${consecutiveFailures} consecutive failures`;
+                        steps[j].playwrightCommands = [];
                     }
-                    const step = steps[i];
-                    step.stepNumber = i + 1;
-                    step.retryCount = 0;
-                    step.subActions = [];
-                    // Force new array and clear any previous command data
-                    step.playwrightCommands = [];
-                    step.playwrightCommand = undefined;
-                    let stepSuccess = false;
-                    let stepError;
-                    let subActionCount = 0;
-                    let stepComplete = false;
-                    let totalFailedAttemptsForStep = 0; // Track FAILED attempts across all sub-actions
-                    // Detect if this is a complex step that benefits from proactive vision
-                    const isComplexStep = this.isComplexStep(step.description);
-                    // A step might need multiple commands (sub-actions) to complete
-                    while (!stepComplete && subActionCount < MAX_SUBACTIONS_PER_STEP && totalFailedAttemptsForStep < MAX_FAILED_ATTEMPTS_PER_STEP) {
-                        let subActionSuccess = false;
-                        let subActionCommand;
-                        let subActionError;
-                        let subActionRetries = 0;
-                        let usedVisionMode = false;
-                        // Build context about what's been done so far in this step
-                        const stepContext = step.subActions && step.subActions.length > 0
-                            ? `\nSub-actions completed so far for this step:\n${step.subActions.map((sa, idx) => `  ${idx + 1}. ${sa.command} - ${sa.success ? 'SUCCESS' : 'FAILED'}`).join('\n')}`
-                            : '';
-                        for (let attempt = 0; attempt <= MAX_RETRIES_PER_STEP; attempt++) {
-                            // Check if we've exceeded failed attempts budget BEFORE attempting
-                            if (totalFailedAttemptsForStep >= MAX_FAILED_ATTEMPTS_PER_STEP) {
-                                this.log(`  ⚠️ Exceeded failed attempts budget (${MAX_FAILED_ATTEMPTS_PER_STEP}) for this step`);
-                                stepComplete = true;
-                                stepSuccess = false;
-                                stepError = `Exceeded maximum failed attempts (${MAX_FAILED_ATTEMPTS_PER_STEP}) for step`;
-                                break;
-                            }
-                            let currentAttemptCommand;
-                            let currentAttemptSuccess = false;
-                            let currentAttemptError;
-                            const attemptTimestamp = Date.now();
-                            try {
-                                this.log(`Step ${step.stepNumber} - Sub-action ${subActionCount + 1}, Attempt ${attempt + 1}: ${step.description}`);
-                                // Get current page state - handle navigation in progress
-                                let domSnapshot;
-                                let pageInfo;
-                                try {
-                                    domSnapshot = {
-                                        url: page.url(),
-                                        title: await page.title(),
-                                        accessibilityTree: await page.accessibility.snapshot()
-                                    };
-                                    pageInfo = await (0, page_info_utils_1.getEnhancedPageInfo)(domSnapshot);
-                                }
-                                catch (contextError) {
-                                    // If execution context was destroyed (navigation in progress), wait and retry
-                                    if (contextError.message && contextError.message.includes('Execution context was destroyed')) {
-                                        this.log(`  ⏳ Navigation in progress, waiting for page to load...`);
-                                        await page.waitForLoadState('domcontentloaded', { timeout: 5000 }).catch(() => { });
-                                        // Retry page state capture
-                                        domSnapshot = {
-                                            url: page.url(),
-                                            title: await page.title(),
-                                            accessibilityTree: await page.accessibility.snapshot()
-                                        };
-                                        pageInfo = await (0, page_info_utils_1.getEnhancedPageInfo)(domSnapshot);
-                                    }
-                                    else {
-                                        throw contextError; // Re-throw if it's not a navigation issue
-                                    }
-                                }
-                                // Vision trigger: Liberal usage since gpt-5-mini vision is cost-effective
-                                const modelToUse = job.model || model_constants_1.DEFAULT_MODEL;
-                                let command;
-                                // Enhanced logging for vision trigger logic
-                                this.log(`  🔍 Vision trigger check: subAction=${subActionCount + 1}, attempt=${attempt}, totalFailed=${totalFailedAttemptsForStep}, usedVision=${usedVisionMode}`);
-                                // Liberal vision strategy (gpt-5-mini is cost-effective):
-                                // 1. After ANY failure (1+) → use vision
-                                // 2. Complex steps → use vision from attempt 1
-                                // 3. No LLM assessment gate → go directly to vision
-                                const hasFailure = totalFailedAttemptsForStep >= 1 && lastError;
-                                const shouldUseProactiveVision = isComplexStep && attempt === 0; // First attempt for complex steps
-                                const shouldUseVision = (hasFailure || shouldUseProactiveVision) && !usedVisionMode;
-                                if (shouldUseVision) {
-                                    if (shouldUseProactiveVision) {
-                                        this.log(`  🎯 PROACTIVE VISION: Complex step detected, using vision from first attempt`);
-                                    }
-                                    else {
-                                        this.log(`  🎯 VISION TRIGGER: ${totalFailedAttemptsForStep} failure(s) detected, using vision (no LLM gate)`);
-                                    }
-                                    // Two-step supervisor pattern:
-                                    // 1. Supervisor analyzes screenshot and provides instructions
-                                    // 2. Worker generates command based on those instructions
-                                    this.log(`  📸 Taking screenshot for supervisor analysis...`);
-                                    // Capture optimized screenshot using utility method
-                                    const imageDataUrl = await (0, browser_utils_1.captureOptimizedScreenshot)(page, { timeout: 10000 }, // Uses default quality 60
-                                    (msg) => this.log(msg));
-                                    this.log(`  👔 STEP 1: Supervisor analyzing screenshot (${model_constants_1.VISION_MODEL})...`);
-                                    const supervisorDiagnostics = await this.llmFacade.getVisionDiagnostics(step.description + stepContext, pageInfo, previousSteps, lastError, imageDataUrl, model_constants_1.VISION_MODEL);
-                                    // DEBUG: Log vision diagnostics
-                                    this.log(`  📸 Visual insights: ${supervisorDiagnostics.visualAnalysis}`);
-                                    this.log(`  🔍 Root cause: ${supervisorDiagnostics.rootCause}`);
-                                    this.log(`  💡 Recommended approach: ${supervisorDiagnostics.recommendedApproach}`);
-                                    if (supervisorDiagnostics.elementsFound.length > 0) {
-                                        this.log(`  ✅ Elements found: ${supervisorDiagnostics.elementsFound.join(', ')}`);
-                                    }
-                                    if (supervisorDiagnostics.elementsNotFound.length > 0) {
-                                        this.log(`  ❌ Elements not found: ${supervisorDiagnostics.elementsNotFound.join(', ')}`);
-                                    }
-                                    this.log(`  🔨 STEP 2: Worker generating command from supervisor instructions (${model_constants_1.DEFAULT_MODEL})...`);
-                                    command = await this.llmFacade.generateCommandFromSupervisorInstructions(step.description + stepContext, supervisorDiagnostics, pageInfo, modelToUse // Cheaper model for command generation
-                                    );
-                                    usedVisionMode = true;
-                                }
-                                else {
-                                    // Not using vision - use regular DOM-based approach
-                                    if (usedVisionMode) {
-                                        this.log(`  📝 Vision already used - using DOM-based approach`);
-                                    }
-                                    else if (isComplexStep) {
-                                        this.log(`  📝 Complex step, but first attempt - using DOM-based approach (vision on retry)`);
-                                    }
-                                    else {
-                                        this.log(`  📝 Using DOM-based approach (${totalFailedAttemptsForStep} failures so far)`);
-                                    }
-                                    const stepDescriptionWithContext = step.description + stepContext;
-                                    command = await this.llmFacade.generatePlaywrightCommand(stepDescriptionWithContext, pageInfo, previousSteps, lastError, step, modelToUse);
-                                }
-                                if (!command) {
-                                    throw new Error('LLM failed to generate a Playwright command.');
-                                }
-                                currentAttemptCommand = command;
-                                this.log(`  Command: ${command}`);
-                                // Execute the command
-                                await this.executePlaywrightCommand(page, browser, context, command);
-                                // Success
-                                subActionSuccess = true;
-                                currentAttemptSuccess = true;
-                                subActionCommand = command;
-                                step.playwrightCommands.push(command);
-                                this.log(`  ✅ SUCCESS: ${command}${usedVisionMode ? ' (vision-aided)' : ''}`);
-                                // Wait a bit for any navigation that might have been triggered
-                                // This prevents "Execution context destroyed" errors when checking goal completion
-                                await page.waitForLoadState('domcontentloaded', { timeout: 3000 }).catch(() => {
-                                    // Ignore timeout - page might not be navigating
-                                });
-                                break; // Sub-action successful, check if step is complete
-                            }
-                            catch (error) {
-                                subActionError = error instanceof Error ? error.message : String(error);
-                                currentAttemptError = subActionError;
-                                // Get current URL for context (especially useful for navigation failures)
-                                let currentUrl = 'unknown';
-                                try {
-                                    currentUrl = page.url();
-                                }
-                                catch (e) {
-                                    // Ignore if we can't get URL
-                                }
-                                // Enhanced error message with current URL
-                                const errorWithContext = `${subActionError} | Current URL: ${currentUrl}`;
-                                this.logError(`  ❌ FAILED (attempt ${attempt + 1}): ${subActionError}`);
-                                this.logError(`  Current URL: ${currentUrl}`);
-                                this.logError(`  Command attempted: ${currentAttemptCommand || 'N/A'}`);
-                                subActionRetries++;
-                                totalFailedAttemptsForStep++; // Increment failed attempts counter
-                                // Only update lastError if this is the final attempt
-                                if (attempt === MAX_RETRIES_PER_STEP) {
-                                    lastError = errorWithContext; // Include URL in error context for LLM
-                                }
-                                // If this is the last attempt, mark sub-action as failed
-                                if (attempt === MAX_RETRIES_PER_STEP) {
-                                    subActionSuccess = false;
-                                    subActionCommand = currentAttemptCommand;
-                                    this.logError(`  🚫 SUB-ACTION FAILED after ${MAX_RETRIES_PER_STEP + 1} attempts (including vision mode if used)`);
-                                    break; // Exit retry loop
-                                }
-                            }
-                            finally {
-                                if (!step.attempts) {
-                                    step.attempts = [];
-                                }
-                                step.attempts.push({
-                                    attemptNumber: attempt + 1,
-                                    command: currentAttemptCommand,
-                                    success: currentAttemptSuccess,
-                                    error: currentAttemptError,
-                                    timestamp: attemptTimestamp
-                                });
-                            }
-                        }
-                        // Record the sub-action
-                        if (subActionCommand) {
-                            step.subActions.push({
-                                command: subActionCommand,
-                                success: subActionSuccess,
-                                error: subActionError,
-                                retryCount: subActionRetries
-                            });
-                        }
-                        subActionCount++;
-                        // Determine if step (goal) is complete
-                        if (subActionSuccess) {
-                            // After each successful sub-action, ask LLM if goal is complete
-                            if (subActionCount >= MAX_SUBACTIONS_PER_STEP) {
-                                // Safety limit - avoid infinite loops
-                                stepComplete = true;
-                                stepSuccess = true;
-                                this.log(`  ⚠️ Reached max sub-actions limit (${MAX_SUBACTIONS_PER_STEP}) with ${totalFailedAttemptsForStep} failed attempts, considering step complete`);
-                            }
-                            else {
-                                // Ask LLM if goal is complete
-                                try {
-                                    // Capture page state - if navigation is still happening, retry once
-                                    let domSnapshot;
-                                    let pageInfo;
-                                    try {
-                                        domSnapshot = {
-                                            url: page.url(),
-                                            title: await page.title(),
-                                            accessibilityTree: await page.accessibility.snapshot()
-                                        };
-                                        pageInfo = await (0, page_info_utils_1.getEnhancedPageInfo)(domSnapshot);
-                                    }
-                                    catch (contextError) {
-                                        // If execution context was destroyed (navigation in progress), wait and retry
-                                        if (contextError.message && contextError.message.includes('Execution context was destroyed')) {
-                                            this.log(`  ⏳ Navigation detected, waiting for page to load...`);
-                                            await page.waitForLoadState('domcontentloaded', { timeout: 5000 }).catch(() => { });
-                                            // Retry page state capture
-                                            domSnapshot = {
-                                                url: page.url(),
-                                                title: await page.title(),
-                                                accessibilityTree: await page.accessibility.snapshot()
-                                            };
-                                            pageInfo = await (0, page_info_utils_1.getEnhancedPageInfo)(domSnapshot);
-                                        }
-                                        else {
-                                            throw contextError; // Re-throw if it's not a navigation issue
-                                        }
-                                    }
-                                    // Vision-backed goal completion for complex/verification steps
-                                    const shouldUseVisionForCompletion = isComplexStep && subActionCount >= 1; // At least one action done
-                                    let completionCheck;
-                                    if (shouldUseVisionForCompletion) {
-                                        this.log(`  🎯 Vision-backed goal completion check (complex step)`);
-                                        // Capture screenshot for visual verification
-                                        const imageDataUrl = await (0, browser_utils_1.captureOptimizedScreenshot)(page, { timeout: 10000 }, (msg) => this.log(msg));
-                                        // Use vision model to check goal completion with visual context
-                                        completionCheck = await this.llmFacade.checkGoalCompletionWithVision(step.description, step.playwrightCommands || [], pageInfo, imageDataUrl, model_constants_1.VISION_MODEL);
-                                    }
-                                    else {
-                                        // Regular DOM-based goal completion check
-                                        completionCheck = await this.llmFacade.checkGoalCompletion(step.description, step.playwrightCommands || [], pageInfo, job.model || model_constants_1.DEFAULT_MODEL);
-                                    }
-                                    this.log(`  🎯 Goal completion check: ${completionCheck.isComplete ? 'COMPLETE' : 'INCOMPLETE'} - ${completionCheck.reason}`);
-                                    if (completionCheck.isComplete) {
-                                        stepComplete = true;
-                                        stepSuccess = true;
-                                    }
-                                    else {
-                                        // Continue with next sub-action
-                                        if (completionCheck.nextSubGoal) {
-                                            this.log(`  📍 Next sub-goal: ${completionCheck.nextSubGoal}`);
-                                        }
-                                        // Continue looping to generate next command
-                                    }
-                                }
-                                catch (error) {
-                                    this.logError(`Error checking goal completion: ${error}`);
-                                    // Fallback: consider complete after 1 successful sub-action if we can't check
-                                    stepComplete = true;
-                                    stepSuccess = true;
-                                }
-                            }
-                        }
-                        else {
-                            // Sub-action failed
-                            stepComplete = true; // Move on after failure
-                            stepSuccess = false;
-                            stepError = subActionError;
-                            overallSuccess = false;
-                        }
+                    overallSuccess = false;
+                    break;
+                }
+                // Warn if approaching limit (even with continueOnFailure)
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && CONTINUE_ON_FAILURE) {
+                    this.log(`⚠️ ${consecutiveFailures} consecutive failures - continuing but scenario may have issues`);
+                }
+                const step = steps[i];
+                step.stepNumber = i + 1;
+                try {
+                    // LIFECYCLE: Call beforeStepStart if provided
+                    if (this.progressReporter?.beforeStepStart) {
+                        await this.progressReporter.beforeStepStart({
+                            stepNumber: step.stepNumber,
+                            description: step.description
+                        }, page);
                     }
-                    // Set the step's final command (last successful or aggregate)
-                    if (step.playwrightCommands && step.playwrightCommands.length > 0) {
-                        step.playwrightCommand = step.playwrightCommands[step.playwrightCommands.length - 1];
+                    // Use orchestrator to execute this step
+                    // Pass accumulated site learnings so agent can build upon them
+                    const result = await this.orchestratorAgent.executeStep(page, step.description, step.stepNumber, steps.length, steps.map(s => s.description), memory, job.id, undefined, // priorSteps
+                    undefined, // nextSteps
+                    undefined, // successfulCommandsInStep
+                    undefined, // failingCommand
+                    undefined, // remainingCommandsInStep
+                    siteLearnings // Pass accumulated learnings
+                    );
+                    // Update step with result
+                    step.success = result.success;
+                    step.playwrightCommands = result.commands;
+                    step.error = result.error;
+                    // Merge site learnings from this step
+                    if (result.siteLearnings) {
+                        siteLearnings = this.mergeSiteLearningsSimple(siteLearnings, result.siteLearnings);
                     }
-                    step.success = stepSuccess;
-                    step.error = stepError;
-                    previousSteps.push(step);
-                    // Update consecutive failure counter
-                    if (stepSuccess) {
-                        consecutiveFailures = 0; // Reset on success
+                    if (result.success) {
+                        this.log(`✓ Step ${step.stepNumber} completed via orchestrator (${result.iterations} iterations, ${result.commands.length} commands)`);
+                        consecutiveFailures = 0;
                     }
                     else {
+                        this.log(`✗ Step ${step.stepNumber} failed via orchestrator: ${result.terminationReason}`);
+                        this.log(`   Reason: ${result.error || 'No error message'}`);
+                        this.log(`   Commands executed: ${result.commands.length}`);
                         consecutiveFailures++;
-                        this.log(`⚠️ Consecutive failures: ${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}`);
-                    }
-                    // Emit step result log events
-                    this.emit('log', job.id, `### Step ${step.stepNumber}: ${step.description}\n`);
-                    this.emit('log', job.id, `Status: ${stepSuccess ? '✅ SUCCESS' : '❌ FAILED'}\n`);
-                    this.emit('log', job.id, `Sub-actions: ${subActionCount}\n`);
-                    this.emit('log', job.id, `Failed attempts: ${totalFailedAttemptsForStep}\n`);
-                    if (step.playwrightCommands && step.playwrightCommands.length > 0) {
-                        this.emit('log', job.id, `Commands:\n`);
-                        step.playwrightCommands.forEach((cmd, idx) => {
-                            this.emit('log', job.id, `  ${idx + 1}. ${cmd}\n`);
-                        });
-                    }
-                    if (stepError) {
-                        this.emit('log', job.id, `Error: ${stepError}\n`);
-                    }
-                    if (step.attempts && step.attempts.length > 0) {
-                        this.emit('log', job.id, `Total attempts: ${step.attempts.length}\n`);
+                        overallSuccess = false;
+                        // CRITICAL: Stop on agent_stuck or infeasible (explicit agent decision)
+                        // continueOnStepFailure only applies to command failures, not agent decisions
+                        if (result.terminationReason === 'agent_stuck' || result.terminationReason === 'infeasible') {
+                            this.log(`🛑 Stopping: Agent declared step ${result.terminationReason} - cannot continue`);
+                            // Mark remaining steps as skipped
+                            for (let j = i + 1; j < steps.length; j++) {
+                                steps[j].success = false;
+                                steps[j].error = `Skipped: Previous step was ${result.terminationReason}`;
+                                steps[j].playwrightCommands = [];
+                            }
+                            break; // Exit loop
+                        }
                     }
-                    this.emit('log', job.id, `\n`);
+                    // REPORT FINAL STEP RESULT (after orchestrator completes all iterations)
+                    // This gives the complete accumulated commands, not just one iteration
+                    await this.reportStepProgress({
+                        jobId: job.id,
+                        stepNumber: step.stepNumber,
+                        description: step.description,
+                        code: step.playwrightCommands?.join('\n') || '', // All accumulated commands
+                        status: step.success ? progress_reporter_1.StepExecutionStatus.SUCCESS : progress_reporter_1.StepExecutionStatus.FAILURE,
+                        error: step.error,
+                        agentIteration: result.iterations
+                    });
+                }
+                catch (error) {
+                    this.logError(`Orchestrator execution failed for step ${step.stepNumber}: ${error.message}`);
+                    step.success = false;
+                    step.error = error.message;
+                    consecutiveFailures++;
+                    overallSuccess = false;
                 }
-            } // End of else block (legacy mode)
+                previousSteps.push(step);
+            }
             // Generate test name if not provided
             const testName = job.testName || await this.llmFacade.generateTestName(job.scenario, job.model);
             // Generate hashtags for semantic grouping
@@ -848,7 +462,7 @@ class ScenarioWorker extends events_1.EventEmitter {
                 executionTime: Date.now() - startTime,
                 testName,
                 preferredFileName,
-                siteLearnings: this.useOrchestrator ? siteLearnings : undefined
+                siteLearnings: siteLearnings // Orchestrator always enabled - always return learnings
             };
         }
         catch (error) {
@@ -877,8 +491,8 @@ class ScenarioWorker extends events_1.EventEmitter {
             // LIFECYCLE: Call afterEndTest if provided
             if (browser && this.progressReporter?.afterEndTest) {
                 try {
-                    await this.progressReporter.afterEndTest(overallSuccess ? 'passed' : 'failed', overallSuccess ? undefined : 'Test execution had failures', page, this.useOrchestrator ? siteLearnings : undefined, // Pass siteLearnings here
-                    this.useOrchestrator && this.orchestratorAgent ? this.orchestratorAgent.getDebugStats() : undefined // Pass debugStats here
+                    await this.progressReporter.afterEndTest(overallSuccess ? 'passed' : 'failed', overallSuccess ? undefined : 'Test execution had failures', page, siteLearnings ?? undefined, // Pass siteLearnings here
+                    this.orchestratorAgent.getDebugStats() ?? undefined // Pass debugStats here
                     );
                 }
                 catch (callbackError) {
@@ -892,31 +506,6 @@ class ScenarioWorker extends events_1.EventEmitter {
             }
         }
     }
-    async executePlaywrightCommand(page, browser, context, command) {
-        // Detect if command contains navigation or load state operations that need longer timeout
-        const needsLongerTimeout = command.includes('waitForLoadState') ||
-            command.includes('goto(') ||
-            command.includes('waitForURL') ||
-            command.includes('waitForNavigation');
-        // Use appropriate timeout based on operation type
-        const timeout = needsLongerTimeout ? 30000 : 5000;
-        page.setDefaultTimeout(timeout);
-        try {
-            // Execute command directly without validation
-            const commandFunction = new Function('page', 'browser', 'context', 'expect', `
-        return (async () => {
-          ${command}
-        })();
-      `);
-            // Dynamically import expect
-            const { expect } = require('@playwright/test');
-            await commandFunction(page, browser, context, expect);
-        }
-        finally {
-            // Reset to default timeout for element operations
-            page.setDefaultTimeout(5000);
-        }
-    }
     /**
      * Simple merge of site learnings (accumulate across steps)
      */
@@ -955,9 +544,6 @@ class ScenarioWorker extends events_1.EventEmitter {
      * Execute exploration mode using orchestrator
      */
     async executeExploration(page, explorationConfig, jobId, existingSiteLearnings) {
-        if (!this.useOrchestrator || !this.orchestratorAgent) {
-            throw new Error('Orchestrator not available - exploration mode requires orchestrator');
-        }
         // Execute exploration via orchestrator
         return this.orchestratorAgent.executeExploration(page, explorationConfig, jobId, existingSiteLearnings);
     }