@yasserkhanorg/e2e-agents 0.3.3 → 0.3.5

package/dist/cli.js

@@ -76,6 +76,8 @@ function printUsage() {
         'Options:',
         '  --config <path>       Path to e2e-ai-agents.config.json (auto-discovered if present)',
         '  --path <app-root>     Path to the web app (required)',
+        '  --profile <name>     default | mattermost',
+        '  --mattermost         Shortcut for --profile mattermost',
         '  --tests-root <path>   Path to tests root (optional)',
         '  --framework <name>    auto | playwright | cypress | selenium',
         '  --patterns <globs>    Comma-separated test patterns',
@@ -89,20 +91,27 @@ function printUsage() {
         '  --pipeline-base-url   Base URL for Playwright runs',
         '  --pipeline-browser    Browser: chrome|chromium|firefox|webkit',
         '  --pipeline-headless   Run in headless mode',
+        '  --pipeline-headed     Run in headed mode',
         '  --pipeline-project    Playwright project name',
         '  --pipeline-parallel   Enable parallel mode in generator',
         '  --pipeline-dry-run    Do not execute pipeline (report only)',
         '  --pipeline-mcp        Use Playwright MCP server for exploration/healing',
         '  --pipeline-mcp-allow-fallback  Allow non-MCP fallback if official MCP setup fails',
+        '  --pipeline-mcp-only   Require MCP for UI exploration (fail if unavailable)',
+        '  --pipeline-mcp-timeout-ms <n>  Timeout per MCP CLI invocation in milliseconds',
+        '  --pipeline-mcp-retries <n>  Retry count for retryable MCP CLI failures',
         '  --spec <path>         Optional spec PDF for context',
         '  --since <git-ref>     Git ref for impact analysis (default HEAD~1)',
         '  --time <minutes>      Time limit in minutes',
         '  --budget-usd <amount> Max LLM budget in USD',
         '  --budget-tokens <n>   Max LLM tokens',
+        '  --llm-provider <name> LLM provider: auto | anthropic | openai | ollama',
         '  --policy-min-confidence <n>   Minimum confidence for targeted suite',
         '  --policy-safe-merge-confidence <n> Confidence needed for safe-to-merge',
         '  --policy-force-full-on-warnings <n> Escalate to full at warning count',
         '  --policy-risky-patterns <globs>     Comma-separated risky file globs',
+        '  --policy-enforcement-mode <mode>    advisory | warn | block',
+        '  --policy-block-actions <actions>    Comma-separated CI actions to block/warn',
         '  --ci-comment-path <path>            Write CI markdown summary',
         '  --github-output <path>              Write GitHub Actions outputs',
         '  --fail-on-must-add-tests            Exit non-zero on must-add-tests decision',
@@ -170,6 +179,17 @@ function parseArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === '--profile' && next) {
+            if (next === 'default' || next === 'mattermost') {
+                parsed.profile = next;
+            }
+            i += 1;
+            continue;
+        }
+        if (arg === '--mattermost') {
+            parsed.profile = 'mattermost';
+            continue;
+        }
         if (arg === '--tests-root' && next) {
             parsed.testsRoot = next;
             i += 1;
@@ -216,6 +236,20 @@ function parseArgs(argv) {
             parsed.pipelineMcpAllowFallback = true;
             continue;
         }
+        if (arg === '--pipeline-mcp-only') {
+            parsed.pipelineMcpOnly = true;
+            continue;
+        }
+        if (arg === '--pipeline-mcp-timeout-ms' && next) {
+            parsed.pipelineMcpTimeoutMs = Number(next);
+            i += 1;
+            continue;
+        }
+        if (arg === '--pipeline-mcp-retries' && next) {
+            parsed.pipelineMcpRetries = Number(next);
+            i += 1;
+            continue;
+        }
         if (arg === '--pipeline-scenarios' && next) {
             const value = Number(next);
             if (Number.isFinite(value)) {
@@ -246,6 +280,10 @@ function parseArgs(argv) {
             parsed.pipelineHeadless = true;
             continue;
         }
+        if (arg === '--pipeline-headed') {
+            parsed.pipelineHeadless = false;
+            continue;
+        }
         if (arg === '--pipeline-project' && next) {
             parsed.pipelineProject = next;
             i += 1;
@@ -293,6 +331,11 @@ function parseArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === '--llm-provider' && next) {
+            parsed.llmProvider = next;
+            i += 1;
+            continue;
+        }
         if (arg === '--policy-min-confidence' && next) {
             const value = Number(next);
             if (Number.isFinite(value)) {
@@ -322,6 +365,21 @@ function parseArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === '--policy-enforcement-mode' && next) {
+            if (next === 'advisory' || next === 'warn' || next === 'block') {
+                parsed.policyEnforcementMode = next;
+            }
+            i += 1;
+            continue;
+        }
+        if (arg === '--policy-block-actions' && next) {
+            parsed.policyBlockActions = next
+                .split(',')
+                .map((value) => value.trim())
+                .filter((value) => (value === 'run-now' || value === 'must-add-tests' || value === 'safe-to-merge'));
+            i += 1;
+            continue;
+        }
         if (arg === '--ci-comment-path' && next) {
             parsed.ciCommentPath = next;
             i += 1;
@@ -450,8 +508,10 @@ async function main() {
         }
         const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
             path: args.path,
+            profile: args.profile,
             testsRoot: args.testsRoot,
             mode: 'impact',
+            llmProvider: args.llmProvider,
         });
         const reportRoot = config.testsRoot || config.path;
         const raw = JSON.parse((0, fs_1.readFileSync)(args.feedbackInputPath, 'utf-8'));
@@ -485,9 +545,11 @@ async function main() {
         }
         const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
             path: args.path,
+            profile: args.profile,
             testsRoot: args.testsRoot,
             mode: 'impact',
             gitSince: args.gitSince,
+            llmProvider: args.llmProvider,
         });
         const reportRoot = config.testsRoot || config.path;
         const output = (0, traceability_capture_js_1.captureTraceabilityInput)({
@@ -526,8 +588,10 @@ async function main() {
         }
         const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
             path: args.path,
+            profile: args.profile,
             testsRoot: args.testsRoot,
             mode: 'impact',
+            llmProvider: args.llmProvider,
         });
         const reportRoot = config.testsRoot || config.path;
         const raw = JSON.parse((0, fs_1.readFileSync)(args.traceabilityInputPath, 'utf-8'));
@@ -560,8 +624,10 @@ async function main() {
         }
         const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
             path: args.path,
+            profile: args.profile,
             testsRoot: args.testsRoot,
             mode: 'gap',
+            llmProvider: args.llmProvider,
         });
         const result = (0, handoff_js_1.finalizeGeneratedTests)({
             appPath: config.path,
@@ -600,6 +666,7 @@ async function main() {
         }
         const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
             path: args.path,
+            profile: args.profile,
             testsRoot: args.testsRoot,
             mode: 'gap',
             framework: args.framework,
@@ -626,7 +693,9 @@ async function main() {
                 dryRun: args.pipelineDryRun,
                 mcp: args.pipelineMcp,
                 mcpAllowFallback: args.pipelineMcpAllowFallback,
+                mcpOnly: args.pipelineMcpOnly,
             },
+            llmProvider: args.llmProvider,
         });
         if (args.allowFallback) {
             config.impact.allowFallback = true;
@@ -713,6 +782,7 @@ async function main() {
         }
         const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
             path: args.path,
+            profile: args.profile,
             testsRoot: args.testsRoot,
             mode: 'gap',
             framework: args.framework,
@@ -728,7 +798,9 @@ async function main() {
                 dryRun: args.pipelineDryRun,
                 mcp: args.pipelineMcp,
                 mcpAllowFallback: args.pipelineMcpAllowFallback,
+                mcpOnly: args.pipelineMcpOnly,
             },
+            llmProvider: args.llmProvider,
         });
         const reportRoot = config.testsRoot || config.path;
         const unstableSpecs = (0, playwright_report_js_1.extractPlaywrightUnstableSpecs)(args.traceabilityReportPath, [reportRoot, config.path]);
@@ -762,8 +834,10 @@ async function main() {
         process.exit(1);
     }
     const forcePipelineFromApproval = args.command === 'approve-and-generate' || args.command === 'generate';
-    const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
+    const forceAIPipelineFromApproval = args.command === 'approve-and-generate' || args.command === 'generate';
+    const { config, configPath } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
         path: args.path,
+        profile: args.profile,
         testsRoot: args.testsRoot,
         mode: (args.command === 'gap' || args.command === 'approve-and-generate' || args.command === 'generate') ? 'gap' : 'impact',
         framework: args.framework,
@@ -778,6 +852,7 @@ async function main() {
         flowCatalogPath: args.flowCatalogPath,
         specPDF: args.specPDF,
         gitSince: args.gitSince,
+        llmProvider: args.llmProvider,
         pipeline: (args.pipeline || forcePipelineFromApproval)
             ? {
                 enabled: true,
@@ -789,19 +864,26 @@ async function main() {
                 project: args.pipelineProject,
                 parallel: args.pipelineParallel,
                 dryRun: args.pipelineDryRun,
-                mcp: args.pipelineMcp !== undefined ? args.pipelineMcp : forcePipelineFromApproval,
+                mcp: args.pipelineMcp !== undefined ? args.pipelineMcp : forceAIPipelineFromApproval,
                 mcpAllowFallback: args.pipelineMcpAllowFallback,
+                mcpOnly: args.pipelineMcpOnly !== undefined ? args.pipelineMcpOnly : forceAIPipelineFromApproval,
+                mcpCommandTimeoutMs: args.pipelineMcpTimeoutMs,
+                mcpRetries: args.pipelineMcpRetries,
             }
             : undefined,
         policy: args.policyMinConfidence !== undefined ||
             args.policySafeMergeConfidence !== undefined ||
             args.policyWarningsThreshold !== undefined ||
-            (args.policyRiskyPatterns && args.policyRiskyPatterns.length > 0)
+            (args.policyRiskyPatterns && args.policyRiskyPatterns.length > 0) ||
+            args.policyEnforcementMode !== undefined ||
+            (args.policyBlockActions && args.policyBlockActions.length > 0)
             ? {
                 minConfidenceForTargeted: args.policyMinConfidence,
                 safeMergeMinConfidence: args.policySafeMergeConfidence,
                 forceFullOnWarningsAtOrAbove: args.policyWarningsThreshold,
                 riskyFilePatterns: args.policyRiskyPatterns,
+                enforcementMode: args.policyEnforcementMode,
+                blockOnActions: args.policyBlockActions,
             }
             : undefined,
     });
@@ -825,29 +907,39 @@ async function main() {
             appPath: config.path,
             testsRoot: reportRoot,
             sinceRef: config.git.since,
+            configPath,
         });
         const plan = (0, operational_insights_js_1.applyOperationalInsights)(withActions, reportRoot);
         const planPath = (0, plan_js_1.writePlanReport)(reportRoot, plan);
         const summaryMarkdown = (0, plan_js_1.renderCiSummaryMarkdown)(plan);
         const summaryPath = (0, plan_js_1.writeCiSummary)(reportRoot, summaryMarkdown, args.ciCommentPath);
+        const metrics = (0, plan_js_1.appendPlanMetrics)(reportRoot, plan);
         const ghaOutput = args.githubOutputPath || process.env.GITHUB_OUTPUT;
         if (ghaOutput) {
             (0, fs_1.appendFileSync)(ghaOutput, `run_set=${plan.runSet}\n`);
             (0, fs_1.appendFileSync)(ghaOutput, `action=${plan.decision.action}\n`);
             (0, fs_1.appendFileSync)(ghaOutput, `confidence=${plan.confidence}\n`);
+            (0, fs_1.appendFileSync)(ghaOutput, `enforcement_mode=${plan.enforcement.mode}\n`);
+            (0, fs_1.appendFileSync)(ghaOutput, `enforcement_should_fail=${plan.enforcement.shouldFail}\n`);
             (0, fs_1.appendFileSync)(ghaOutput, `recommended_tests_count=${plan.recommendedTests.length}\n`);
             (0, fs_1.appendFileSync)(ghaOutput, `required_new_tests_count=${plan.requiredNewTests.length}\n`);
             (0, fs_1.appendFileSync)(ghaOutput, `plan_path=${planPath}\n`);
             (0, fs_1.appendFileSync)(ghaOutput, `summary_path=${summaryPath}\n`);
+            (0, fs_1.appendFileSync)(ghaOutput, `metrics_events_path=${metrics.eventsPath}\n`);
+            (0, fs_1.appendFileSync)(ghaOutput, `metrics_summary_path=${metrics.summaryPath}\n`);
         }
         // eslint-disable-next-line no-console
         console.log(`Suggested run set: ${plan.runSet} (confidence ${plan.confidence})`);
         // eslint-disable-next-line no-console
         console.log(`Decision: ${plan.decision.action} - ${plan.decision.summary}`);
         // eslint-disable-next-line no-console
+        console.log(`Enforcement: ${plan.enforcement.mode} (shouldFail=${plan.enforcement.shouldFail})`);
+        // eslint-disable-next-line no-console
         console.log(`Plan data: ${planPath}`);
         // eslint-disable-next-line no-console
         console.log(`CI summary: ${summaryPath}`);
+        // eslint-disable-next-line no-console
+        console.log(`Plan metrics: ${metrics.summaryPath}`);
         if (plan.nextActions) {
             // eslint-disable-next-line no-console
             console.log(`Next action (run existing): ${plan.nextActions.runRecommendedTests || plan.nextActions.runSmokeSuite}`);
@@ -856,7 +948,8 @@ async function main() {
             // eslint-disable-next-line no-console
             console.log(`Next action (heal): ${plan.nextActions.healGeneratedTests}`);
         }
-        if (args.failOnMustAddTests && plan.decision.action === 'must-add-tests') {
+        const failOnLegacyFlag = args.failOnMustAddTests && plan.decision.action === 'must-add-tests';
+        if (failOnLegacyFlag || plan.enforcement.shouldFail) {
             process.exit(2);
         }
         return;

package/dist/esm/agent/ai_flow_analysis.js

@@ -0,0 +1,323 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, readFileSync } from 'fs';
+import { isAbsolute, join } from 'path';
+import { LLMProviderFactory } from '../provider_factory.js';
+import { normalizePath, tokenize, uniqueTokens } from './utils.js';
+function extractJson(text) {
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidates = fenced ? [fenced[1], text] : [text];
+    for (const candidate of candidates) {
+        const start = candidate.indexOf('{');
+        const end = candidate.lastIndexOf('}');
+        if (start < 0 || end <= start) {
+            continue;
+        }
+        const raw = candidate.slice(start, end + 1);
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && Array.isArray(parsed.flows)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Ignore parse failure and keep trying other candidates.
+        }
+    }
+    return null;
+}
+function resolveContextFiles(appRoot, testsRoot, files) {
+    const resolved = [];
+    const seen = new Set();
+    const maxCharsPerFile = 12000;
+    const maxTotalChars = 32000;
+    let totalChars = 0;
+    for (const file of files) {
+        const candidates = isAbsolute(file)
+            ? [file]
+            : [join(testsRoot, file), join(appRoot, file)];
+        for (const candidate of candidates) {
+            const normalized = normalizePath(candidate);
+            if (seen.has(normalized) || !existsSync(candidate)) {
+                continue;
+            }
+            const content = readFileSync(candidate, 'utf-8');
+            const trimmed = content.trim();
+            if (!trimmed) {
+                seen.add(normalized);
+                continue;
+            }
+            const remaining = Math.max(0, maxTotalChars - totalChars);
+            if (remaining <= 0) {
+                return resolved;
+            }
+            const clipped = trimmed.slice(0, Math.min(maxCharsPerFile, remaining));
+            resolved.push({ path: normalized, content: clipped });
+            seen.add(normalized);
+            totalChars += clipped.length;
+            break;
+        }
+    }
+    return resolved;
+}
+function priorityFromEntry(entry) {
+    if (entry.priority === 'P0' || entry.priority === 'P1' || entry.priority === 'P2') {
+        return entry.priority;
+    }
+    const score = typeof entry.score === 'number' ? entry.score : 0;
+    if (score >= 8) {
+        return 'P0';
+    }
+    if (score >= 5) {
+        return 'P1';
+    }
+    return 'P2';
+}
+function normalizeFlowId(value) {
+    return normalizePath(value)
+        .replace(/[^a-zA-Z0-9/_-]+/g, '_')
+        .replace(/\/{2,}/g, '/')
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '')
+        .trim();
+}
+function sanitizeReasons(reasons, fallback) {
+    if (!Array.isArray(reasons)) {
+        return [fallback];
+    }
+    const cleaned = reasons.filter((entry) => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+    return cleaned.length > 0 ? cleaned : [fallback];
+}
+function sanitizeKeywords(keywords, fallbackTokens) {
+    if (!Array.isArray(keywords)) {
+        return uniqueTokens(fallbackTokens).slice(0, 20);
+    }
+    const fromAI = keywords.filter((entry) => typeof entry === 'string').flatMap((entry) => tokenize(entry));
+    return uniqueTokens([...fromAI, ...fallbackTokens]).slice(0, 20);
+}
+function summarizeFiles(files, changedFileSet, maxFiles) {
+    const sorted = [...files].sort((a, b) => {
+        const aChanged = changedFileSet.has(a.relativePath) ? 1 : 0;
+        const bChanged = changedFileSet.has(b.relativePath) ? 1 : 0;
+        if (aChanged !== bChanged) {
+            return bChanged - aChanged;
+        }
+        const aSignals = (a.isUI ? 1 : 0) + (a.isScreen ? 1 : 0) + (a.isState ? 1 : 0) + (a.hasInteractions ? 1 : 0);
+        const bSignals = (b.isUI ? 1 : 0) + (b.isScreen ? 1 : 0) + (b.isState ? 1 : 0) + (b.hasInteractions ? 1 : 0);
+        if (aSignals !== bSignals) {
+            return bSignals - aSignals;
+        }
+        return a.relativePath.localeCompare(b.relativePath);
+    }).slice(0, Math.max(20, maxFiles));
+    return sorted.map((file) => ({
+        path: file.relativePath,
+        changed: changedFileSet.has(file.relativePath),
+        isUI: file.isUI,
+        isScreen: file.isScreen,
+        isComponent: file.isComponent,
+        isState: file.isState,
+        isStyle: file.isStyle,
+        hasInteractions: file.hasInteractions,
+        keywords: file.keywords.slice(0, 20),
+        audience: file.audience,
+        flags: file.flags?.map((flag) => ({ name: flag.name, source: flag.source, defaultState: flag.defaultState })),
+    }));
+}
+function mergeFlow(existing, candidate) {
+    if (!existing) {
+        return candidate;
+    }
+    const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+    const priority = priorityOrder[candidate.priority] < priorityOrder[existing.priority]
+        ? candidate.priority
+        : existing.priority;
+    return {
+        ...existing,
+        name: existing.name || candidate.name,
+        kind: existing.kind || candidate.kind,
+        score: Math.max(existing.score, candidate.score),
+        priority,
+        reasons: uniqueTokens([...(existing.reasons || []), ...(candidate.reasons || [])]),
+        keywords: uniqueTokens([...(existing.keywords || []), ...(candidate.keywords || [])]),
+        files: uniqueTokens([...(existing.files || []), ...(candidate.files || [])]),
+        audience: uniqueTokens([...(existing.audience || []), ...(candidate.audience || [])]),
+        flags: [...(existing.flags || []), ...(candidate.flags || [])],
+    };
+}
+export async function mapAIFlowsFromFiles(appRoot, testsRoot, config, files, changedFiles) {
+    const providerName = config.provider === 'auto' ? 'auto' : config.provider;
+    const warnings = [];
+    if (!config.enabled) {
+        return {
+            enabled: false,
+            used: false,
+            provider: providerName,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    if (files.length === 0) {
+        warnings.push('AI flow analysis skipped: no analyzable files were found.');
+        return {
+            enabled: true,
+            used: false,
+            provider: providerName,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    const changedFileSet = new Set(changedFiles.map((entry) => normalizePath(entry)));
+    const summarizedFiles = summarizeFiles(files, changedFileSet, config.maxFilesPerRequest);
+    const allowedFiles = new Set(files.map((entry) => entry.relativePath));
+    const fileByPath = new Map(files.map((entry) => [entry.relativePath, entry]));
+    const contextFiles = resolveContextFiles(appRoot, testsRoot, config.contextFiles || []);
+    const contextBlock = contextFiles.length > 0
+        ? contextFiles.map((entry) => `### Context: ${entry.path}\n${entry.content}`).join('\n\n')
+        : 'No optional markdown context files were found.';
+    if (contextFiles.length === 0) {
+        warnings.push('AI flow analysis context files were not found; continuing without optional markdown context.');
+    }
+    let provider;
+    try {
+        provider = config.provider === 'auto'
+            ? await LLMProviderFactory.createFromEnv()
+            : LLMProviderFactory.createFromString(config.provider);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`AI flow analysis unavailable (${providerName}): ${message}`);
+        return {
+            enabled: true,
+            used: false,
+            provider: providerName,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    const prompt = [
+        'You are an expert frontend impact analyst for Mattermost.',
+        'Build impacted user flows from changed frontend files.',
+        'This must be flow-centric, not file-centric.',
+        '',
+        'Return strict JSON only with this exact shape:',
+        '{"flows":[{"id":"<flow_id>","name":"<name>","kind":"flow|screen","priority":"P0|P1|P2","score":10,"reasons":["..."],"keywords":["..."],"files":["relative/path.tsx"]}]}',
+        '',
+        'Rules:',
+        '- Use only file paths listed in FILES.',
+        '- Every flow must have at least one file.',
+        '- Keep IDs stable and lowercase with underscores when possible.',
+        '- Prioritize true user-impacting flows; avoid low-value internal buckets.',
+        '- Keep at most 6 file paths per flow.',
+        `- Keep at most ${Math.max(1, config.maxFlowsPerRequest)} flows.`,
+        '',
+        `CHANGED_FILES (${changedFileSet.size}):`,
+        JSON.stringify(Array.from(changedFileSet), null, 2),
+        '',
+        `FILES (${summarizedFiles.length}):`,
+        JSON.stringify(summarizedFiles, null, 2),
+        '',
+        contextBlock,
+    ].join('\n');
+    let parsed = null;
+    try {
+        const response = await provider.generateText(prompt, {
+            maxTokens: Math.max(800, config.maxTokens),
+            temperature: Math.max(0, Math.min(1, config.temperature)),
+            systemPrompt: 'Return only valid JSON. Do not include markdown fences unless necessary.',
+        });
+        parsed = extractJson(response.text);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`AI flow analysis request failed (${provider.name}): ${message}`);
+        return {
+            enabled: true,
+            used: false,
+            provider: provider.name,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    if (!parsed) {
+        warnings.push(`AI flow analysis returned invalid JSON (${provider.name}).`);
+        return {
+            enabled: true,
+            used: false,
+            provider: provider.name,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    const flowsById = new Map();
+    for (const entry of parsed.flows) {
+        if (!entry || !Array.isArray(entry.files)) {
+            continue;
+        }
+        const validFiles = Array.from(new Set(entry.files
+            .filter((value) => typeof value === 'string')
+            .map((value) => normalizePath(value))
+            .filter((value) => allowedFiles.has(value)))).slice(0, 6);
+        if (validFiles.length === 0) {
+            continue;
+        }
+        const rawId = typeof entry.id === 'string' && entry.id.trim()
+            ? entry.id
+            : (typeof entry.name === 'string' && entry.name.trim() ? entry.name : validFiles[0]);
+        const id = normalizeFlowId(rawId);
+        if (!id) {
+            continue;
+        }
+        const fallbackTokens = uniqueTokens([
+            ...tokenize(id),
+            ...(typeof entry.name === 'string' ? tokenize(entry.name) : []),
+            ...validFiles.flatMap((value) => tokenize(value)),
+        ]);
+        const linkedFiles = validFiles.map((path) => fileByPath.get(path)).filter(Boolean);
+        const audience = uniqueTokens(linkedFiles.flatMap((file) => file.audience || []));
+        const flags = linkedFiles.flatMap((file) => file.flags || []);
+        const score = typeof entry.score === 'number' && Number.isFinite(entry.score)
+            ? Math.max(1, Math.min(20, Math.round(entry.score)))
+            : Math.max(4, validFiles.length * 2);
+        const flow = {
+            id,
+            name: typeof entry.name === 'string' && entry.name.trim() ? entry.name.trim() : id.replace(/[_/.-]+/g, ' '),
+            kind: entry.kind === 'screen' ? 'screen' : 'flow',
+            score,
+            priority: priorityFromEntry(entry),
+            reasons: sanitizeReasons(entry.reasons, 'AI flow analysis identified impacted behavior'),
+            keywords: sanitizeKeywords(entry.keywords, fallbackTokens),
+            files: validFiles,
+            audience,
+            flags,
+        };
+        flowsById.set(id, mergeFlow(flowsById.get(id), flow));
+        if (flowsById.size >= Math.max(1, config.maxFlowsPerRequest)) {
+            break;
+        }
+    }
+    const flows = Array.from(flowsById.values());
+    if (flows.length === 0) {
+        warnings.push('AI flow analysis did not return any valid flows linked to changed files.');
+        return {
+            enabled: true,
+            used: false,
+            provider: provider.name,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    return {
+        enabled: true,
+        used: true,
+        provider: provider.name,
+        flowCount: flows.length,
+        warnings,
+        flows,
+    };
+}