testchimp-runner-core 0.0.78 → 0.0.80

package/dist/execution-service.js

@@ -358,26 +358,33 @@ class PersistentExecutionContext {
 /**
  * Helper function to resolve file paths relative to tempDir
  * Relative paths are resolved to tempDir, absolute paths are unchanged
+ * Uses path.resolve() to properly handle ../ and ./ in relative paths
  */
 function resolveFilePaths(tempDir, files) {
     if (typeof files === "string") {
-        return path.isAbsolute(files) ? files : path.join(tempDir, files);
+        return path.isAbsolute(files) ? files : path.resolve(tempDir, files);
     }
     else if (Array.isArray(files)) {
-        return files.map(file => typeof file === "string" && !path.isAbsolute(file) ? path.join(tempDir, file) : file);
+        return files.map(file => typeof file === "string" && !path.isAbsolute(file) ? path.resolve(tempDir, file) : file);
     }
     return files;
 }
 /**
  * Apply file upload overrides to a page object
- * Overrides setInputFiles to resolve relative paths using tempDir
+ * Overrides setInputFiles to resolve relative paths using the test file's directory
  */
-function applyFileUploadOverrides(page, tempDir) {
+function applyFileUploadOverrides(page, tempDir, testFolderPath, log) {
+    // Use test folder path from DB (e.g., ["tests", "e2e"]) to construct test file directory
+    // This ensures paths like "../fixtures/file.pdf" resolve correctly regardless of test nesting
+    const testFileDir = testFolderPath && testFolderPath.length > 0
+        ? path.join(tempDir, ...testFolderPath)
+        : path.join(tempDir, 'tests'); // Fallback if not provided
+    log(`Using test file directory for file path resolution: ${testFileDir}`);
     const originalSetInputFiles = page.setInputFiles.bind(page);
     const originalLocator = page.locator.bind(page);
     // Override page.setInputFiles
     page.setInputFiles = async (selector, files, options) => {
-        const resolvedFiles = resolveFilePaths(tempDir, files);
+        const resolvedFiles = resolveFilePaths(testFileDir, files);
         return originalSetInputFiles(selector, resolvedFiles, options);
     };
     // Override page.locator to modify only setInputFiles
@@ -386,7 +393,7 @@ function applyFileUploadOverrides(page, tempDir) {
         const originalLocatorSetInputFiles = locator.setInputFiles.bind(locator);
         // Override only setInputFiles
         locator.setInputFiles = async (files, options) => {
-            const resolvedFiles = resolveFilePaths(tempDir, files);
+            const resolvedFiles = resolveFilePaths(testFileDir, files);
             return originalLocatorSetInputFiles(resolvedFiles, options);
         };
         return locator;
@@ -865,41 +872,39 @@ class ExecutionService {
                 this.log(`Warning: Failed to execute imports: ${importError.message}`, 'warn');
                 // Continue execution - some imports might not be needed
             }
-            // Extract and execute initialization code from the test script
-            // This includes code like: const signInPage = new SignInPage(page);
-            // We execute this using the same mechanism as steps (persistentContext.executeCode)
-            // But we need to transform const/let to assignments so variables are available in context
-            if (options.originalScript) {
-                try {
-                    this.log('Extracting initialization code from test script...');
-                    const initializationCode = initialization_code_utils_1.InitializationCodeUtils.extractInitializationCode(options.originalScript, (msg, level) => this.log(msg, level));
-                    if (initializationCode) {
-                        this.log(`Executing initialization code: ${initializationCode.substring(0, 100)}...`);
-                        // Transform const/let declarations to assignments so they create properties on context
-                        // This is necessary because const/let create block-scoped variables, not context properties
-                        const { transformedCode } = initialization_code_utils_1.InitializationCodeUtils.transformInitializationCode(initializationCode, (msg, level) => this.log(msg, level));
-                        // Execute using the same mechanism as steps
-                        // This ensures consistent behavior and module resolution
-                        await persistentContext.executeCode(transformedCode);
-                        this.log('Initialization code executed successfully');
-                    }
-                    else {
-                        this.log('No initialization code found in test script');
-                    }
-                }
-                catch (initError) {
-                    this.log(`Warning: Failed to execute initialization code: ${initError.message}`, 'warn');
-                    // Continue execution - initialization might not be needed
-                }
-            }
         }
-        this.log(`Executing ${steps.length} steps in persistent context (mode: ${options.mode})`);
-        // Track executed step descriptions for repair context
+        // Extract ALL statements from test body using AST
+        // This replaces separate initialization extraction and LLM-based step parsing
+        let allStatements = [];
+        // Option 1: Use pre-parsed steps (for backward compatibility with consumers like journey-runner)
+        if (steps && steps.length > 0) {
+            this.log(`Using ${steps.length} pre-parsed steps from consumer`);
+            allStatements = steps.map(step => ({
+                code: step.code,
+                isVariableDeclaration: false, // Pre-parsed steps are assumed to be already filtered
+                intentComment: step.description !== step.code ? step.description : undefined,
+                screenStateAnnotation: undefined // Will be in description for pre-parsed steps
+            }));
+        }
+        // Option 2: Extract from script using AST
+        else if (options.originalScript) {
+            this.log('Extracting all statements from test script using AST...');
+            allStatements = initialization_code_utils_1.InitializationCodeUtils.extractAllStatements(options.originalScript, (msg, level) => this.log(msg, level));
+            this.log(`Extracted ${allStatements.length} statements from test body`);
+        }
+        // Option 3: No input provided
+        else {
+            this.log('No script or steps provided, cannot execute', 'error');
+            persistentContext.dispose();
+            return { success: false, error: 'No script or steps provided for execution' };
+        }
+        // Execute all statements sequentially
+        // Variable declarations execute silently, other statements trigger callbacks
+        let stepNumber = 0; // Track step number (excludes variables)
         const executedStepDescriptions = [];
-        const updatedSteps = [...steps]; // Copy for modifications
-        let i = 0;
-        while (i < updatedSteps.length) {
-            const step = updatedSteps[i];
+        for (let i = 0; i < allStatements.length; i++) {
+            const stmt = allStatements[i];
+            const isVariable = stmt.isVariableDeclaration;
             // Check cancellation
             if (this.progressReporter?.shouldContinue && options.jobId) {
                 const shouldContinue = await this.progressReporter.shouldContinue(options.jobId);
@@ -909,101 +914,129 @@ class ExecutionService {
                     return { success: false, failedStepIndex: i, error: 'Cancelled by user' };
                 }
             }
-            this.log(`Step ${i + 1}/${updatedSteps.length}: ${step.description}`);
-            // LIFECYCLE: beforeStepStart
-            if (this.progressReporter?.beforeStepStart) {
-                await this.progressReporter.beforeStepStart({
-                    stepId: step.id,
-                    stepNumber: i + 1,
-                    description: step.description,
-                    code: step.code
-                }, page);
+            // Transform const/let to assignments for variables (so they persist in context)
+            let codeToExecute = stmt.code;
+            if (isVariable) {
+                // Use AST transformation (no regex)
+                const transformed = initialization_code_utils_1.InitializationCodeUtils.transformInitializationCode(stmt.code, (msg, level) => this.log(msg, level));
+                codeToExecute = transformed.transformedCode;
+            }
+            // Increment step number for non-variables (before execution)
+            if (!isVariable) {
+                stepNumber++;
+                // LIFECYCLE: beforeStepStart (call before execution)
+                if (this.progressReporter?.beforeStepStart && options.jobId) {
+                    const description = stmt.intentComment || stmt.code;
+                    await this.progressReporter.beforeStepStart({
+                        stepId: `step-${stepNumber}`,
+                        stepNumber,
+                        description,
+                        code: stmt.code
+                    }, page);
+                }
             }
             try {
-                // Execute step in persistent context
-                // ai-wright will automatically extend timeout via test.setTimeout() when ai.act/verify/extract is called
-                await persistentContext.executeCode(step.code);
-                this.log(`  ✓ Step ${i + 1} succeeded`);
-                // Mark step as successful
-                // Ensure we're updating the step in the array (important after repair when new object was created)
-                updatedSteps[i].success = true;
-                // Ensure code is preserved in array (defensive - step is a reference but be explicit after repair)
-                if (step.code && step.code.trim().length > 0) {
-                    updatedSteps[i].code = step.code;
+                // Execute ALL statements (variables + actions)
+                await persistentContext.executeCode(codeToExecute);
+                // Only report non-variable statements as steps
+                if (!isVariable) {
+                    const description = stmt.intentComment || stmt.code;
+                    this.log(`  ✓ Step ${stepNumber} succeeded: ${description}`);
+                    executedStepDescriptions.push(description);
+                    // LIFECYCLE: onStepProgress (success)
+                    if (this.progressReporter?.onStepProgress && options.jobId) {
+                        await this.progressReporter.onStepProgress({
+                            jobId: options.jobId,
+                            stepId: `step-${stepNumber}`,
+                            stepNumber,
+                            description,
+                            code: stmt.code,
+                            screenStateAnnotation: stmt.screenStateAnnotation,
+                            status: 'SUCCESS_STEP_EXECUTION',
+                            wasRepaired: false
+                        });
+                    }
                 }
-                // Track executed step for repair context
-                executedStepDescriptions.push(step.description);
-                // LIFECYCLE: onStepComplete (success)
-                if (this.progressReporter?.onStepProgress && options.jobId) {
-                    await this.progressReporter.onStepProgress({
-                        jobId: options.jobId,
-                        stepId: step.id,
-                        stepNumber: i + 1,
-                        description: step.description,
-                        code: step.code,
-                        status: 'SUCCESS_STEP_EXECUTION',
-                        wasRepaired: false
-                    });
+                else {
+                    this.log(`  Executed variable declaration (no callback): ${stmt.code}`);
                 }
-                i++; // Move to next step
             }
             catch (error) {
                 const errorMsg = error.message || String(error);
-                this.log(`  ✗ Step ${i + 1} failed: ${errorMsg}`);
-                // LIFECYCLE: onStepComplete (failure)
-                if (this.progressReporter?.onStepProgress && options.jobId) {
-                    await this.progressReporter.onStepProgress({
-                        jobId: options.jobId,
-                        stepId: step.id,
-                        stepNumber: i + 1,
-                        description: step.description,
-                        code: step.code,
-                        status: 'FAILURE_STEP_EXECUTION',
-                        error: errorMsg,
-                        wasRepaired: false
-                    });
+                // Report failure
+                if (!isVariable) {
+                    // stepNumber already incremented in beforeStepStart
+                    const description = stmt.intentComment || stmt.code;
+                    this.log(`  ✗ Step ${stepNumber} failed: ${errorMsg}`);
+                    // LIFECYCLE: onStepProgress (failure)
+                    if (this.progressReporter?.onStepProgress && options.jobId) {
+                        await this.progressReporter.onStepProgress({
+                            jobId: options.jobId,
+                            stepId: `step-${stepNumber}`,
+                            stepNumber,
+                            description,
+                            code: stmt.code,
+                            screenStateAnnotation: stmt.screenStateAnnotation,
+                            status: 'FAILURE_STEP_EXECUTION',
+                            error: errorMsg,
+                            wasRepaired: false
+                        });
+                    }
+                }
+                else {
+                    this.log(`  ✗ Variable declaration failed: ${stmt.code} - ${errorMsg}`);
                 }
                 // Mode-specific error handling
                 if (options.mode === 'RUN_EXACTLY') {
-                    // Stop execution
+                    // Stop execution on first failure
                     persistentContext.dispose();
                     return { success: false, failedStepIndex: i, error: errorMsg };
                 }
                 else {
-                    // RUN_WITH_AI_REPAIR: Attempt repair
-                    const repairSuccess = await this.attemptStepRepair(i, step, updatedSteps, executedStepDescriptions, page, persistentContext, options.jobId || '', options.model || 'gpt-4o-mini');
-                    if (repairSuccess) {
-                        // Repair succeeded - orchestrator already executed the commands, so step is done
-                        // Check if step was marked as successful during repair (orchestrator executed it)
-                        if (updatedSteps[i] && updatedSteps[i].success) {
-                            // Step was already executed by orchestrator during repair, move to next step
-                            this.log(`  ✓ Step ${i + 1} already executed during repair, moving to next step`);
-                            i++;
-                            continue;
+                    // RUN_WITH_AI_REPAIR: Attempt repair (only for non-variable statements)
+                    if (!isVariable) {
+                        // Convert statement to step format for repair
+                        const stepForRepair = {
+                            id: `step-${stepNumber}`,
+                            description: stmt.intentComment || stmt.code,
+                            code: stmt.code
+                        };
+                        // Create temporary steps array for repair context
+                        const stepsForRepair = allStatements
+                            .filter(s => !s.isVariableDeclaration)
+                            .map((s, idx) => ({
+                            id: `step-${idx + 1}`,
+                            description: s.intentComment || s.code,
+                            code: s.code,
+                            success: idx < stepNumber - 1 // Previous steps succeeded
+                        }));
+                        const repairSuccess = await this.attemptStepRepair(stepNumber - 1, // 0-based index
+                        stepForRepair, stepsForRepair, executedStepDescriptions, page, persistentContext, options.jobId || '', options.model || model_constants_1.DEFAULT_MODEL);
+                        if (repairSuccess) {
+                            // Repair succeeded, continue to next statement
+                            this.log(`  ✓ Step ${stepNumber} repaired successfully`);
+                            // Don't increment i - the repaired statement was already executed by orchestrator
                         }
                         else {
-                            // Step was deleted or needs re-execution
-                            this.log(`  ↻ Re-executing repaired step ${i + 1}`);
-                            continue;
+                            // Repair failed, stop execution
+                            this.log(`  ✗ Repair failed for step ${stepNumber}, stopping execution`);
+                            persistentContext.dispose();
+                            return { success: false, failedStepIndex: i, error: errorMsg };
                         }
                     }
                     else {
-                        // Repair failed, stop execution
+                        // Variable declaration failed - stop (can't repair variable declarations)
+                        this.log(`  ✗ Variable declaration failed, cannot repair`);
                         persistentContext.dispose();
-                        return {
-                            success: false,
-                            failedStepIndex: i,
-                            error: errorMsg,
-                            updatedSteps
-                        };
+                        return { success: false, failedStepIndex: i, error: `Variable declaration failed: ${errorMsg}` };
                     }
                 }
             }
         }
-        // All steps succeeded
-        this.log(`All ${updatedSteps.length} steps completed successfully`);
+        // All statements executed successfully
+        this.log(`All ${allStatements.length} statements executed successfully (${stepNumber} steps with callbacks)`);
         persistentContext.dispose();
-        return { success: true, updatedSteps };
+        return { success: true, updatedSteps: [] };
     }
     /**
      * Attempt to repair a failed step using orchestrator
@@ -1095,7 +1128,7 @@ class ExecutionService {
             const page = request.existingPage;
             // Apply file upload overrides if tempDir is provided
             if (request.tempDir) {
-                applyFileUploadOverrides(page, request.tempDir);
+                applyFileUploadOverrides(page, request.tempDir, request.testFolderPath, (msg, level) => this.log(msg, level));
                 this.log(`Applied file upload overrides with tempDir: ${request.tempDir}`);
             }
             try {
@@ -1103,18 +1136,14 @@ class ExecutionService {
                 if (this.progressReporter?.beforeStartTest) {
                     await this.progressReporter.beforeStartTest(page, browser, context);
                 }
-                // Parse script into steps if not already provided
-                let steps = request.steps;
-                if (!steps || steps.length === 0) {
-                    steps = await this.parseScriptIntoSteps(request.script, model || model_constants_1.DEFAULT_MODEL);
-                    this.log(`Parsed script into ${steps.length} steps`);
-                }
-                // Execute steps in persistent context (STOP on first error)
-                const result = await this.executeStepsInPersistentContext(steps, page, browser, context, {
+                // Execute script in persistent context (STOP on first error)
+                // Pre-parsed steps from consumer (if any) will be ignored - AST extracts from script
+                const result = await this.executeStepsInPersistentContext(request.steps || [], // Pre-parsed steps (optional, for backward compatibility)
+                page, browser, context, {
                     mode: 'RUN_EXACTLY',
                     jobId: request.jobId,
                     tempDir: request.tempDir,
-                    originalScript: request.script // Pass original script for import extraction
+                    originalScript: request.script // AST will extract statements from this
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1152,7 +1181,7 @@ class ExecutionService {
             const { browser, context, page } = await this.initializeBrowser(request.playwrightConfig, request.headless, request.playwrightConfigFilePath);
             // Apply file upload overrides if tempDir is provided
             if (request.tempDir) {
-                applyFileUploadOverrides(page, request.tempDir);
+                applyFileUploadOverrides(page, request.tempDir, request.testFolderPath, (msg, level) => this.log(msg, level));
                 this.log(`Applied file upload overrides with tempDir: ${request.tempDir}`);
             }
             try {
@@ -1160,18 +1189,14 @@ class ExecutionService {
                 if (this.progressReporter?.beforeStartTest) {
                     await this.progressReporter.beforeStartTest(page, browser, context);
                 }
-                // Parse script into steps if not already provided
-                let steps = request.steps;
-                if (!steps || steps.length === 0) {
-                    steps = await this.parseScriptIntoSteps(request.script, model || model_constants_1.DEFAULT_MODEL);
-                    this.log(`Parsed script into ${steps.length} steps`);
-                }
-                // Execute steps in persistent context (STOP on first error)
-                const result = await this.executeStepsInPersistentContext(steps, page, browser, context, {
+                // Execute script in persistent context (STOP on first error)
+                // Pre-parsed steps from consumer (if any) will be ignored - AST extracts from script
+                const result = await this.executeStepsInPersistentContext(request.steps || [], // Pre-parsed steps (optional, for backward compatibility)
+                page, browser, context, {
                     mode: 'RUN_EXACTLY',
                     jobId: request.jobId,
                     tempDir: request.tempDir,
-                    originalScript: request.script // Pass original script for import extraction
+                    originalScript: request.script // AST will extract statements from this
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1252,7 +1277,7 @@ class ExecutionService {
                 repairPage = request.existingPage;
                 // Apply file upload overrides if tempDir is provided
                 if (request.tempDir) {
-                    applyFileUploadOverrides(repairPage, request.tempDir);
+                    applyFileUploadOverrides(repairPage, request.tempDir, request.testFolderPath, (msg, level) => this.log(msg, level));
                     this.log(`Applied file upload overrides with tempDir: ${request.tempDir}`);
                 }
             }
@@ -1264,7 +1289,7 @@ class ExecutionService {
                 repairPage = browserInstance.page;
                 // Apply file upload overrides if tempDir is provided
                 if (request.tempDir) {
-                    applyFileUploadOverrides(repairPage, request.tempDir);
+                    applyFileUploadOverrides(repairPage, request.tempDir, request.testFolderPath, (msg, level) => this.log(msg, level));
                     this.log(`Applied file upload overrides with tempDir: ${request.tempDir}`);
                 }
             }
@@ -1361,235 +1386,7 @@ class ExecutionService {
             return fallbackResult;
         }
     }
-    async repairStepsWithAI(steps, page, repairFlexibility, model, jobId) {
-        let updatedSteps = [...steps];
-        const maxTries = 3;
-        const recentRepairs = [];
-        // Track actual executed steps (including agent repairs) for proper history
-        const executedStepDescriptions = [];
-        // Create a shared execution context that accumulates ONLY variable declarations (not action commands)
-        // This allows variables to be shared across steps without re-executing commands
-        let executionContext = '';
-        const contextVariables = new Map();
-        let i = 0;
-        while (i < updatedSteps.length) {
-            // Check if job was cancelled by user
-            if (this.progressReporter?.shouldContinue && jobId) {
-                const shouldContinue = await this.progressReporter.shouldContinue(jobId);
-                if (!shouldContinue) {
-                    this.log(`🛑 Job ${jobId} cancelled by user - aborting repair`);
-                    // Mark remaining steps as failed
-                    for (let j = i; j < updatedSteps.length; j++) {
-                        updatedSteps[j].success = false;
-                        updatedSteps[j].error = 'Cancelled by user';
-                    }
-                    break;
-                }
-            }
-            const step = updatedSteps[i];
-            this.log(`Loop iteration: i=${i}, step description="${step.description}", total steps=${updatedSteps.length}`);
-            // Declare variables that will be used in repair section
-            let successfulCommands = [];
-            let failingCommand;
-            let remainingCommands = [];
-            let stepWasAttempted = false; // Track if we actually tried this step
-            try {
-                // LIFECYCLE: Call beforeStepStart if provided
-                if (this.progressReporter?.beforeStepStart) {
-                    await this.progressReporter.beforeStepStart({
-                        stepId: step.id, // Preserve original step ID if provided
-                        stepNumber: i + 1,
-                        description: step.description,
-                        code: step.code
-                    }, page);
-                }
-                // Execute step commands one-by-one to track which succeed
-                this.log(`Attempting Step ${i + 1}: ${step.description}`);
-                this.log(`  Code: ${step.code}`);
-                stepWasAttempted = true; // Mark that we attempted this step
-                const result = await this.executeStepWithTracking(step.code, page, executionContext);
-                successfulCommands = result.successfulCommands;
-                failingCommand = result.failingCommand;
-                remainingCommands = result.remainingCommands;
-                const execError = result.error;
-                if (!failingCommand) {
-                    // All commands succeeded
-                    step.success = true;
-                    this.log(`Step ${i + 1} executed successfully: ${step.description}`);
-                    this.log(`Step ${i + 1} success status set to: ${step.success}`);
-                    // Track executed step description for agent context
-                    executedStepDescriptions.push(step.description);
-                    // Report successful step execution
-                    this.log(`DEBUG: About to check callback - progressReporter=${!!this.progressReporter}, onStepProgress=${!!this.progressReporter?.onStepProgress}, jobId=${jobId}`);
-                    if (this.progressReporter?.onStepProgress && jobId) {
-                        this.log(`DEBUG: Firing onStepProgress callback for step ${i + 1}, stepId=${step.id}`);
-                        await this.progressReporter.onStepProgress({
-                            jobId,
-                            stepId: step.id, // Preserve original step ID if provided
-                            stepNumber: i + 1,
-                            description: step.description,
-                            code: step.code,
-                            status: 'SUCCESS_STEP_EXECUTION',
-                            wasRepaired: false
-                        });
-                        this.log(`DEBUG: onStepProgress callback completed for step ${i + 1}`);
-                    }
-                    else {
-                        this.log(`DEBUG: Skipping callback - conditions not met`);
-                    }
-                    // Add only variable declarations to execution context (not action commands)
-                    // This prevents re-executing commands while preserving variable scope
-                    const declarations = successfulCommands.filter(cmd => cmd.startsWith('const ') || cmd.startsWith('let ') || cmd.startsWith('var '));
-                    if (declarations.length > 0) {
-                        executionContext += declarations.join('\n') + '\n';
-                    }
-                    i++; // Move to next step
-                    continue; // Skip to next iteration
-                }
-                // Step failed - we have tracked which commands succeeded
-                this.log(`Step ${i + 1} failed: ${step.description}`);
-                this.log(`  Error: ${execError}`);
-                step.success = false;
-                step.error = execError;
-                this.log(`  Identified ${successfulCommands.length} successful commands before failure`);
-                if (successfulCommands.length > 0) {
-                    this.log(`  Successful commands:\n    ${successfulCommands.join('\n    ')}`);
-                }
-                if (failingCommand) {
-                    this.log(`  Failing command: ${failingCommand}`);
-                }
-                if (remainingCommands.length > 0) {
-                    this.log(`  Remaining commands (${remainingCommands.length}):\n    ${remainingCommands.join('\n    ')}`);
-                }
-            }
-            catch (error) {
-                // Unexpected error in the tracking logic itself
-                this.log(`Unexpected error in step execution tracking: ${error}`);
-                step.success = false;
-                step.error = step_execution_utils_1.StepExecutionUtils.safeSerializeError(error);
-                stepWasAttempted = true; // Mark as attempted (failed)
-            }
-            // Only attempt repair if step was actually tried and failed
-            if (stepWasAttempted && !step.success) {
-                const aiCommandDetected = (0, ai_command_utils_1.containsAiCommand)(failingCommand) ||
-                    (0, ai_command_utils_1.anyContainsAiCommand)(remainingCommands) ||
-                    (0, ai_command_utils_1.containsAiCommand)(step.code);
-                if (aiCommandDetected) {
-                    this.log(`Skipping AI repair for step ${i + 1} because it already relies on ai.act/ai.verify and failed during execution.`);
-                    break;
-                }
-                // Use orchestrator for repair (reuses all SoM infrastructure)
-                this.log(`Calling orchestrator in REPAIR mode for step ${i + 1}`);
-                // Prepare repair context - use executedStepDescriptions (includes agent repairs)
-                const priorSteps = executedStepDescriptions; // What was ACTUALLY executed (scripted + agent)
-                const nextSteps = updatedSteps.slice(i + 1).map(s => s.description);
-                this.log(`  Prior steps executed: ${priorSteps.length}, Next steps: ${nextSteps.length}`);
-                this.log(`  Prior steps context:\n    ${priorSteps.map((s, idx) => `${idx + 1}. ${s}`).join('\n    ')}`);
-                // Create minimal memory for repair
-                const memory = {
-                    extractedData: {},
-                    history: []
-                };
-                let repairSuccess = false;
-                try {
-                    // Call orchestrator with repair context (page object persisted)
-                    const repairResult = await this.orchestratorAgent.executeStep(page, // Same page object (persisted state)
-                    step.description, // Goal with testdata embedded
-                    i + 1, // Current step number
-                    updatedSteps.length, // Total steps
-                    updatedSteps.map(s => s.description), // All step descriptions
-                    memory, // Memory (empty for repair)
-                    jobId || 'repair', priorSteps, // What was already completed (prior steps)
-                    nextSteps, // What comes after this (next steps)
-                    successfulCommands, // Commands that succeeded within THIS step before failure
-                    failingCommand, // The specific command that failed
-                    remainingCommands // Commands after the failing one (not yet executed)
-                    );
-                    if (repairResult.success && repairResult.commands.length > 0) {
-                        // MODIFY: Merge successful + fixed + remaining commands
-                        const allCommands = [...successfulCommands, ...repairResult.commands, ...remainingCommands];
-                        const repairedCode = allCommands.join('\n');
-                        updatedSteps[i] = {
-                            ...step,
-                            code: repairedCode,
-                            success: true,
-                            error: undefined
-                        };
-                        this.log(`✓ Step ${i + 1} MODIFIED by orchestrator (repair successful)`);
-                        this.log(`  Original code: ${step.code}`);
-                        if (successfulCommands.length > 0) {
-                            this.log(`  Preserved ${successfulCommands.length} successful commands`);
-                        }
-                        this.log(`  Added ${repairResult.commands.length} repaired commands`);
-                        if (remainingCommands.length > 0) {
-                            this.log(`  Appended ${remainingCommands.length} remaining commands from original step`);
-                        }
-                        this.log(`  Complete code (${allCommands.length} total):\n    ${allCommands.join('\n    ')}`);
-                        // Track what agent actually did in history (for future repair context)
-                        const agentActionSummary = `${step.description} [AI-repaired: ${successfulCommands.length} preserved + ${repairResult.commands.length} fixed + ${remainingCommands.length} remaining]`;
-                        executedStepDescriptions.push(agentActionSummary);
-                        // Update execution context with ONLY variable declarations from repaired step
-                        const repairedDeclarations = allCommands.filter(cmd => cmd.startsWith('const ') || cmd.startsWith('let ') || cmd.startsWith('var '));
-                        if (repairedDeclarations.length > 0) {
-                            executionContext += repairedDeclarations.join('\n') + '\n';
-                        }
-                        // Report repaired step
-                        if (this.progressReporter?.onStepProgress && jobId) {
-                            await this.progressReporter.onStepProgress({
-                                jobId,
-                                stepId: step.id,
-                                stepNumber: i + 1,
-                                description: updatedSteps[i].description,
-                                code: updatedSteps[i].code,
-                                status: 'SUCCESS_STEP_EXECUTION',
-                                wasRepaired: true
-                            });
-                        }
-                        // Ensure page is stable after agent repairs before returning control to script
-                        this.log(`Waiting for page stability after agent repair...`);
-                        try {
-                            await page.waitForLoadState('networkidle', { timeout: 5000 });
-                            this.log(`Page stabilized (networkidle) after agent repair`);
-                        }
-                        catch (stabilityError) {
-                            try {
-                                await page.waitForLoadState('domcontentloaded', { timeout: 3000 });
-                                this.log(`Page loaded (domcontentloaded) after agent repair`);
-                            }
-                            catch (fallbackError) {
-                                this.log(`Page stability wait timed out (continuing anyway)`, 'warn');
-                            }
-                        }
-                        repairSuccess = true;
-                        i++; // Continue to NEXT step (hand control back to script)
-                    }
-                    else if (repairResult.success && repairResult.commands.length === 0) {
-                        // DELETE: Step goal already achieved or no longer needed (e.g., modal already dismissed)
-                        this.log(`✓ Step ${i + 1} DELETED by orchestrator (goal already achieved, step obsolete)`);
-                        this.log(`  Reason: Orchestrator completed with 0 commands - step no longer needed`);
-                        // Track deletion in history (helps agent understand what was skipped)
-                        executedStepDescriptions.push(`${step.description} [AI-deleted: step obsolete/already done]`);
-                        // Remove the step from array
-                        updatedSteps.splice(i, 1);
-                        repairSuccess = true;
-                        // Don't increment i - next step moved to current position
-                    }
-                    else {
-                        this.log(`✗ Step ${i + 1} could not be repaired by orchestrator (reason: ${repairResult.terminationReason})`);
-                    }
-                }
-                catch (repairError) {
-                    this.log(`✗ Orchestrator repair failed: ${repairError.message}`);
-                }
-                // Legacy repair code removed - now using orchestrator
-                if (!repairSuccess) {
-                    this.log(`Step ${i + 1} could not be repaired - stopping execution`);
-                    break;
-                }
-            }
-        }
-        return updatedSteps;
-    }
+    // Dead code removed: repairStepsWithAI() - 283 lines of unused legacy repair logic
     async executeStepCode(code, page) {
         // Set timeout based on whether code contains AI commands (which need more time for LLM calls)
         const hasAiCommands = (0, ai_command_utils_1.containsAiCommand)(code);
@@ -1622,12 +1419,6 @@ class ExecutionService {
             page.setDefaultNavigationTimeout(30000);
         }
     }
-    // Legacy repair helper methods (now unused but kept for compilation)
-    buildFailureHistory() { return ''; }
-    buildRecentRepairsContext() { return ''; }
-    async applyRepairActionInContext() {
-        return { success: false };
-    }
     generateUpdatedScript(steps, repairAdvice, originalScript) {
         return script_generator_utils_1.ScriptGeneratorUtils.generateUpdatedScript(steps, repairAdvice, originalScript);
     }