@yasserkhanorg/impact-gate 2.0.0

package/dist/agent/pipeline.js

@@ -0,0 +1,260 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTargetedSpecHeal = runTargetedSpecHeal;
+exports.runPlaywrightPipeline = runPlaywrightPipeline;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const utils_js_1 = require("./utils.js");
+const pipeline_utils_js_1 = require("./pipeline_utils.js");
+const api_catalog_js_1 = require("./api_catalog.js");
+const process_runner_js_1 = require("./process_runner.js");
+const native_flow_js_1 = require("./native_flow.js");
+const llm_agents_flow_js_1 = require("./llm_agents_flow.js");
+function hasE2eTestGenCLI(testsRoot) {
+    const cliPath = (0, path_1.join)(testsRoot, 'e2e-test-gen-cli.ts');
+    return (0, fs_1.existsSync)(cliPath) ? cliPath : null;
+}
+function runTargetedSpecHeal(testsRoot, targets, pipeline) {
+    const warnings = new Set();
+    const results = [];
+    const mcp = (0, pipeline_utils_js_1.createMcpStatus)('package-native', Boolean(pipeline.mcp));
+    if (targets.length === 0) {
+        warnings.add('No targeted specs provided for heal.');
+        return (0, pipeline_utils_js_1.finalizePipelineSummary)({
+            runner: 'package-native',
+            results,
+            warnings: Array.from(warnings),
+            mcp,
+        });
+    }
+    const playwrightBinary = pipeline.heal ? (0, process_runner_js_1.resolvePlaywrightBinary)(testsRoot) : null;
+    const seedFile = (0, llm_agents_flow_js_1.resolveAgentSeedSpec)(testsRoot) || 'specs/seed.spec.ts';
+    const apiSurface = (0, api_catalog_js_1.buildApiSurfaceCatalog)(testsRoot, seedFile);
+    if (pipeline.heal && !playwrightBinary) {
+        warnings.add('Playwright binary was not found. Targeted heal uses static quality checks without runtime compile validation.');
+    }
+    for (const target of targets) {
+        const inputPath = target.specPath || '';
+        const absoluteSpecPath = (0, utils_js_1.normalizePath)((0, path_1.resolve)(testsRoot, inputPath));
+        if (!(0, utils_js_1.isPathWithinRoot)(testsRoot, absoluteSpecPath)) {
+            results.push({
+                flowId: inputPath || 'unknown',
+                flowName: inputPath || 'Unknown Spec',
+                generatedDir: (0, utils_js_1.normalizePath)((0, path_1.dirname)(absoluteSpecPath)),
+                generateStatus: 'failed',
+                healStatus: pipeline.heal ? 'failed' : undefined,
+                error: `Targeted spec resolves outside testsRoot: ${inputPath}`,
+            });
+            continue;
+        }
+        if (!(0, fs_1.existsSync)(absoluteSpecPath)) {
+            results.push({
+                flowId: inputPath || 'unknown',
+                flowName: inputPath || 'Unknown Spec',
+                generatedDir: (0, utils_js_1.normalizePath)((0, path_1.dirname)(absoluteSpecPath)),
+                generateStatus: 'failed',
+                healStatus: pipeline.heal ? 'failed' : undefined,
+                error: `Targeted spec does not exist: ${inputPath}`,
+            });
+            continue;
+        }
+        const relativeSpecPath = (0, utils_js_1.normalizePath)((0, path_1.relative)(testsRoot, absoluteSpecPath));
+        if (!/\.(spec|test)\.[tj]sx?$/.test(relativeSpecPath)) {
+            warnings.add(`Skipping non-spec target path: ${relativeSpecPath}`);
+            results.push({
+                flowId: relativeSpecPath,
+                flowName: relativeSpecPath,
+                generatedDir: (0, utils_js_1.normalizePath)((0, path_1.dirname)(absoluteSpecPath)),
+                generateStatus: 'skipped',
+                healStatus: pipeline.heal ? 'skipped' : undefined,
+            });
+            continue;
+        }
+        if (pipeline.dryRun) {
+            results.push({
+                flowId: relativeSpecPath,
+                flowName: relativeSpecPath,
+                generatedDir: (0, utils_js_1.normalizePath)((0, path_1.dirname)(absoluteSpecPath)),
+                generateStatus: 'skipped',
+                healStatus: pipeline.heal ? 'skipped' : undefined,
+            });
+            continue;
+        }
+        const syntheticFlow = (0, pipeline_utils_js_1.buildSyntheticFlowFromSpecTarget)(relativeSpecPath, target);
+        results.push((0, native_flow_js_1.runPackageNativeFlow)(testsRoot, syntheticFlow, pipeline, (0, utils_js_1.normalizePath)((0, path_1.dirname)(absoluteSpecPath)), absoluteSpecPath, playwrightBinary, apiSurface));
+    }
+    return (0, pipeline_utils_js_1.finalizePipelineSummary)({
+        runner: 'package-native',
+        results,
+        warnings: Array.from(warnings),
+        mcp,
+    });
+}
+function runPlaywrightPipeline(testsRoot, flows, pipeline) {
+    const mcpFallbackWarnings = [];
+    // MCP-only mode requires MCP to be enabled
+    if (pipeline.mcpOnly && !pipeline.mcp) {
+        const warnings = [
+            '❌ MCP-Only Mode Error: --pipeline-mcp-only requires --pipeline-mcp flag',
+            'Run with: npm run gen:tests -- --pipeline-mcp',
+        ];
+        return (0, pipeline_utils_js_1.finalizePipelineSummary)({
+            runner: 'unknown',
+            results: [],
+            warnings,
+            mcp: (0, pipeline_utils_js_1.createMcpStatus)('unknown', false),
+        });
+    }
+    if (pipeline.mcp) {
+        const agentsSummary = (0, llm_agents_flow_js_1.runPlaywrightAgentsPipeline)(testsRoot, flows, pipeline);
+        if (agentsSummary.runner !== 'unknown' || agentsSummary.results.length > 0) {
+            return (0, pipeline_utils_js_1.finalizePipelineSummary)(agentsSummary);
+        }
+        // Handle strict MCP-only mode
+        if (pipeline.mcpOnly) {
+            const warnings = [
+                ...agentsSummary.warnings,
+                '❌ MCP-Only Mode Error: Claude Code CLI / Playwright Agents MCP is not available',
+                'Please install Claude Code CLI: brew install anthropic/tap/claude-code',
+                'Or check that the MCP server is properly configured',
+            ];
+            return (0, pipeline_utils_js_1.finalizePipelineSummary)({
+                runner: 'unknown',
+                results: agentsSummary.results,
+                warnings,
+                mcp: (0, pipeline_utils_js_1.createMcpStatus)('unknown', true),
+            });
+        }
+        if (!pipeline.mcpAllowFallback) {
+            const warnings = [
+                ...agentsSummary.warnings,
+                'Official Playwright MCP mode is strict; fallback generation is disabled unless pipeline.mcpAllowFallback=true.',
+            ];
+            return (0, pipeline_utils_js_1.finalizePipelineSummary)({
+                runner: 'unknown',
+                results: agentsSummary.results,
+                warnings,
+                mcp: (0, pipeline_utils_js_1.createMcpStatus)('unknown', true),
+            });
+        }
+        mcpFallbackWarnings.push(...agentsSummary.warnings);
+    }
+    const cliPath = hasE2eTestGenCLI(testsRoot);
+    if (!cliPath) {
+        return (0, pipeline_utils_js_1.finalizePipelineSummary)((0, native_flow_js_1.runPackageNativePipeline)(testsRoot, flows, pipeline, mcpFallbackWarnings));
+    }
+    const warnings = [...mcpFallbackWarnings];
+    const results = [];
+    const outputBase = (0, path_1.resolve)(testsRoot, pipeline.outputDir || 'specs/functional/ai-assisted');
+    if (!(0, utils_js_1.isPathWithinRoot)(testsRoot, outputBase)) {
+        warnings.push(`Pipeline outputDir resolves outside testsRoot and was blocked: ${pipeline.outputDir}`);
+        return (0, pipeline_utils_js_1.finalizePipelineSummary)({
+            runner: 'unknown',
+            results,
+            warnings,
+            mcp: (0, pipeline_utils_js_1.createMcpStatus)('unknown', Boolean(pipeline.mcp)),
+        });
+    }
+    for (const flow of flows) {
+        if (flow.priority !== 'P0' && flow.priority !== 'P1') {
+            continue;
+        }
+        const slug = flow.id.replace(/[^a-zA-Z0-9._-]+/g, '-');
+        const outputDir = (0, utils_js_1.normalizePath)((0, path_1.join)(outputBase, slug));
+        if (!(0, utils_js_1.isPathWithinRoot)(testsRoot, outputDir)) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                error: 'output directory resolves outside testsRoot',
+            });
+            continue;
+        }
+        if (pipeline.dryRun) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'skipped',
+                healStatus: 'skipped',
+            });
+            continue;
+        }
+        const generateArgs = ['tsx', cliPath, 'generate', flow.name, '--output', outputDir, '--scenarios', `${pipeline.scenarios}`];
+        if (pipeline.baseUrl) {
+            generateArgs.push('--base-url', pipeline.baseUrl);
+        }
+        if (pipeline.headless) {
+            generateArgs.push('--headless');
+        }
+        if (pipeline.browser) {
+            generateArgs.push('--browser', pipeline.browser);
+        }
+        if (pipeline.project) {
+            generateArgs.push('--project', pipeline.project);
+        }
+        if (pipeline.parallel) {
+            generateArgs.push('--parallel');
+        }
+        if (pipeline.mcp) {
+            generateArgs.push('--mcp');
+        }
+        const generateResult = (0, process_runner_js_1.runCommand)('npx', generateArgs, testsRoot);
+        if (generateResult.status !== 0) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                error: (0, process_runner_js_1.summarizeCommandOutput)(generateResult.stdout, generateResult.stderr) || generateResult.error || 'generate failed',
+            });
+            continue;
+        }
+        let healStatus = 'skipped';
+        if (pipeline.heal) {
+            const healArgs = ['tsx', cliPath, 'heal', outputDir];
+            if (pipeline.browser) {
+                healArgs.push('--browser', pipeline.browser);
+            }
+            if (pipeline.project) {
+                healArgs.push('--project', pipeline.project);
+            }
+            if (pipeline.parallel) {
+                healArgs.push('--parallel');
+            }
+            if (pipeline.mcp) {
+                healArgs.push('--mcp');
+            }
+            const healResult = (0, process_runner_js_1.runCommand)('npx', healArgs, testsRoot);
+            healStatus = healResult.status === 0 ? 'success' : 'failed';
+        }
+        const disallowedDescribeFiles = (0, llm_agents_flow_js_1.findDisallowedDescribeFiles)(outputDir);
+        if (disallowedDescribeFiles.length > 0) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                healStatus,
+                error: `Generated tests contain test.describe (disallowed): ${disallowedDescribeFiles.join(', ')}`,
+            });
+            continue;
+        }
+        results.push({
+            flowId: flow.id,
+            flowName: flow.name,
+            generatedDir: outputDir,
+            generateStatus: 'success',
+            healStatus,
+        });
+    }
+    return (0, pipeline_utils_js_1.finalizePipelineSummary)({
+        runner: 'e2e-test-gen',
+        results,
+        warnings,
+        mcp: (0, pipeline_utils_js_1.createMcpStatus)('e2e-test-gen', Boolean(pipeline.mcp)),
+    });
+}

package/dist/agent/pipeline_types.d.ts

@@ -0,0 +1,54 @@
+export interface PipelineResult {
+    flowId: string;
+    flowName: string;
+    generatedDir: string;
+    generateStatus: 'success' | 'skipped' | 'failed';
+    healStatus?: 'success' | 'skipped' | 'failed';
+    error?: string;
+    failureCategory?: 'config' | 'environment' | 'generation' | 'validation' | 'runtime' | 'quality' | 'path-safety' | 'unknown';
+    failureCode?: string;
+}
+export interface PipelineSummary {
+    runner: 'playwright-agents' | 'e2e-test-gen' | 'package-native' | 'unknown';
+    results: PipelineResult[];
+    warnings: string[];
+    mcp?: {
+        requested: boolean;
+        active: boolean;
+        backend: 'playwright-agents' | 'e2e-test-gen' | 'package-native' | 'unknown';
+    };
+}
+export interface SpecHealTarget {
+    specPath: string;
+    status?: 'failed' | 'flaky';
+    reason?: string;
+}
+export type NativeSpecStrategy = 'thread-reply' | 'lifecycle-channel' | 'channel-settings' | 'channel-switch' | 'markdown-post' | 'mentions-post' | 'realtime-post' | 'message-post' | 'channel-baseline' | 'search-baseline' | 'generic-baseline';
+export interface NativeSpecQualityIssue {
+    code: 'disallowed-describe' | 'disallowed-only' | 'missing-test' | 'missing-tag' | 'tag-array-disallowed' | 'unknown-api-surface' | 'fragile-system-console-visibility' | 'fragile-selector';
+    message: string;
+}
+export interface CommandResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+    error?: string;
+}
+export interface ValidationResult {
+    status: 'passed' | 'failed' | 'skipped';
+    detail?: string;
+}
+export interface ApiSurfaceCatalog {
+    pwProps: Set<string>;
+    pwNestedMethods: Map<string, Set<string>>;
+    initSetupKeys: Set<string>;
+    initSetupVariableMethods: Map<string, Set<string>>;
+    testBrowserMethods: Set<string>;
+    channelsPageMembers: Set<string>;
+    sidebarRightMembers: Set<string>;
+}
+export interface InitSetupBinding {
+    key: string;
+    variable: string;
+}
+//# sourceMappingURL=pipeline_types.d.ts.map

package/dist/agent/pipeline_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline_types.d.ts","sourceRoot":"","sources":["../../src/agent/pipeline_types.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,cAAc;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IACjD,UAAU,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,QAAQ,GAAG,aAAa,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAAC;IAC7H,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC5B,MAAM,EAAE,mBAAmB,GAAG,cAAc,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAC5E,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,CAAC,EAAE;QACF,SAAS,EAAE,OAAO,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;QAChB,OAAO,EAAE,mBAAmB,GAAG,cAAc,GAAG,gBAAgB,GAAG,SAAS,CAAC;KAChF,CAAC;CACL;AAED,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,kBAAkB,GACxB,cAAc,GACd,mBAAmB,GACnB,kBAAkB,GAClB,gBAAgB,GAChB,eAAe,GACf,eAAe,GACf,eAAe,GACf,cAAc,GACd,kBAAkB,GAClB,iBAAiB,GACjB,kBAAkB,CAAC;AAEzB,MAAM,WAAW,sBAAsB;IACnC,IAAI,EACE,qBAAqB,GACrB,iBAAiB,GACjB,cAAc,GACd,aAAa,GACb,sBAAsB,GACtB,qBAAqB,GACrB,mCAAmC,GACnC,kBAAkB,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACnD,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAChC,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;CACpB"}

package/dist/agent/pipeline_types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent/pipeline_utils.d.ts

@@ -0,0 +1,12 @@
+import type { FlowImpact } from './types.js';
+import type { NativeSpecStrategy, PipelineResult, PipelineSummary } from './pipeline_types.js';
+import type { SpecHealTarget } from './pipeline_types.js';
+export declare function createMcpStatus(backend: 'playwright-agents' | 'e2e-test-gen' | 'package-native' | 'unknown', requested: boolean): NonNullable<PipelineSummary['mcp']>;
+export declare function classifyPipelineFailure(result: PipelineResult): PipelineResult;
+export declare function finalizePipelineSummary(summary: PipelineSummary): PipelineSummary;
+export declare function toSafeSlug(value: string): string;
+export declare function stripSpecSuffix(value: string): string;
+export declare function buildSyntheticFlowFromSpecTarget(relativeSpecPath: string, target: SpecHealTarget): FlowImpact;
+export declare function firstFlowFiles(flow: FlowImpact): string[];
+export declare function buildNativeStrategyOrder(flow: FlowImpact): NativeSpecStrategy[];
+//# sourceMappingURL=pipeline_utils.d.ts.map

package/dist/agent/pipeline_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline_utils.d.ts","sourceRoot":"","sources":["../../src/agent/pipeline_utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAC,kBAAkB,EAAE,cAAc,EAAE,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAE7F,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,eAAe,CAC3B,OAAO,EAAE,mBAAmB,GAAG,cAAc,GAAG,gBAAgB,GAAG,SAAS,EAC5E,SAAS,EAAE,OAAO,GACnB,WAAW,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAMrC;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CA8B9E;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAKjF;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,gCAAgC,CAAC,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,UAAU,CAqB7G;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAEzD;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,kBAAkB,EAAE,CAmE/E"}

package/dist/agent/pipeline_utils.js

@@ -0,0 +1,156 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpStatus = createMcpStatus;
+exports.classifyPipelineFailure = classifyPipelineFailure;
+exports.finalizePipelineSummary = finalizePipelineSummary;
+exports.toSafeSlug = toSafeSlug;
+exports.stripSpecSuffix = stripSpecSuffix;
+exports.buildSyntheticFlowFromSpecTarget = buildSyntheticFlowFromSpecTarget;
+exports.firstFlowFiles = firstFlowFiles;
+exports.buildNativeStrategyOrder = buildNativeStrategyOrder;
+const path_1 = require("path");
+const utils_js_1 = require("./utils.js");
+function createMcpStatus(backend, requested) {
+    return {
+        requested,
+        active: requested && (backend === 'e2e-test-gen' || backend === 'playwright-agents'),
+        backend,
+    };
+}
+function classifyPipelineFailure(result) {
+    if (result.failureCategory || result.failureCode) {
+        return result;
+    }
+    if (!result.error) {
+        return result;
+    }
+    const errorText = result.error.toLowerCase();
+    if (errorText.includes('etimedout') || errorText.includes('timed out')) {
+        return { ...result, failureCategory: 'environment', failureCode: 'mcp_timeout' };
+    }
+    if (errorText.includes('outside testsroot')) {
+        return { ...result, failureCategory: 'path-safety', failureCode: 'path_outside_tests_root' };
+    }
+    if (errorText.includes('playwright binary') || errorText.includes('not found')) {
+        return { ...result, failureCategory: 'environment', failureCode: 'dependency_missing' };
+    }
+    if (errorText.includes('compile validation')) {
+        return { ...result, failureCategory: 'validation', failureCode: 'compile_validation_failed' };
+    }
+    if (errorText.includes('runtime validation') || errorText.includes('playwright test failed')) {
+        return { ...result, failureCategory: 'runtime', failureCode: 'runtime_validation_failed' };
+    }
+    if (errorText.includes('quality checks failed') || errorText.includes('invalid test content')) {
+        return { ...result, failureCategory: 'quality', failureCode: 'quality_guard_failed' };
+    }
+    if (errorText.includes('generate failed') || errorText.includes('did not produce expected test file')) {
+        return { ...result, failureCategory: 'generation', failureCode: 'generation_failed' };
+    }
+    return { ...result, failureCategory: 'unknown', failureCode: 'unknown' };
+}
+function finalizePipelineSummary(summary) {
+    return {
+        ...summary,
+        results: summary.results.map(classifyPipelineFailure),
+    };
+}
+function toSafeSlug(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'flow';
+}
+function stripSpecSuffix(value) {
+    return value.replace(/\.(spec|test)\.[^.]+$/i, '').replace(/\.[^.]+$/, '');
+}
+function buildSyntheticFlowFromSpecTarget(relativeSpecPath, target) {
+    const normalizedSpecPath = (0, utils_js_1.normalizePath)(relativeSpecPath);
+    const noSuffix = stripSpecSuffix(normalizedSpecPath);
+    const flowId = toSafeSlug(noSuffix.replace(/\//g, '.'));
+    const base = (0, utils_js_1.baseNameWithoutExt)(stripSpecSuffix((0, path_1.basename)(normalizedSpecPath)));
+    const flowName = (0, utils_js_1.titleCase)(base.replace(/[._-]+/g, ' ')) || 'Recovered Spec';
+    const keywords = (0, utils_js_1.uniqueTokens)((0, utils_js_1.tokenize)(noSuffix.replace(/[/.]/g, ' ')));
+    const reasons = [
+        `Playwright report marked this spec as ${target.status || 'unstable'}.`,
+        target.reason || `Auto-heal target: ${normalizedSpecPath}`,
+    ];
+    return {
+        id: flowId,
+        name: flowName,
+        kind: 'flow',
+        score: target.status === 'failed' ? 12 : 9,
+        priority: target.status === 'failed' ? 'P0' : 'P1',
+        reasons,
+        keywords,
+        files: [normalizedSpecPath],
+    };
+}
+function firstFlowFiles(flow) {
+    return (flow.files || []).filter(Boolean).slice(0, 5);
+}
+function buildNativeStrategyOrder(flow) {
+    const flowId = (flow.id || '').toLowerCase();
+    const haystack = [
+        flow.id,
+        flow.name,
+        ...(flow.files || []),
+        ...(flow.reasons || []),
+        ...(flow.keywords || []),
+    ].join(' ').toLowerCase();
+    const strategies = [];
+    if (flowId.includes('search')) {
+        strategies.push('search-baseline');
+    }
+    if (flowId.includes('threads') || flowId.includes('thread')) {
+        strategies.push('thread-reply');
+    }
+    if (flowId.includes('channels.lifecycle')) {
+        strategies.push('lifecycle-channel');
+    }
+    if (flowId.includes('channels.settings')) {
+        strategies.push('channel-settings');
+    }
+    if (flowId.includes('channels.switch')) {
+        strategies.push('channel-switch');
+    }
+    if (flowId.includes('messaging.markdown')) {
+        strategies.push('markdown-post');
+    }
+    if (flowId.includes('messaging.mentions')) {
+        strategies.push('mentions-post');
+    }
+    if (flowId.includes('messaging.realtime')) {
+        strategies.push('realtime-post');
+    }
+    if (/(thread|reply|rhs|sidebar[_-]?right)/.test(haystack)) {
+        strategies.push('thread-reply');
+    }
+    if (/(create|join|leave|invite)/.test(haystack)) {
+        strategies.push('lifecycle-channel');
+    }
+    if (/(settings|preferences)/.test(haystack)) {
+        strategies.push('channel-settings');
+    }
+    if (/(switch|quick\\s*switch)/.test(haystack)) {
+        strategies.push('channel-switch');
+    }
+    if (/(markdown|format)/.test(haystack)) {
+        strategies.push('markdown-post');
+    }
+    if (/(mention|@)/.test(haystack)) {
+        strategies.push('mentions-post');
+    }
+    if (/(realtime|websocket|presence)/.test(haystack)) {
+        strategies.push('realtime-post');
+    }
+    if (/(search|find|spotlight)/.test(haystack)) {
+        strategies.push('search-baseline');
+    }
+    if (/(message|post|realtime|websocket|chat)/.test(haystack)) {
+        strategies.push('message-post');
+    }
+    if (/(channel|navigation|sidebar|switch)/.test(haystack)) {
+        strategies.push('channel-baseline');
+    }
+    strategies.push('generic-baseline');
+    return Array.from(new Set(strategies));
+}

package/dist/agent/plan.d.ts

@@ -0,0 +1,170 @@
+import type { PolicyConfig } from './config.js';
+import type { CrossImpact, Finding, RegressionRisk, StrategyEntry, TestDesign } from '../crew/types.js';
+import type { FlowDecision } from '../validation/output_schema.js';
+export type RecommendedRunSet = 'smoke' | 'targeted' | 'full';
+export type CiAction = 'run-now' | 'must-add-tests' | 'safe-to-merge';
+export interface PolicyEvaluation {
+    riskyFiles: string[];
+    triggeredRules: string[];
+    applied: PolicyConfig;
+}
+export interface DecisionSummary {
+    action: CiAction;
+    title: string;
+    summary: string;
+}
+export interface GapDetail {
+    id: string;
+    name: string;
+    priority: string;
+    reasons: string[];
+    files: string[];
+    existingTests?: string[];
+    missingScenarios?: string[];
+    source?: 'deterministic' | 'ai+deterministic';
+}
+export interface CoveredFlowSummary {
+    id: string;
+    name: string;
+    priority: string;
+    coveredBy: string[];
+    advisoryScenarios?: string[];
+}
+export interface CrewPlanSummary {
+    impactedFlows: number;
+    strategyEntries: number;
+    testDesigns: number;
+    crossImpacts: number;
+    highRiskCrossImpacts: number;
+    regressionRisks: number;
+    findings: number;
+    generatedSpecs: number;
+    manualReviewEntries: number;
+    totalCostUSD: number;
+    totalTokens: number;
+}
+export interface CrewPlanInsights {
+    workflow: string;
+    providerOverride: string;
+    summary: CrewPlanSummary;
+    impactedFlows: FlowDecision[];
+    strategyEntries: StrategyEntry[];
+    testDesigns: TestDesign[];
+    crossImpacts: CrossImpact[];
+    regressionRisks: RegressionRisk[];
+    findings: Finding[];
+    warnings: string[];
+    timings: Record<string, number>;
+}
+export interface PlanReport {
+    schemaVersion: '1.0.0';
+    runId: string;
+    sourceRunId?: string;
+    generatedAt: string;
+    source: 'impact' | 'ai+deterministic';
+    runSet: RecommendedRunSet;
+    confidence: number;
+    reasons: string[];
+    recommendedTests: string[];
+    requiredNewTests: string[];
+    gapDetails: GapDetail[];
+    coveredFlows: CoveredFlowSummary[];
+    policy: PolicyEvaluation;
+    decision: DecisionSummary;
+    enforcement: {
+        mode: PolicyConfig['enforcementMode'];
+        blockOnActions: CiAction[];
+        matchedAction: boolean;
+        shouldFail: boolean;
+        summary: string;
+    };
+    insights?: {
+        flaky?: {
+            highRiskRecommendedTests: Array<{
+                test: string;
+                flakeRate: number;
+                flakeRate7d?: number;
+                flakeRate30d?: number;
+                trend?: 'up' | 'down' | 'stable';
+                subsystem?: string;
+                owners?: string[];
+                quarantine?: boolean;
+                quarantineState?: 'none' | 'active' | 'retire-candidate';
+                lastFailureAt?: string;
+            }>;
+            quarantinedRecommendedTests: string[];
+            ownerMentions?: string[];
+        };
+        qualityGates?: {
+            failed: Array<{
+                name: string;
+                status: 'pass' | 'warn' | 'fail';
+                details?: string;
+            }>;
+            warnings: Array<{
+                name: string;
+                status: 'pass' | 'warn' | 'fail';
+                details?: string;
+            }>;
+        };
+        calibration?: {
+            precision: number;
+            recall: number;
+            falseNegativeRate: number;
+        };
+    };
+    nextActions?: {
+        requiresUserApprovalForGeneration: boolean;
+        runRecommendedTests?: string;
+        runSmokeSuite?: string;
+        runFullSuite?: string;
+        approveAndGenerate?: string;
+        generateMissingTests?: string;
+        healGeneratedTests?: string;
+        commitGeneratedTests?: string;
+        openPullRequest?: string;
+    };
+    crew?: CrewPlanInsights;
+    metrics: {
+        changedFiles: number;
+        impactedFlows: number;
+        p0Flows: number;
+        p1Flows: number;
+        p2Flows: number;
+        coveredFlows?: number;
+        partialFlows?: number;
+        uncoveredP0P1Flows: number;
+        unboundFiles?: number;
+        warnings: number;
+    };
+}
+export interface PlanMetricEvent {
+    schemaVersion: '1.0.0';
+    timestamp: string;
+    runId: string;
+    sourceRunId?: string;
+    action: CiAction;
+    runSet: RecommendedRunSet;
+    confidence: number;
+    changedFiles: number;
+    impactedFlows: number;
+    uncoveredP0P1Flows: number;
+    warnings: number;
+    enforcementMode: PolicyConfig['enforcementMode'];
+    enforcementShouldFail: boolean;
+}
+export interface PlanMetricsSummary {
+    schemaVersion: '1.0.0';
+    generatedAt: string;
+    totalRuns: number;
+    averageConfidence: number;
+    byAction: Record<CiAction, number>;
+    byRunSet: Record<RecommendedRunSet, number>;
+    blockingRecommendations: number;
+    blockingRate: number;
+}
+export declare function appendPlanMetrics(appRoot: string, plan: PlanReport): {
+    eventsPath: string;
+    summaryPath: string;
+};
+//# sourceMappingURL=plan.d.ts.map