testchimp-runner-core 0.1.20 → 0.1.22

package/dist/execution-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execution-service.d.ts","sourceRoot":"","sources":["../src/execution-service.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAE3B,sBAAsB,EACtB,uBAAuB,EAKvB,wBAAwB,EACxB,yBAAyB,EAG1B,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAW3C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAA+C,MAAM,qBAAqB,CAAC;AAmbpG;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,MAAM,CAAC,CAA8D;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAkB;IAExC;;OAEG;IACH,aAAa;gBAKX,UAAU,CAAC,EAAE,UAAU,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,uBAAuB,GAAE,MAAW,EACpC,WAAW,CAAC,EAAE,WAAW,EACzB,gBAAgB,CAAC,EAAE,gBAAgB;IA8BrC;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,KAAK,IAAI,GAAG,IAAI;IAKpF;;OAEG;IACH,OAAO,CAAC,GAAG;IASX,OAAO,CAAC,WAAW;IAanB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAQ3C;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkBtF;;;;;;;;;;OAUG;IACG,cAAc,CAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE,GAAG,EACb,cAAc,CAAC,EAAE,GAAG,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAuBhB;;OAEG;YACW,qBAAqB;IAmBnC;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAgCjG;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsC7B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;YACW,+BAA+B;IA6tB7C;;;OAGG;YACW,iBAAiB;YAiGjB,UAAU;YAkLV,eAAe;YAoKf,oBAAoB;YAiBpB,eAAe;IAuC7B,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;YACW,iBAAiB;IAI/B;;;;OAIG;IACG,WAAW,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAorBxF;;;;;OAKG;YACW,WAAW;CAgI1B"}
+{"version":3,"file":"execution-service.d.ts","sourceRoot":"","sources":["../src/execution-service.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAE3B,sBAAsB,EACtB,uBAAuB,EAKvB,wBAAwB,EACxB,yBAAyB,EAG1B,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAY3C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAA+C,MAAM,qBAAqB,CAAC;AAmbpG;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,MAAM,CAAC,CAA8D;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAkB;IAExC;;OAEG;IACH,aAAa;gBAKX,UAAU,CAAC,EAAE,UAAU,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,uBAAuB,GAAE,MAAW,EACpC,WAAW,CAAC,EAAE,WAAW,EACzB,gBAAgB,CAAC,EAAE,gBAAgB;IA8BrC;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,KAAK,IAAI,GAAG,IAAI;IAKpF;;OAEG;IACH,OAAO,CAAC,GAAG;IASX,OAAO,CAAC,WAAW;IAanB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAQ3C;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkBtF;;;;;;;;;;OAUG;IACG,cAAc,CAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE,GAAG,EACb,cAAc,CAAC,EAAE,GAAG,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAuBhB;;OAEG;YACW,qBAAqB;IAmBnC;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAgCjG;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsC7B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;YACW,+BAA+B;IAm2B7C;;;OAGG;YACW,iBAAiB;YAiGjB,UAAU;YAoMV,eAAe;YAsKf,oBAAoB;YAiBpB,eAAe;IAuC7B,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;YACW,iBAAiB;IAI/B;;;;OAIG;IACG,WAAW,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAsxBxF;;;;;OAKG;YACW,WAAW;CAoI1B"}

package/dist/execution-service.js

@@ -51,6 +51,7 @@ const import_utils_1 = require("./utils/import-utils");
 const initialization_code_utils_1 = require("./utils/initialization-code-utils");
 const script_parser_utils_1 = require("./utils/script-parser-utils");
 const script_generator_utils_1 = require("./utils/script-generator-utils");
+const pom_denormalizer_1 = require("./utils/pom-denormalizer");
 const progress_reporter_1 = require("./progress-reporter");
 const backend_proxy_llm_provider_1 = require("./providers/backend-proxy-llm-provider");
 const build_info_1 = require("./build-info");
@@ -645,12 +646,71 @@ class ExecutionService {
      * Variables persist across steps without re-execution
      */
     async executeStepsInPersistentContext(steps, page, browser, browserContext, options, sharedContext) {
-        this.log(`[executeStepsInPersistentContext] Called with ${steps.length} steps, mode=${options.mode}, originalScript=${!!options.originalScript}, tempDir=${!!options.tempDir}, sharedContext=${!!sharedContext}`);
+        this.log(`[executeStepsInPersistentContext] Called with ${steps.length} steps, mode=${options.mode}, originalScript=${!!options.originalScript}, tempDir=${!!options.tempDir}, sharedContext=${!!sharedContext}, runPomDenormalized=${!!options.runPomDenormalized}`);
         const { expect, test } = require('@playwright/test');
         const { ai } = require('ai-wright');
         // Use shared context if provided, otherwise create new context
         const persistentContext = sharedContext || new PersistentExecutionContext(page, expect, test, ai, browser, browserContext, options.tempDir);
         const isSharedContext = !!sharedContext;
+        const resolvedTestFileDir = (() => {
+            if (!options.tempDir) {
+                return undefined;
+            }
+            if (options.testFolderPath && options.testFolderPath.length > 0) {
+                return path.join(options.tempDir, ...options.testFolderPath);
+            }
+            const defaultDir = path.join(options.tempDir, 'tests');
+            try {
+                const testsDir = defaultDir;
+                const fs = require('fs');
+                if (!fs.existsSync(testsDir)) {
+                    this.log(`Tests directory ${testsDir} does not exist, using default for module resolution`, 'warn');
+                    return defaultDir;
+                }
+                const findTestFile = (dir, depth = 0, maxDepth = 10) => {
+                    if (depth > maxDepth) {
+                        return null;
+                    }
+                    try {
+                        const files = fs.readdirSync(dir);
+                        for (const file of files) {
+                            const fullPath = path.join(dir, file);
+                            try {
+                                const stat = fs.statSync(fullPath);
+                                if (stat.isDirectory()) {
+                                    const found = findTestFile(fullPath, depth + 1, maxDepth);
+                                    if (found)
+                                        return found;
+                                }
+                                else if (file.endsWith('.spec.ts') || file.endsWith('.spec.js') ||
+                                    file.endsWith('.test.ts') || file.endsWith('.test.js')) {
+                                    return fullPath;
+                                }
+                            }
+                            catch (statError) {
+                                continue;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        return null;
+                    }
+                    return null;
+                };
+                const testFilePath = findTestFile(testsDir);
+                if (testFilePath) {
+                    const testFileDir = path.dirname(testFilePath);
+                    this.log(`Found test file at ${testFilePath}, using directory ${testFileDir} for module resolution`);
+                    return testFileDir;
+                }
+                this.log(`No test file found in ${testsDir}, using tests directory for module resolution`, 'warn');
+                return testsDir;
+            }
+            catch (searchError) {
+                this.log(`Could not search for test file: ${searchError.message}, using tests directory for module resolution`, 'warn');
+                return defaultDir;
+            }
+        })();
         // Extract and execute imports from original script if provided
         this.log(`[executeStepsInPersistentContext] Checking imports: originalScript=${!!options.originalScript}, tempDir=${!!options.tempDir}`);
         if (options.originalScript && options.tempDir) {
@@ -664,60 +724,7 @@ class ExecutionService {
                     // Execute imports with proper context - find the actual test file path
                     // All tests are within the tests folder
                     // We search for test files in tempDir/tests directory tree
-                    let testFileDir = path.join(options.tempDir, 'tests'); // Default to tests directory
-                    try {
-                        const fs = require('fs');
-                        const testsDir = path.join(options.tempDir, 'tests');
-                        // Check if tests directory exists
-                        if (!fs.existsSync(testsDir)) {
-                            this.log(`Tests directory ${testsDir} does not exist, using default for module resolution`, 'warn');
-                        }
-                        else {
-                            // Recursive search with depth limit to prevent infinite loops
-                            const findTestFile = (dir, depth = 0, maxDepth = 10) => {
-                                if (depth > maxDepth) {
-                                    return null; // Prevent infinite recursion
-                                }
-                                try {
-                                    const files = fs.readdirSync(dir);
-                                    for (const file of files) {
-                                        const fullPath = path.join(dir, file);
-                                        try {
-                                            const stat = fs.statSync(fullPath);
-                                            if (stat.isDirectory()) {
-                                                const found = findTestFile(fullPath, depth + 1, maxDepth);
-                                                if (found)
-                                                    return found;
-                                            }
-                                            else if (file.endsWith('.spec.ts') || file.endsWith('.spec.js') ||
-                                                file.endsWith('.test.ts') || file.endsWith('.test.js')) {
-                                                return fullPath; // Found a test file
-                                            }
-                                        }
-                                        catch (statError) {
-                                            // Skip files we can't stat
-                                            continue;
-                                        }
-                                    }
-                                }
-                                catch (e) {
-                                    // Continue searching in other directories
-                                }
-                                return null;
-                            };
-                            const testFilePath = findTestFile(testsDir);
-                            if (testFilePath) {
-                                testFileDir = path.dirname(testFilePath);
-                                this.log(`Found test file at ${testFilePath}, using directory ${testFileDir} for module resolution`);
-                            }
-                            else {
-                                this.log(`No test file found in ${testsDir}, using tests directory for module resolution`, 'warn');
-                            }
-                        }
-                    }
-                    catch (searchError) {
-                        this.log(`Could not search for test file: ${searchError.message}, using tests directory for module resolution`, 'warn');
-                    }
+                    const testFileDir = resolvedTestFileDir || path.join(options.tempDir, 'tests');
                     // Store test file directory in context for module resolution
                     persistentContext.setTestFileDir(testFileDir);
                     this.log(`Module resolution context: testFileDir=${testFileDir}, tempDir=${options.tempDir}`);
@@ -963,6 +970,78 @@ class ExecutionService {
             }
             return { success: false, error: 'No script or steps provided for execution' };
         }
+        if (options.runPomDenormalized && options.originalScript) {
+            const originalCount = allStatements.length;
+            const originalStepIds = allStatements
+                .map((stmt, idx) => ({ idx, stepId: stmt.stepId, code: stmt.code.substring(0, 50) }))
+                .filter(s => s.stepId);
+            this.log(`[executeStepsInPersistentContext] Starting POM denormalization: ${originalCount} original statements, ` +
+                `${originalStepIds.length} with stepIds`);
+            // Convert to ScriptStep[] for denormalization
+            const scriptSteps = allStatements.map(stmt => ({
+                code: stmt.code,
+                description: stmt.intentComment || '',
+                id: stmt.stepId, // stepId may not exist for InitializationCodeUtils results
+                isVariableDeclaration: stmt.isVariableDeclaration
+            }));
+            // Denormalize POM calls
+            const denormalizedSteps = pom_denormalizer_1.PomDenormalizer.denormalizePomSteps(scriptSteps, {
+                originalScript: options.originalScript,
+                tempDir: options.tempDir || '',
+                testFileDir: resolvedTestFileDir,
+                logger: (msg, level) => this.log(msg, level)
+            });
+            const denormalizedCount = denormalizedSteps.length;
+            const denormalizedStepIds = denormalizedSteps
+                .map((step, idx) => ({ idx, stepId: step.id, isVar: step.isVariableDeclaration, code: step.code.substring(0, 50) }))
+                .filter(s => s.stepId && !s.isVar);
+            this.log(`[executeStepsInPersistentContext] Denormalization complete: ${originalCount} -> ${denormalizedCount} statements ` +
+                `(${denormalizedCount - originalCount > 0 ? '+' : ''}${denormalizedCount - originalCount}), ` +
+                `${denormalizedStepIds.length} non-variable steps with stepIds`);
+            if (denormalizedStepIds.length > 0 && this.log) {
+                const stepIdPreview = denormalizedStepIds.slice(0, 5).map(s => `idx=${s.idx} stepId=${s.stepId?.substring(0, 16)}...`).join(', ');
+                this.log(`[executeStepsInPersistentContext] Sample denormalized stepIds: ${stepIdPreview}${denormalizedStepIds.length > 5 ? '...' : ''}`);
+            }
+            // Convert back to inline type format
+            allStatements = denormalizedSteps.map(step => ({
+                code: step.code,
+                isVariableDeclaration: step.isVariableDeclaration || false,
+                intentComment: step.description !== step.code ? step.description : undefined,
+                screenStateAnnotation: undefined,
+                stepId: step.id
+            }));
+            // Verify stepId preservation
+            const preservedStepIds = allStatements
+                .map((stmt, idx) => ({ idx, stepId: stmt.stepId, isVar: stmt.isVariableDeclaration }))
+                .filter(s => s.stepId && !s.isVar);
+            this.log(`[executeStepsInPersistentContext] StepId preservation: ${preservedStepIds.length} non-variable statements have stepIds ` +
+                `(expected: ${denormalizedStepIds.length})`);
+            // Verify stepId matching between denormalized and preserved
+            if (preservedStepIds.length !== denormalizedStepIds.length) {
+                this.log(`[executeStepsInPersistentContext] WARNING: StepId count mismatch! ` +
+                    `Denormalized: ${denormalizedStepIds.length}, Preserved: ${preservedStepIds.length}`, 'warn');
+            }
+            else {
+                // Check if stepIds match
+                let matchCount = 0;
+                for (let i = 0; i < Math.min(denormalizedStepIds.length, preservedStepIds.length); i++) {
+                    const denorm = denormalizedStepIds[i];
+                    const preserved = preservedStepIds.find(p => p.idx === denorm.idx);
+                    if (preserved && preserved.stepId === denorm.stepId) {
+                        matchCount++;
+                    }
+                }
+                this.log(`[executeStepsInPersistentContext] StepId matching: ${matchCount}/${Math.min(denormalizedStepIds.length, preservedStepIds.length)} stepIds match`);
+            }
+        }
+        else {
+            if (!options.runPomDenormalized) {
+                this.log(`[executeStepsInPersistentContext] POM denormalization skipped: runPomDenormalized=false`);
+            }
+            else if (!options.originalScript) {
+                this.log(`[executeStepsInPersistentContext] POM denormalization skipped: originalScript not provided`);
+            }
+        }
         // Build stepId -> statement index map before execution
         const statementIndexByStepId = new Map();
         for (let idx = 0; idx < allStatements.length; idx++) {
@@ -980,6 +1059,38 @@ class ExecutionService {
             }
             return count;
         };
+        const normalizeJumpStepId = (stepId) => stepId.replace(/#\d+$/, '');
+        const consumeJumpRequest = (contextLabel) => {
+            const jumpRequest = page.__tcExecutionJump;
+            if (!jumpRequest || typeof jumpRequest !== 'object' || !jumpRequest.toStepId) {
+                return null;
+            }
+            if (jumpCount >= maxJumpCount) {
+                this.log(`[executeStepsInPersistentContext] Max jump count ${maxJumpCount} reached - ignoring jump`, 'warn');
+                delete page.__tcExecutionJump;
+                return null;
+            }
+            const rawStepId = String(jumpRequest.toStepId);
+            const normalizedStepId = normalizeJumpStepId(rawStepId);
+            const targetIndex = statementIndexByStepId.get(normalizedStepId);
+            delete page.__tcExecutionJump;
+            if (targetIndex === undefined) {
+                this.log(`[executeStepsInPersistentContext] Jump target stepId not found: ${rawStepId}`, 'warn');
+                return null;
+            }
+            const nextIndex = targetIndex + 1;
+            jumpCount += 1;
+            if (nextIndex >= allStatements.length) {
+                this.log(`[executeStepsInPersistentContext] Jump target is last statement; ending execution`, 'warn');
+                return allStatements.length;
+            }
+            stepNumber = countNonVariableStatementsBefore(nextIndex);
+            const normalizedNote = rawStepId !== normalizedStepId
+                ? ` (normalized from ${rawStepId})`
+                : '';
+            this.log(`[executeStepsInPersistentContext] Jumping to step index ${nextIndex} (stepId: ${normalizedStepId})${normalizedNote} [${contextLabel}]`);
+            return targetIndex;
+        };
         // Execute all statements sequentially
         // Variable declarations execute silently, other statements trigger callbacks
         let stepNumber = 0; // Track step number (excludes variables)
@@ -1009,32 +1120,10 @@ class ExecutionService {
             const isVariable = stmt.isVariableDeclaration;
             let stepMeta;
             // Jump request handling (allow rewinding to a prior checkpoint step)
-            const jumpRequest = page.__tcExecutionJump;
-            if (jumpRequest && typeof jumpRequest === 'object' && jumpRequest.toStepId) {
-                if (jumpCount >= maxJumpCount) {
-                    this.log(`[executeStepsInPersistentContext] Max jump count ${maxJumpCount} reached - ignoring jump`, 'warn');
-                    delete page.__tcExecutionJump;
-                }
-                else {
-                    const targetIndex = statementIndexByStepId.get(jumpRequest.toStepId);
-                    delete page.__tcExecutionJump;
-                    if (targetIndex === undefined) {
-                        this.log(`[executeStepsInPersistentContext] Jump target stepId not found: ${jumpRequest.toStepId}`, 'warn');
-                    }
-                    else {
-                        const nextIndex = targetIndex + 1;
-                        jumpCount += 1;
-                        if (nextIndex >= allStatements.length) {
-                            this.log(`[executeStepsInPersistentContext] Jump target is last statement; ending execution`, 'warn');
-                            i = allStatements.length;
-                            continue;
-                        }
-                        stepNumber = countNonVariableStatementsBefore(nextIndex);
-                        this.log(`[executeStepsInPersistentContext] Jumping to step index ${nextIndex} (stepId: ${jumpRequest.toStepId})`);
-                        i = targetIndex;
-                        continue;
-                    }
-                }
+            const jumpIndexBefore = consumeJumpRequest('before-step');
+            if (jumpIndexBefore !== null) {
+                i = jumpIndexBefore;
+                continue;
             }
             // Check cancellation
             if (this.progressReporter?.shouldContinue && options.jobId) {
@@ -1069,14 +1158,6 @@ class ExecutionService {
                 let shouldSkipStep = false;
                 if (this.progressReporter?.beforeStepStart && options.jobId) {
                     const { description, baseStepId, stepId, runNumber } = stepMeta;
-                    // Log stepId usage for debugging
-                    if (stmt.stepId) {
-                        const stepIdPreview = stmt.stepId.length > 16 ? `${stmt.stepId.substring(0, 16)}...` : stmt.stepId;
-                        this.log(`[stepId] beforeStepStart: Using hash-based stepId: ${stepIdPreview} (stepNumber: ${stepNumber}, run: ${runNumber})`);
-                    }
-                    else {
-                        this.log(`[stepId] beforeStepStart: WARNING: No hash-based stepId, using fallback: ${baseStepId} (stepNumber: ${stepNumber}, run: ${runNumber})`);
-                    }
                     const beforeStepResult = await this.progressReporter.beforeStepStart({
                         stepId,
                         stepNumber,
@@ -1119,6 +1200,11 @@ class ExecutionService {
                 }
                 // Skip step execution if beforeStepStart returned skip: true
                 if (shouldSkipStep) {
+                    const jumpIndexAfterSkip = consumeJumpRequest('after-skip');
+                    if (jumpIndexAfterSkip !== null) {
+                        i = jumpIndexAfterSkip;
+                        continue;
+                    }
                     continue; // Skip to next step
                 }
             }
@@ -1151,6 +1237,11 @@ class ExecutionService {
                             wasRepaired: false
                         });
                     }
+                    const jumpIndexAfterSuccess = consumeJumpRequest('after-success');
+                    if (jumpIndexAfterSuccess !== null) {
+                        i = jumpIndexAfterSuccess;
+                        continue;
+                    }
                 }
                 else {
                     this.log(`  Executed variable declaration (no callback): ${stmt.code}`);
@@ -1381,12 +1472,18 @@ class ExecutionService {
                 }
                 // Execute script in persistent context (STOP on first error)
                 // Pre-parsed steps from consumer (if any) will be ignored - AST extracts from script
+                this.log(`[runExactly] Calling executeStepsInPersistentContext (existing browser): ` +
+                    `runPomDenormalized=${request.runPomDenormalized}, ` +
+                    `originalScript=${!!request.script} (length: ${request.script?.length || 0}), ` +
+                    `tempDir=${!!request.tempDir}`);
                 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 // AST will extract statements from this
+                    originalScript: request.script, // AST will extract statements from this
+                    testFolderPath: request.testFolderPath,
+                    runPomDenormalized: request.runPomDenormalized
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1434,12 +1531,18 @@ class ExecutionService {
                 }
                 // Execute script in persistent context (STOP on first error)
                 // Pre-parsed steps from consumer (if any) will be ignored - AST extracts from script
+                this.log(`[runExactly] Calling executeStepsInPersistentContext (new browser, attempt ${attempt}): ` +
+                    `runPomDenormalized=${request.runPomDenormalized}, ` +
+                    `originalScript=${!!request.script} (length: ${request.script?.length || 0}), ` +
+                    `tempDir=${!!request.tempDir}`);
                 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 // AST will extract statements from this
+                    originalScript: request.script, // AST will extract statements from this
+                    testFolderPath: request.testFolderPath,
+                    runPomDenormalized: request.runPomDenormalized
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1555,7 +1658,9 @@ class ExecutionService {
                 jobId: request.jobId,
                 model,
                 tempDir: request.tempDir,
-                originalScript: request.script // Pass original script for import extraction
+                originalScript: request.script, // Pass original script for import extraction
+                testFolderPath: request.testFolderPath,
+                runPomDenormalized: request.runPomDenormalized
             });
             const updatedSteps = result.updatedSteps || steps;
             const allStepsSuccessful = result.success;
@@ -1866,7 +1971,7 @@ class ExecutionService {
                 this.log(`Executing ${flattened.fileLevelHooks.beforeAll.length} file-level beforeAll hook(s)...`);
                 try {
                     for (const hook of flattened.fileLevelHooks.beforeAll) {
-                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, fileLevelContext || undefined, hook);
+                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook);
                     }
                     this.log('File-level beforeAll hooks executed successfully');
                 }
@@ -1937,7 +2042,7 @@ class ExecutionService {
                                     // Get or create suite context (includes file variables + suite variables)
                                     const suiteContext = await getOrCreateSuiteContext(suitePath, suite.suiteVariables, flattened.fileVariables);
                                     for (const hook of suite.beforeAll) {
-                                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, suiteContext, hook);
+                                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook);
                                     }
                                     suiteBeforeAllExecuted.add(suiteKey);
                                     this.log(`Suite-level beforeAll hooks executed for suite: ${suiteDisplayName}`);
@@ -1962,7 +2067,7 @@ class ExecutionService {
                         this.log(`Executing ${flattened.fileLevelHooks.beforeEach.length} file-level beforeEach hook(s) for test: ${test.fullName}`);
                         try {
                             for (const hook of flattened.fileLevelHooks.beforeEach) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, fileLevelContext || undefined, hook, jobId, testStepCounter);
+                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook, jobId, testStepCounter);
                                 testStepCounter += stepsExecuted;
                             }
                         }
@@ -1980,7 +2085,7 @@ class ExecutionService {
                             // Get or create suite context for this test's suite
                             const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
                             for (const hook of testData.suiteBeforeEachHooks) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, suiteContext, hook, jobId, testStepCounter);
+                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook, jobId, testStepCounter);
                                 testStepCounter += stepsExecuted;
                             }
                         }
@@ -2041,7 +2146,9 @@ class ExecutionService {
                                 jobId: jobId,
                                 tempDir: request.tempDir,
                                 originalScript: testScript, // For module resolution (imports)
-                                model: request.model
+                                model: request.model,
+                                testFolderPath: request.testFolderPath,
+                                runPomDenormalized: request.runPomDenormalized
                             }, suiteContext // Pass shared context
                             );
                             if (!result.success) {
@@ -2090,7 +2197,7 @@ class ExecutionService {
                             // Get or create suite context for this test's suite
                             const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
                             for (const hook of testData.suiteAfterEachHooks) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, suiteContext, hook, jobId, testStepCounter);
+                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook, jobId, testStepCounter);
                                 testStepCounter += stepsExecuted;
                             }
                         }
@@ -2105,7 +2212,7 @@ class ExecutionService {
                         this.log(`Executing ${flattened.fileLevelHooks.afterEach.length} file-level afterEach hook(s) for test: ${test.fullName}`);
                         try {
                             for (const hook of flattened.fileLevelHooks.afterEach) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, fileLevelContext || undefined, hook, jobId, testStepCounter);
+                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook, jobId, testStepCounter);
                                 testStepCounter += stepsExecuted;
                             }
                         }
@@ -2144,7 +2251,7 @@ class ExecutionService {
                                             // Get or create suite context (should already exist, but safe to call)
                                             const suiteContext = await getOrCreateSuiteContext(suitePath, suite.suiteVariables, flattened.fileVariables);
                                             for (const hook of suite.afterAll) {
-                                                await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, suiteContext, hook);
+                                                await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook);
                                             }
                                             this.log(`Suite-level afterAll hooks executed for suite: ${suiteDisplayName}`);
                                         }
@@ -2209,7 +2316,7 @@ class ExecutionService {
                 this.log(`Executing ${flattened.fileLevelHooks.afterAll.length} file-level afterAll hook(s)...`);
                 try {
                     for (const hook of flattened.fileLevelHooks.afterAll) {
-                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, fileLevelContext || undefined, hook);
+                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook);
                     }
                     this.log('File-level afterAll hooks executed successfully');
                 }
@@ -2275,7 +2382,7 @@ class ExecutionService {
      * If jobId is provided, executes step-wise with callbacks for step reporting
      * @returns Number of non-variable steps executed (for step counter tracking)
      */
-    async executeHook(hookCode, page, context, browser, tempDir, originalScript, sharedContext, hook, jobId, stepIdOffset = 0) {
+    async executeHook(hookCode, page, context, browser, tempDir, originalScript, testFolderPath, runPomDenormalized, sharedContext, hook, jobId, stepIdOffset = 0) {
         const { expect, test } = require('@playwright/test');
         const { ai } = require('ai-wright');
         // Construct hook script with imports from original script (for module resolution)
@@ -2314,7 +2421,9 @@ class ExecutionService {
                     mode: types_1.ExecutionMode.RUN_EXACTLY,
                     jobId: jobId,
                     tempDir: tempDir,
-                    originalScript: hookScript
+                    originalScript: hookScript,
+                    testFolderPath: testFolderPath,
+                    runPomDenormalized: runPomDenormalized
                 }, hookContext // Pass shared context
                 );
                 if (!result.success) {