qa360 1.4.5 → 2.0.1

package/dist/core/runner/phase3-runner.js

@@ -1,13 +1,14 @@
 /**
  * QA360 Phase 3 Runner
  * Orchestrates hooks, adapters, and proof generation
+ * Supports both Pack v1 and Pack v2 configurations
  */
 import { existsSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { createHash } from 'crypto';
 import chalk from 'chalk';
 import { HooksRunner } from '../hooks/runner.js';
-import { PlaywrightApiAdapter } from '../adapters/playwright-api.js';
+import { PlaywrightNativeApiAdapter } from '../adapters/playwright-native-api.js';
 import { PlaywrightUiAdapter } from '../adapters/playwright-ui.js';
 import { K6PerfAdapter } from '../adapters/k6-perf.js';
 import { SemgrepSastAdapter } from '../adapters/semgrep-sast.js';
@@ -15,6 +16,8 @@ import { SecurityRedactor } from '../security/redactor.js';
 import { initializeKeys, sign } from '../proof/signer.js';
 import { canonicalize } from '../proof/canonicalize.js';
 import { EvidenceVault } from '../vault/index.js';
+import { AuthManager } from '../auth/index.js';
+import { FlakinessDetector, FlakinessCategory, formatFlakinessScore, generateTestId, DEFAULT_FLAKINESS_OPTIONS } from '../flakiness/index.js';
 export class Phase3Runner {
     workingDir;
     pack;
@@ -23,25 +26,165 @@ export class Phase3Runner {
     hooksRunner;
     keyPair;
     vault;
+    authManager;
+    authCredentialsCache = new Map();
+    flakyDetect;
+    flakyRuns;
+    flakinessDetector;
     constructor(options) {
         this.workingDir = options.workingDir;
         this.pack = options.pack;
         this.outputDir = options.outputDir || join(this.workingDir, '.qa360', 'runs');
         this.redactor = SecurityRedactor.forLogs();
+        this.authManager = new AuthManager();
+        this.flakyDetect = options.flakyDetect || false;
+        this.flakyRuns = options.flakyRuns || DEFAULT_FLAKINESS_OPTIONS.consecutiveRuns;
+        this.flakinessDetector = new FlakinessDetector({
+            consecutiveRuns: this.flakyRuns,
+            minRuns: 2,
+            enablePatternDetection: true
+        });
+        // Initialize hooks runner (convert v2 hooks to v1 format if needed)
+        const hooks = this.isPackV2(options.pack)
+            ? this.convertV2HooksToV1(options.pack.hooks)
+            : options.pack.hooks;
         this.hooksRunner = new HooksRunner({
             workingDir: this.workingDir,
-            hooks: this.pack.hooks || {},
-            execution: this.pack.execution,
+            hooks: hooks || {},
+            execution: this.isPackV2(options.pack) ? this.convertV2ExecutionToV1(options.pack.execution) : options.pack.execution,
             redactor: this.redactor
         });
+        // Register auth profiles from pack v2
+        if (this.isPackV2(options.pack) && options.pack.auth?.profiles) {
+            this.registerAuthProfiles(options.pack.auth.profiles);
+        }
+    }
+    /**
+     * Type guard to check if pack is v2
+     */
+    isPackV2(pack) {
+        return pack.version === 2;
+    }
+    /**
+     * Register authentication profiles from pack config
+     */
+    registerAuthProfiles(profiles) {
+        for (const [name, profile] of Object.entries(profiles)) {
+            // Convert v2 auth profile to auth module format
+            const authConfig = {
+                type: profile.type || 'none',
+                ...profile.config
+            };
+            this.authManager.registerProfile(name, authConfig);
+        }
+    }
+    /**
+     * Get auth profile name for a specific gate
+     */
+    getAuthProfileForGate(gateName) {
+        if (!this.isPackV2(this.pack) || !this.pack.auth) {
+            return undefined;
+        }
+        const authConfig = this.pack.auth;
+        // Check if gate has specific auth override
+        const gateConfig = this.pack.gates[gateName];
+        if (gateConfig?.auth) {
+            return gateConfig.auth;
+        }
+        // Use default based on gate type
+        if (gateName === 'api_smoke' || gateName === 'api') {
+            return authConfig.api;
+        }
+        if (gateName === 'ui' || gateName === 'a11y') {
+            return authConfig.ui;
+        }
+        return undefined;
+    }
+    /**
+     * Authenticate and get credentials for a gate
+     */
+    async getCredentialsForGate(gateName) {
+        const profileName = this.getAuthProfileForGate(gateName);
+        if (!profileName) {
+            return undefined;
+        }
+        // Check cache first
+        if (this.authCredentialsCache.has(profileName)) {
+            return this.authCredentialsCache.get(profileName);
+        }
+        // Authenticate
+        const result = await this.authManager.authenticate(profileName);
+        if (result.success && result.credentials) {
+            this.authCredentialsCache.set(profileName, result.credentials);
+            return result.credentials;
+        }
+        console.log(chalk.yellow(`    ⚠️  Auth failed for profile '${profileName}': ${result.error}`));
+        return undefined;
+    }
+    /**
+     * Convert v2 hooks to v1 format
+     */
+    convertV2HooksToV1(hooks) {
+        if (!hooks)
+            return undefined;
+        // v2 hooks use { type, command, ... } format
+        // v1 hooks use { run, timeout } format
+        const converted = {
+            beforeAll: [],
+            afterAll: [],
+            beforeEach: [],
+            afterEach: []
+        };
+        for (const [phase, phaseHooks] of Object.entries(hooks)) {
+            if (Array.isArray(phaseHooks)) {
+                converted[phase] = phaseHooks.map((h) => {
+                    if (h.type === 'run' || h.type === 'script') {
+                        return { run: h.command, timeout: h.timeout, cwd: h.cwd, env: h.env };
+                    }
+                    if (h.type === 'wait_on') {
+                        return { run: `npx wait-on ${h.wait_for?.resource || h.command}`, timeout: h.timeout };
+                    }
+                    if (h.type === 'docker') {
+                        return { run: `docker compose ${h.compose?.command || 'up -d'}`, timeout: h.timeout };
+                    }
+                    return h;
+                });
+            }
+        }
+        return converted;
+    }
+    /**
+     * Convert v2 execution config to v1 format
+     */
+    convertV2ExecutionToV1(execution) {
+        if (!execution)
+            return undefined;
+        return {
+            timeout: execution.default_timeout || execution.timeout,
+            max_retries: execution.default_retries || execution.retries,
+            on_failure: execution.on_failure || 'continue'
+        };
+    }
+    /**
+     * Get gates array from pack (handles v1 and v2)
+     */
+    getGatesArray() {
+        if (this.isPackV2(this.pack)) {
+            return Object.keys(this.pack.gates).filter(gateName => {
+                const gateConfig = this.pack.gates[gateName];
+                return gateConfig?.enabled !== false;
+            });
+        }
+        return this.pack.gates || [];
     }
     /**
      * Execute complete Phase 3 workflow
      */
     async run() {
         const startTime = Date.now();
+        const gatesArray = this.getGatesArray();
         console.log(chalk.bold.blue(`\n🚀 QA360 Phase 3 Runner - ${this.pack.name}`));
-        console.log(chalk.gray(`Gates: ${this.pack.gates.join(', ')}`));
+        console.log(chalk.gray(`Gates: ${gatesArray.join(', ')}`));
         try {
             // Ensure output directory exists
             this.ensureOutputDir();
@@ -65,7 +208,7 @@ export class Phase3Runner {
             // Execute gates
             console.log(chalk.blue('\n🎯 Phase 2: Quality Gates'));
             const gateResults = [];
-            for (const gate of this.pack.gates) {
+            for (const gate of gatesArray) {
                 const gateResult = await this.executeGate(gate);
                 gateResults.push(gateResult);
                 // Check if gate failed and should stop
@@ -74,6 +217,20 @@ export class Phase3Runner {
                     break;
                 }
             }
+            // Flakiness Detection Phase (Vision 2.0)
+            let flakinessResults;
+            if (this.flakyDetect) {
+                console.log(chalk.blue(`\n🎲 Phase 2.5: Flakiness Detection (${this.flakyRuns} consecutive runs)`));
+                flakinessResults = await this.detectFlakiness(gateResults);
+                // Display flakiness summary
+                const unstableCount = flakinessResults.filter(f => f.category === FlakinessCategory.UNSTABLE || f.category === FlakinessCategory.SHAKY).length;
+                if (unstableCount > 0) {
+                    console.log(chalk.yellow(`   ⚠️  ${unstableCount} test(s) show flaky behavior`));
+                }
+                else {
+                    console.log(chalk.green('   ✅ All tests stable - no flakiness detected'));
+                }
+            }
             // Execute afterAll hooks
             console.log(chalk.blue('\n🔗 Phase 3: Cleanup Hooks'));
             const afterAllResults = await this.hooksRunner.executeHooks('afterAll');
@@ -98,8 +255,8 @@ export class Phase3Runner {
             });
             // Save to Evidence Vault
             console.log(chalk.blue('\n💾 Phase 5: Evidence Storage'));
-            const runId = proofPath.split('/').pop()?.replace('-proof.json', '') || 'unknown';
-            await this.saveToVault(runId, {
+            const proofRunId = proofPath.split('/').pop()?.replace('-proof.json', '') || 'unknown';
+            const vaultRunId = await this.saveToVault(proofRunId, {
                 success,
                 pack: this.pack,
                 duration,
@@ -112,13 +269,31 @@ export class Phase3Runner {
                 },
                 summary,
                 proofPath
-            }, proofPath);
+            }, proofPath, flakinessResults);
             // Final summary
             console.log(chalk.blue('\n📊 Execution Summary'));
             console.log(`  Duration: ${duration}ms`);
             console.log(`  Gates: ${summary.passed}/${summary.total} passed`);
             console.log(`  Trust Score: ${summary.trustScore}%`);
             console.log(`  Proof: ${proofPath}`);
+            // Display flakiness details if enabled
+            if (flakinessResults && flakinessResults.length > 0) {
+                console.log(chalk.blue('\n🎲 Flakiness Scores:'));
+                for (const f of flakinessResults) {
+                    const scoreFormatted = formatFlakinessScore(f.score);
+                    const categoryMeta = {
+                        [FlakinessCategory.LEGENDARY]: { emoji: '🟢', color: chalk.green },
+                        [FlakinessCategory.SOLID]: { emoji: '🟢', color: chalk.green },
+                        [FlakinessCategory.GOOD]: { emoji: '🟡', color: chalk.yellow },
+                        [FlakinessCategory.SHAKY]: { emoji: '🟠', color: chalk.hex('#F97316') },
+                        [FlakinessCategory.UNSTABLE]: { emoji: '🔴', color: chalk.red }
+                    }[f.category];
+                    console.log(`  ${categoryMeta.color(`${f.testName}: ${scoreFormatted}`)} (${f.successfulRuns}/${f.totalRuns} passes)`);
+                    if (f.suggestedFix) {
+                        console.log(chalk.gray(`     💡 ${f.suggestedFix}`));
+                    }
+                }
+            }
             if (success) {
                 console.log(chalk.green('\n✅ All quality gates passed!'));
             }
@@ -137,7 +312,9 @@ export class Phase3Runner {
                     afterAll: afterAllResults
                 },
                 summary,
-                proofPath
+                flakiness: flakinessResults,
+                proofPath,
+                runId: vaultRunId
             };
         }
         catch (error) {
@@ -169,9 +346,17 @@ export class Phase3Runner {
         try {
             let result;
             let adapter;
+            // Check if this is a v2 pack with dynamic gate configuration
+            if (this.isPackV2(this.pack)) {
+                const gateConfig = this.pack.gates[gate];
+                if (gateConfig) {
+                    return await this.executeDynamicGate(gate, gateConfig);
+                }
+            }
+            // Legacy v1 gates or predefined gates
             switch (gate) {
                 case 'api_smoke':
-                    adapter = 'playwright-api';
+                    adapter = 'playwright-native-api';
                     result = await this.runApiSmokeGate();
                     break;
                 case 'ui':
@@ -231,33 +416,184 @@ export class Phase3Runner {
             };
         }
     }
+    /**
+     * Execute a dynamic v2 gate
+     */
+    async executeDynamicGate(gateName, gateConfig) {
+        const startTime = Date.now();
+        const adapterType = gateConfig.adapter || gateConfig.type;
+        if (!adapterType) {
+            throw new Error(`Gate '${gateName}' must specify an adapter`);
+        }
+        // Get auth credentials for this gate
+        const credentials = await this.getCredentialsForGate(gateName);
+        // Map adapter type to implementation
+        let result;
+        switch (adapterType) {
+            case 'playwright-api':
+                result = await this.executePlaywrightApiGate(gateName, gateConfig, credentials);
+                break;
+            case 'playwright-ui':
+                result = await this.executePlaywrightUiGate(gateName, gateConfig, credentials);
+                break;
+            case 'k6':
+            case 'k6-perf':
+                result = await this.executeK6PerfGate(gateName, gateConfig);
+                break;
+            case 'semgrep':
+            case 'sast':
+                result = await this.executeSemgrepSastGate(gateName, gateConfig);
+                break;
+            default:
+                throw new Error(`Unsupported adapter: '${adapterType}' for gate '${gateName}'`);
+        }
+        // Set duration
+        result.duration = Date.now() - startTime;
+        // Log result
+        if (result.success) {
+            console.log(chalk.green(`    ✅ ${gateName} passed (${result.duration}ms)`));
+        }
+        else {
+            console.log(chalk.red(`    ❌ ${gateName} failed (${result.duration}ms)`));
+            if (result.error) {
+                console.log(chalk.red(`    🔍 ${result.error}`));
+            }
+        }
+        return result;
+    }
+    /**
+     * Execute Playwright API gate with v2 config
+     * Uses PlaywrightNativeApiAdapter for zero-overhead HTTP testing
+     */
+    async executePlaywrightApiGate(gateName, gateConfig, credentials) {
+        const { PlaywrightNativeApiAdapter } = await import('../adapters/playwright-native-api.js');
+        const adapter = new PlaywrightNativeApiAdapter();
+        // Transform v2 config to adapter format
+        const gateConfigData = gateConfig.config || {};
+        const config = {
+            target: {
+                baseUrl: gateConfigData.baseUrl,
+                smoke: gateConfigData.smoke
+            },
+            budgets: gateConfigData.budgets,
+            timeout: gateConfigData.timeout,
+            retries: gateConfigData.retries,
+            auth: credentials
+        };
+        const result = await adapter.runSmokeTests(config);
+        return {
+            gate: gateName,
+            success: result.success,
+            duration: 0, // Will be set by caller
+            adapter: 'playwright-native-api',
+            results: result,
+            junit: result.junit
+        };
+    }
+    /**
+     * Execute Playwright UI gate with v2 config
+     */
+    async executePlaywrightUiGate(gateName, gateConfig, credentials) {
+        const { PlaywrightUiAdapter } = await import('../adapters/playwright-ui.js');
+        const adapter = new PlaywrightUiAdapter();
+        // Transform v2 config to adapter format
+        // v2: { baseUrl, pages } -> adapter expects: { target: { baseUrl, pages } }
+        const gateConfigData = gateConfig.config || {};
+        const pages = gateConfigData.pages ||
+            (gateConfigData.baseUrl ? [gateConfigData.baseUrl] : undefined);
+        const config = {
+            target: {
+                baseUrl: gateConfigData.baseUrl,
+                pages: pages
+            },
+            budgets: gateConfigData.budgets,
+            timeout: gateConfigData.timeout,
+            auth: credentials
+        };
+        const result = await adapter.runSmokeTests(config);
+        return {
+            gate: gateName,
+            success: result.success,
+            duration: 0, // Will be set by caller
+            adapter: 'playwright-ui',
+            results: result,
+            junit: result.junit
+        };
+    }
+    /**
+     * Execute K6 Performance gate with v2 config
+     */
+    async executeK6PerfGate(gateName, gateConfig) {
+        const { K6PerfAdapter } = await import('../adapters/k6-perf.js');
+        const adapter = new K6PerfAdapter(this.workingDir);
+        const config = {
+            baseUrl: gateConfig.config?.baseUrl,
+            ...gateConfig.config
+        };
+        const result = await adapter.runPerfTest(config);
+        return {
+            gate: gateName,
+            success: result.success,
+            duration: 0,
+            adapter: 'k6',
+            results: result,
+            junit: result.junit
+        };
+    }
+    /**
+     * Execute Semgrep SAST gate with v2 config
+     */
+    async executeSemgrepSastGate(gateName, gateConfig) {
+        const { SemgrepSastAdapter } = await import('../adapters/semgrep-sast.js');
+        const adapter = new SemgrepSastAdapter();
+        const config = {
+            workingDir: this.workingDir,
+            ...gateConfig.config
+        };
+        const result = await adapter.runSastScan(config);
+        return {
+            gate: gateName,
+            success: result.success,
+            duration: 0,
+            adapter: 'semgrep',
+            results: result,
+            junit: result.junit
+        };
+    }
     /**
      * Run API smoke gate
+     * Uses PlaywrightNativeApiAdapter for zero-overhead HTTP testing
      */
     async runApiSmokeGate() {
-        if (!this.pack.targets?.api) {
-            throw new Error('API smoke gate requires targets.api configuration');
+        const target = this.getTargetApi();
+        if (!target) {
+            throw new Error('API smoke gate requires targets.api configuration or gate config with baseUrl');
         }
-        const adapter = new PlaywrightApiAdapter();
+        const credentials = await this.getCredentialsForGate('api_smoke');
+        const adapter = new PlaywrightNativeApiAdapter();
         return await adapter.runSmokeTests({
-            target: this.pack.targets.api,
-            budgets: this.pack.budgets,
-            timeout: this.pack.execution?.timeout || 10000,
-            retries: this.pack.execution?.max_retries || 1
+            target,
+            budgets: this.getBudgets(),
+            timeout: this.getExecutionTimeout() || 10000,
+            retries: this.getExecutionRetries() || 1,
+            auth: credentials
         });
     }
     /**
      * Run UI gate (includes basic accessibility)
      */
     async runUiGate() {
-        if (!this.pack.targets?.web) {
-            throw new Error('UI gate requires targets.web configuration');
+        const target = this.getTargetWeb();
+        if (!target) {
+            throw new Error('UI gate requires targets.web configuration or gate config with baseUrl');
         }
+        const credentials = await this.getCredentialsForGate('ui');
         const adapter = new PlaywrightUiAdapter();
         return await adapter.runSmokeTests({
-            target: this.pack.targets.web,
-            budgets: this.pack.budgets,
-            timeout: this.pack.execution?.timeout || 30000
+            target,
+            budgets: this.getBudgets(),
+            timeout: this.getExecutionTimeout() || 30000,
+            auth: credentials
         });
     }
     /**
@@ -415,11 +751,12 @@ export class Phase3Runner {
     }
     /**
      * Save run results to Evidence Vault
+     * @returns The vault run ID
      */
-    async saveToVault(runId, result, proofPath) {
+    async saveToVault(runId, result, proofPath, flakinessResults) {
         if (!this.vault) {
             console.log(chalk.yellow('   ⚠️  Vault not initialized, skipping storage'));
-            return;
+            return undefined;
         }
         try {
             // Begin run in vault (returns actual runId used)
@@ -451,11 +788,152 @@ export class Phase3Runner {
                     });
                 }
             }
+            // Record flakiness results if available
+            if (flakinessResults && flakinessResults.length > 0) {
+                for (const flaky of flakinessResults) {
+                    // Record unstable/shaky tests as findings
+                    if (flaky.category === FlakinessCategory.UNSTABLE || flaky.category === FlakinessCategory.SHAKY) {
+                        await this.vault.recordFinding(vaultRunId, {
+                            gate: flaky.gate,
+                            severity: flaky.category === FlakinessCategory.UNSTABLE ? 'high' : 'medium',
+                            rule: 'flaky-test-detected',
+                            message: `Test "${flaky.testName}" is ${flaky.category}: ${flaky.score}% reliability (${flaky.successfulRuns}/${flaky.totalRuns} passes)`
+                        });
+                    }
+                }
+                console.log(chalk.green(`   💾 ${flakinessResults.length} flakiness analysis(es) saved`));
+            }
             console.log(chalk.green('   💾 Run saved to Evidence Vault'));
+            return vaultRunId;
         }
         catch (error) {
             console.log(chalk.yellow(`   ⚠️  Failed to save to vault: ${error}`));
+            return undefined;
+        }
+    }
+    /**
+     * Detect flakiness by running tests multiple times consecutively
+     * @param gateResults Original gate results from first run
+     * @returns Flakiness analysis results
+     */
+    async detectFlakiness(gateResults) {
+        const flakinessMap = new Map();
+        const timestamp = Date.now();
+        // First, collect results from the initial run
+        for (const gateResult of gateResults) {
+            for (const [testId, testResult] of this.extractTestResults(gateResult, timestamp)) {
+                if (!flakinessMap.has(testId)) {
+                    flakinessMap.set(testId, []);
+                }
+                flakinessMap.get(testId).push(testResult);
+            }
+        }
+        // Run additional consecutive runs
+        for (let run = 1; run < this.flakyRuns; run++) {
+            console.log(chalk.gray(`     🔄 Consecutive run ${run + 1}/${this.flakyRuns}...`));
+            for (const gateResult of gateResults) {
+                // Re-run all gates to detect flakiness
+                try {
+                    const retryResult = await this.executeGate(gateResult.gate);
+                    // Extract and store test results
+                    for (const [testId, testResult] of this.extractTestResults(retryResult, timestamp)) {
+                        if (!flakinessMap.has(testId)) {
+                            flakinessMap.set(testId, []);
+                        }
+                        flakinessMap.get(testId).push(testResult);
+                    }
+                }
+                catch (error) {
+                    console.log(chalk.yellow(`     ⚠️  Failed to re-run ${gateResult.gate}: ${error}`));
+                }
+            }
+        }
+        // Analyze all collected results
+        return this.flakinessDetector.analyzeAll(flakinessMap);
+    }
+    /**
+     * Extract test results from a gate result
+     * Returns a map of testId to TestResult for flakiness tracking
+     */
+    extractTestResults(gateResult, timestamp) {
+        const results = new Map();
+        // Extract test results from adapter output
+        const adapterResults = gateResult.results;
+        if (adapterResults?.results && Array.isArray(adapterResults.results)) {
+            // Check for Playwright Native API adapter format
+            const firstResult = adapterResults.results[0];
+            if (firstResult && 'endpoint' in firstResult && 'method' in firstResult) {
+                // PlaywrightNativeApiAdapter format: { endpoint, method, status, success, error, ... }
+                for (const test of adapterResults.results) {
+                    // Extract just the path from full URL for cleaner test names
+                    const url = new URL(test.endpoint);
+                    const path = url.pathname + url.search;
+                    const testName = `${test.method} ${path} -> ${test.status}`;
+                    const testId = generateTestId(testName, gateResult.gate);
+                    results.set(testId, {
+                        testId,
+                        testName,
+                        filePath: gateResult.gate,
+                        gate: gateResult.gate,
+                        success: test.success,
+                        durationMs: test.responseTime || 0,
+                        errorMessage: test.error,
+                        timestamp: timestamp + Math.random(), // Small offset for ordering
+                        environment: process.env.NODE_ENV || 'local'
+                    });
+                }
+            }
+            else {
+                // Generic adapter format with results array
+                for (const test of adapterResults.results) {
+                    const testName = test.name || gateResult.gate;
+                    const testId = generateTestId(testName, gateResult.gate);
+                    results.set(testId, {
+                        testId,
+                        testName,
+                        filePath: gateResult.gate,
+                        gate: gateResult.gate,
+                        success: test.passed || test.status === 'passed',
+                        durationMs: test.duration || 0,
+                        errorType: test.error?.type,
+                        errorMessage: test.error?.message,
+                        timestamp: timestamp + Math.random(),
+                        environment: process.env.NODE_ENV || 'local'
+                    });
+                }
+            }
+        }
+        else if (adapterResults?.summary) {
+            // Generic adapter with summary only (no detailed results)
+            const testId = generateTestId(gateResult.gate, gateResult.gate);
+            results.set(testId, {
+                testId,
+                testName: gateResult.gate,
+                filePath: gateResult.gate,
+                gate: gateResult.gate,
+                success: gateResult.success,
+                durationMs: gateResult.duration,
+                errorMessage: gateResult.error,
+                timestamp,
+                environment: process.env.NODE_ENV || 'local'
+            });
         }
+        else {
+            // Fallback: create single test result from gate
+            const testId = generateTestId(gateResult.gate, gateResult.gate);
+            results.set(testId, {
+                testId,
+                testName: gateResult.gate,
+                filePath: gateResult.gate,
+                gate: gateResult.gate,
+                success: gateResult.success,
+                durationMs: gateResult.duration,
+                errorMessage: gateResult.error,
+                timestamp,
+                environment: process.env.NODE_ENV || 'local'
+            });
+        }
+        return results;
     }
     /**
      * Generate hash of pack configuration
@@ -466,6 +944,63 @@ export class Phase3Runner {
             .digest('hex')
             .substring(0, 16);
     }
+    /**
+     * Get API target (v1 or v2 format)
+     */
+    getTargetApi() {
+        if (this.isPackV2(this.pack)) {
+            // In v2, target is in the gate config
+            const gateConfig = this.pack.gates['api_smoke'] || this.pack.gates['api'];
+            if (gateConfig && gateConfig.config?.baseUrl) {
+                return gateConfig.config;
+            }
+            return undefined;
+        }
+        return this.pack.targets?.api;
+    }
+    /**
+     * Get Web target (v1 or v2 format)
+     */
+    getTargetWeb() {
+        if (this.isPackV2(this.pack)) {
+            // In v2, target is in the gate config
+            const gateConfig = this.pack.gates['ui'] || this.pack.gates['a11y'];
+            if (gateConfig && gateConfig.config?.baseUrl) {
+                return gateConfig.config;
+            }
+            return undefined;
+        }
+        return this.pack.targets?.web;
+    }
+    /**
+     * Get budgets (v1 or v2 format)
+     */
+    getBudgets() {
+        if (this.isPackV2(this.pack)) {
+            // In v2, budgets can be in gate config or global
+            // For now, return undefined - budgets are gate-specific in v2
+            return undefined;
+        }
+        return this.pack.budgets;
+    }
+    /**
+     * Get execution timeout (v1 or v2 format)
+     */
+    getExecutionTimeout() {
+        if (this.isPackV2(this.pack)) {
+            return this.pack.execution?.default_timeout;
+        }
+        return this.pack.execution?.timeout;
+    }
+    /**
+     * Get execution retries (v1 or v2 format)
+     */
+    getExecutionRetries() {
+        if (this.isPackV2(this.pack)) {
+            return this.pack.execution?.default_retries;
+        }
+        return this.pack.execution?.max_retries;
+    }
     /**
      * Ensure output directory exists
      */