testchimp-runner-core 0.1.21 → 0.1.23

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;IAowB7C;;;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,EAAuE,MAAM,qBAAqB,CAAC;AAmb5H;;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;IA86B7C;;;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;IAuxBxF;;;;;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}`);
@@ -945,6 +952,8 @@ class ExecutionService {
                     isVariableDeclaration,
                     intentComment: step.description !== step.code ? step.description : undefined,
                     screenStateAnnotation: undefined, // Will be in description for pre-parsed steps
+                    scenarioAnnotation: step.scenarioAnnotation,
+                    scenarioAnnotationLine: undefined,
                     stepId: step.id // Preserve stepId (should be hash-based for test body statements)
                 };
             });
@@ -963,6 +972,80 @@ 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,
+                scenarioAnnotation: step.scenarioAnnotation,
+                scenarioAnnotationLine: 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++) {
@@ -1012,6 +1095,54 @@ class ExecutionService {
             this.log(`[executeStepsInPersistentContext] Jumping to step index ${nextIndex} (stepId: ${normalizedStepId})${normalizedNote} [${contextLabel}]`);
             return targetIndex;
         };
+        // Scenario coverage tracking (@Scenario annotations)
+        const scenarioTitlesOrdered = [];
+        const scenarioTitleToIndex = new Map();
+        const scenarioBoundaryByStatementIndex = new Map();
+        for (let idx = 0; idx < allStatements.length; idx++) {
+            const scenarioTitle = allStatements[idx].scenarioAnnotation?.trim();
+            if (!scenarioTitle) {
+                continue;
+            }
+            if (scenarioTitleToIndex.has(scenarioTitle)) {
+                continue; // dedupe by title (ignore subsequent occurrences)
+            }
+            scenarioTitleToIndex.set(scenarioTitle, scenarioTitlesOrdered.length);
+            scenarioTitlesOrdered.push(scenarioTitle);
+            scenarioBoundaryByStatementIndex.set(idx, scenarioTitle);
+        }
+        let currentScenarioTitle;
+        let currentScenarioIndex = -1;
+        const completedScenarioTitles = new Set();
+        const emitScenarioCompletion = async (title, status) => {
+            if (!title || completedScenarioTitles.has(title)) {
+                return;
+            }
+            completedScenarioTitles.add(title);
+            if (this.progressReporter?.onScenarioCompletion) {
+                await this.progressReporter.onScenarioCompletion(title, status);
+            }
+        };
+        const finalizeScenarioFailure = async () => {
+            if (scenarioTitlesOrdered.length === 0) {
+                return;
+            }
+            if (!currentScenarioTitle) {
+                for (const title of scenarioTitlesOrdered) {
+                    await emitScenarioCompletion(title, progress_reporter_1.ScenarioCoverageStatus.NOT_ATTEMPTED);
+                }
+                return;
+            }
+            await emitScenarioCompletion(currentScenarioTitle, progress_reporter_1.ScenarioCoverageStatus.FAILED);
+            for (let idx = currentScenarioIndex + 1; idx < scenarioTitlesOrdered.length; idx++) {
+                await emitScenarioCompletion(scenarioTitlesOrdered[idx], progress_reporter_1.ScenarioCoverageStatus.NOT_ATTEMPTED);
+            }
+        };
+        const finalizeScenarioSuccess = async () => {
+            if (currentScenarioTitle) {
+                await emitScenarioCompletion(currentScenarioTitle, progress_reporter_1.ScenarioCoverageStatus.SUCCESSFUL);
+            }
+        };
         // Execute all statements sequentially
         // Variable declarations execute silently, other statements trigger callbacks
         let stepNumber = 0; // Track step number (excludes variables)
@@ -1046,6 +1177,17 @@ class ExecutionService {
                 i = jumpIndexBefore;
                 continue;
             }
+            // Scenario boundary handling (before executing statement)
+            const scenarioBoundaryTitle = scenarioBoundaryByStatementIndex.get(i);
+            if (scenarioBoundaryTitle) {
+                if (currentScenarioTitle && currentScenarioTitle !== scenarioBoundaryTitle) {
+                    await emitScenarioCompletion(currentScenarioTitle, progress_reporter_1.ScenarioCoverageStatus.SUCCESSFUL);
+                }
+                if (!completedScenarioTitles.has(scenarioBoundaryTitle)) {
+                    currentScenarioTitle = scenarioBoundaryTitle;
+                    currentScenarioIndex = scenarioTitleToIndex.get(scenarioBoundaryTitle) ?? -1;
+                }
+            }
             // Check cancellation
             if (this.progressReporter?.shouldContinue && options.jobId) {
                 const shouldContinue = await this.progressReporter.shouldContinue(options.jobId);
@@ -1079,14 +1221,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,
@@ -1215,6 +1349,7 @@ class ExecutionService {
                     if (!isSharedContext) {
                         persistentContext.dispose();
                     }
+                    await finalizeScenarioFailure();
                     return { success: false, failedStepIndex: i, error: errorMsg };
                 }
                 else {
@@ -1270,6 +1405,7 @@ class ExecutionService {
                             if (!isSharedContext) {
                                 persistentContext.dispose();
                             }
+                            await finalizeScenarioFailure();
                             return { success: false, failedStepIndex: i, error: errorMsg };
                         }
                     }
@@ -1279,6 +1415,7 @@ class ExecutionService {
                         if (!isSharedContext) {
                             persistentContext.dispose();
                         }
+                        await finalizeScenarioFailure();
                         return { success: false, failedStepIndex: i, error: `Variable declaration failed: ${errorMsg}` };
                     }
                 }
@@ -1299,6 +1436,7 @@ class ExecutionService {
             code: s.code,
             success: true
         }));
+        await finalizeScenarioSuccess();
         return { success: true, updatedSteps };
     }
     /**
@@ -1401,12 +1539,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) {
@@ -1454,12 +1598,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) {
@@ -1575,7 +1725,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;
@@ -1886,7 +2038,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');
                 }
@@ -1957,7 +2109,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}`);
@@ -1982,7 +2134,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;
                             }
                         }
@@ -2000,7 +2152,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;
                             }
                         }
@@ -2044,7 +2196,8 @@ class ExecutionService {
                                     id: stepId,
                                     code: stmt.code,
                                     description: stmt.intentComment || stmt.code.trim().substring(0, 100) || '',
-                                    isVariableDeclaration: stmt.isVariableDeclaration // Pass AST-based detection flag
+                                    isVariableDeclaration: stmt.isVariableDeclaration, // Pass AST-based detection flag
+                                    scenarioAnnotation: stmt.scenarioAnnotation
                                 };
                             });
                             // Get or create suite context for this test's suite
@@ -2061,7 +2214,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) {
@@ -2110,7 +2265,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;
                             }
                         }
@@ -2125,7 +2280,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;
                             }
                         }
@@ -2164,7 +2319,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}`);
                                         }
@@ -2229,7 +2384,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');
                 }
@@ -2295,7 +2450,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)
@@ -2334,7 +2489,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) {