@yasserkhanorg/e2e-agents 1.7.6 → 1.8.0

package/dist/esm/cli/commands/crew.js

@@ -0,0 +1,134 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * CLI command: crew — runs multi-agent QA analysis workflows.
+ */
+import { resolveConfig } from '../../agent/config.js';
+import { CrewOrchestrator } from '../../crew/orchestrator.js';
+import { ImpactAnalystAgent } from '../../agents/impact-analyst.js';
+import { GeneratorAgent } from '../../agents/generator.js';
+import { ExecutorAgent } from '../../agents/executor.js';
+import { HealerAgent } from '../../agents/healer.js';
+import { StrategistAgent } from '../../agents/strategist.js';
+import { TestDesignerAgent } from '../../agents/test-designer.js';
+import { CrossImpactAgent } from '../../agents/cross-impact.js';
+import { RegressionAdvisorAgent } from '../../agents/regression-advisor.js';
+const VALID_WORKFLOWS = ['full-qa', 'quick-check', 'design-only'];
+export async function runCrewCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for crew command');
+        process.exit(1);
+    }
+    const { config } = resolveConfig(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'impact',
+        gitSince: args.gitSince,
+        llmProvider: args.llmProvider,
+    });
+    const testsRoot = config.testsRoot || config.path;
+    const rawWorkflow = args.crewWorkflow || 'full-qa';
+    if (!VALID_WORKFLOWS.includes(rawWorkflow)) {
+        console.error(`Error: invalid workflow '${rawWorkflow}'. Valid: ${VALID_WORKFLOWS.join(', ')}`);
+        process.exit(1);
+    }
+    const workflowName = rawWorkflow;
+    const crewConfig = {
+        appPath: config.path,
+        testsRoot,
+        gitSince: args.gitSince || config.git.since,
+        routeFamilies: config.routeFamilies,
+        apiSurface: config.apiSurface,
+        workflow: workflowName,
+        providerOverride: args.llmProvider,
+        budgetUSD: args.budgetUSD,
+        dryRun: args.dryRun,
+    };
+    // Create orchestrator and register all agents
+    const orchestrator = new CrewOrchestrator();
+    orchestrator.registerAgent(new ImpactAnalystAgent());
+    orchestrator.registerAgent(new GeneratorAgent());
+    orchestrator.registerAgent(new ExecutorAgent());
+    orchestrator.registerAgent(new HealerAgent());
+    orchestrator.registerAgent(new StrategistAgent());
+    orchestrator.registerAgent(new TestDesignerAgent());
+    orchestrator.registerAgent(new CrossImpactAgent());
+    orchestrator.registerAgent(new RegressionAdvisorAgent());
+    let result;
+    try {
+        result = await orchestrator.run(crewConfig);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Crew workflow failed: ${message}`);
+        process.exit(1);
+    }
+    const ctx = result.context;
+    // JSON output mode
+    if (args.jsonOutput) {
+        const jsonReport = {
+            workflow: workflowName,
+            changedFiles: ctx.changedFiles.length,
+            impactedFlows: ctx.impactedFlows,
+            strategyEntries: ctx.strategyEntries,
+            testDesigns: ctx.testDesigns,
+            crossImpacts: ctx.crossImpacts,
+            regressionRisks: ctx.regressionRisks,
+            findings: ctx.findings,
+            generatedSpecs: ctx.generatedSpecs.map((s) => ({ flowId: s.flowId, specPath: s.specPath, mode: s.mode, written: s.written })),
+            usage: { cost: ctx.usage.totalCost, requests: ctx.usage.requestCount, tokens: ctx.usage.totalTokens },
+            timings: result.timings,
+            warnings: result.warnings,
+        };
+        console.log(JSON.stringify(jsonReport, null, 2));
+        return;
+    }
+    // Human-readable output
+    console.log(`Crew workflow: ${workflowName}`);
+    console.log(`Changed files: ${ctx.changedFiles.length}`);
+    console.log(`Impacted flows: ${ctx.impactedFlows.length}`);
+    console.log(`Strategy entries: ${ctx.strategyEntries.length}`);
+    console.log(`Test designs: ${ctx.testDesigns.length} (${ctx.testDesigns.reduce((sum, td) => sum + td.testCases.length, 0)} test cases)`);
+    console.log(`Cross-impacts: ${ctx.crossImpacts.length}`);
+    console.log(`Regression risks: ${ctx.regressionRisks.length}`);
+    console.log(`Findings: ${ctx.findings.length}`);
+    console.log(`Generated specs: ${ctx.generatedSpecs.length}`);
+    console.log(`Cost: $${ctx.usage.totalCost.toFixed(4)}`);
+    if (ctx.strategyEntries.length > 0) {
+        console.log('\nTest Strategy:');
+        for (const entry of ctx.strategyEntries) {
+            console.log(`  ${entry.priority} ${entry.flowName} → ${entry.approach} [${entry.testCategories.join(', ')}]`);
+        }
+    }
+    if (ctx.testDesigns.length > 0) {
+        console.log('\nTest Designs:');
+        for (const design of ctx.testDesigns) {
+            console.log(`  ${design.flowName}: ${design.testCases.length} test cases`);
+            for (const tc of design.testCases) {
+                console.log(`    [${tc.type}] ${tc.name} (${tc.priority})`);
+            }
+        }
+    }
+    if (ctx.crossImpacts.length > 0) {
+        console.log('\nCross-Family Impacts:');
+        for (const ci of ctx.crossImpacts) {
+            console.log(`  ${ci.sourceFamily} → ${ci.affectedFamily} (${ci.riskLevel}): ${ci.sharedDependency}`);
+        }
+    }
+    if (result.timings && Object.keys(result.timings).length > 0) {
+        console.log('\nPhase timings:');
+        for (const [phase, ms] of Object.entries(result.timings)) {
+            console.log(`  ${phase}: ${ms}ms`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        console.log(`\nWarnings: ${result.warnings.length}`);
+        for (const w of result.warnings.slice(0, 10)) {
+            console.log(`  - ${w}`);
+        }
+        if (result.warnings.length > 10) {
+            console.log(`  ... and ${result.warnings.length - 10} more`);
+        }
+    }
+}

package/dist/esm/cli/parse_args.js

@@ -98,6 +98,7 @@ const FLAGS = {
     '--flow-catalog': { key: 'flowCatalogPath', type: 'string' },
     '--output': { key: 'trainOutput', type: 'string' },
     '--server-path': { key: 'serverPath', type: 'string' },
+    '--workflow': { key: 'crewWorkflow', type: 'string' },
     // -- number flags (with isFinite guard) --
     '--pipeline-scenarios': { key: 'pipelineScenarios', type: 'number' },
     '--time': { key: 'timeLimitMinutes', type: 'number' },
@@ -143,7 +144,7 @@ const COMMANDS = new Set([
     'init', 'impact', 'plan', 'heal', 'suggest', 'generate',
     'finalize-generated-tests', 'feedback',
     'traceability-capture', 'traceability-ingest',
-    'analyze', 'llm-health', 'train',
+    'analyze', 'llm-health', 'train', 'crew',
 ]);
 // ---------------------------------------------------------------------------
 // Parser

package/dist/esm/cli.js

@@ -15,6 +15,7 @@ import { runPlanCommand } from './cli/commands/plan.js';
 import { runGenerateCommand } from './cli/commands/generate.js';
 import { runInitCommand } from './cli/commands/init.js';
 import { runTrainCommand } from './cli/commands/train.js';
+import { runCrewCommand } from './cli/commands/crew.js';
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     const autoConfig = resolveAutoConfig(args);
@@ -59,6 +60,10 @@ async function main() {
         runHealCommand(args, autoConfig);
         return;
     }
+    if (args.command === 'crew') {
+        await runCrewCommand(args, autoConfig);
+        return;
+    }
     if (!args.path && !autoConfig) {
         console.error('Error: --path is required (or provide a config file with path set)');
         printUsage();

package/dist/esm/crew/context.js

@@ -0,0 +1,32 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export function createEmptyUsageStats() {
+    const now = new Date();
+    return {
+        requestCount: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        averageResponseTimeMs: 0,
+        failedRequests: 0,
+        startTime: now,
+        lastUpdated: now,
+    };
+}
+export function mergeUsageStats(target, source) {
+    const prevRequestCount = target.requestCount;
+    target.requestCount += source.requestCount;
+    target.totalInputTokens += source.totalInputTokens;
+    target.totalOutputTokens += source.totalOutputTokens;
+    target.totalTokens += source.totalTokens;
+    target.totalCost += source.totalCost;
+    target.failedRequests += source.failedRequests;
+    if (source.requestCount > 0 && target.requestCount > 0) {
+        const prevWeight = prevRequestCount / target.requestCount;
+        const newWeight = source.requestCount / target.requestCount;
+        target.averageResponseTimeMs =
+            target.averageResponseTimeMs * prevWeight + source.averageResponseTimeMs * newWeight;
+    }
+    target.lastUpdated = new Date();
+}

package/dist/esm/crew/orchestrator.js

@@ -0,0 +1,167 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Crew Orchestrator — executes workflow definitions by dispatching to agents.
+ */
+import { getChangedFiles, isTestFile } from '../agent/git.js';
+import { preprocess } from '../pipeline/stage0_preprocess.js';
+import { logger } from '../logger.js';
+import { createEmptyUsageStats, mergeUsageStats } from './context.js';
+import { WORKFLOWS } from './workflows.js';
+export class CrewOrchestrator {
+    constructor() {
+        this.agents = new Map();
+    }
+    registerAgent(agent) {
+        this.agents.set(agent.role, agent);
+    }
+    async run(config) {
+        const workflow = WORKFLOWS[config.workflow || 'full-qa'];
+        const timings = {};
+        const warnings = [];
+        // Step 1: Get changed files
+        const gitResult = getChangedFiles(config.appPath, config.gitSince, {
+            includeUncommitted: config.gitIncludeUncommitted,
+        });
+        if (gitResult.error) {
+            warnings.push(`Git diff warning: ${gitResult.error}`);
+        }
+        const changedFiles = gitResult.files
+            .map((f) => f.replace(/\\/g, '/'))
+            .filter((f) => !isTestFile(f));
+        if (changedFiles.length === 0) {
+            warnings.push('No changed application files detected.');
+        }
+        // Initialize context (will be populated during preprocess phase)
+        const ctx = {
+            changedFiles,
+            routeFamilies: [],
+            manifest: null,
+            apiSurface: { pageObjects: [], generatedAt: '' },
+            specIndex: { specs: [], indexedAt: '' },
+            context: { documents: [], warnings: [] },
+            familyGroups: [],
+            preprocessResult: null,
+            appPath: config.appPath,
+            testsRoot: config.testsRoot,
+            gitSince: config.gitSince,
+            providerOverride: config.providerOverride,
+            impactedFlows: [],
+            strategyEntries: [],
+            testDesigns: [],
+            crossImpacts: [],
+            regressionRisks: [],
+            findings: [],
+            generatedSpecs: [],
+            usage: createEmptyUsageStats(),
+            messages: [],
+            warnings,
+        };
+        // Execute each phase
+        for (const phase of workflow.phases) {
+            const timer = logger.timer(`crew:${phase.name}`);
+            if (phase.handler === 'built-in') {
+                await this.runBuiltInPhase(phase.name, ctx, config);
+            }
+            else if (phase.parallel && phase.parallel.length > 0) {
+                await this.runParallel(phase.parallel, phase.name, ctx);
+            }
+            else if (phase.sequential && phase.sequential.length > 0) {
+                await this.runSequential(phase.sequential, phase.name, ctx);
+            }
+            else {
+                warnings.push(`Phase '${phase.name}' has no handler, parallel, or sequential agents — skipped.`);
+            }
+            timings[phase.name] = timer.end();
+            // Budget check
+            if (config.budgetUSD && ctx.usage.totalCost >= config.budgetUSD) {
+                warnings.push(`Budget limit reached ($${ctx.usage.totalCost.toFixed(4)} >= $${config.budgetUSD}). Stopping workflow.`);
+                break;
+            }
+        }
+        return { context: ctx, warnings, timings };
+    }
+    async dispatch(role, action, ctx) {
+        const agent = this.agents.get(role);
+        if (!agent) {
+            return {
+                role,
+                status: 'failed',
+                output: null,
+                warnings: [`Agent '${role}' is not registered.`],
+            };
+        }
+        const task = { role, action, input: null };
+        try {
+            const result = await agent.execute(task, ctx);
+            if (result.usage) {
+                mergeUsageStats(ctx.usage, result.usage);
+            }
+            if (result.warnings && result.warnings.length > 0) {
+                ctx.warnings.push(...result.warnings);
+            }
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            ctx.warnings.push(`Agent '${role}' failed: ${message}`);
+            return { role, status: 'failed', output: null, warnings: [message] };
+        }
+    }
+    async parallel(roles, action, ctx) {
+        const promises = roles.map((role) => this.dispatch(role, action, ctx));
+        return Promise.all(promises);
+    }
+    async broadcast(msg, ctx) {
+        ctx.messages.push(msg);
+        const promises = [];
+        for (const agent of this.agents.values()) {
+            if (agent.onMessage && agent.role !== msg.from) {
+                promises.push(agent.onMessage(msg).catch((err) => {
+                    ctx.warnings.push(`Broadcast to ${agent.role} failed: ${err instanceof Error ? err.message : String(err)}`);
+                }));
+            }
+        }
+        await Promise.all(promises);
+    }
+    async runBuiltInPhase(name, ctx, config) {
+        if (name === 'preprocess') {
+            if (ctx.changedFiles.length === 0) {
+                return;
+            }
+            const result = preprocess(ctx.changedFiles, {
+                appPath: config.appPath,
+                testsRoot: config.testsRoot,
+                routeFamilies: config.routeFamilies,
+                apiSurface: config.apiSurface,
+            });
+            ctx.preprocessResult = result;
+            ctx.manifest = result.manifest;
+            ctx.routeFamilies = result.manifest?.families || [];
+            ctx.apiSurface = result.apiSurface;
+            ctx.specIndex = result.specIndex;
+            ctx.context = result.context;
+            ctx.familyGroups = result.familyGroups;
+            ctx.warnings.push(...result.warnings);
+        }
+    }
+    async runParallel(roles, phaseName, ctx) {
+        logger.info(`Crew phase '${phaseName}': running ${roles.join(', ')} in parallel`);
+        const results = await this.parallel(roles, phaseName, ctx);
+        this.checkPhaseResults(phaseName, results, ctx);
+    }
+    async runSequential(roles, phaseName, ctx) {
+        logger.info(`Crew phase '${phaseName}': running ${roles.join(' → ')} sequentially`);
+        const results = [];
+        for (const role of roles) {
+            results.push(await this.dispatch(role, phaseName, ctx));
+        }
+        this.checkPhaseResults(phaseName, results, ctx);
+    }
+    checkPhaseResults(phaseName, results, ctx) {
+        const allFailed = results.length > 0 && results.every((r) => r.status === 'failed');
+        if (allFailed) {
+            ctx.warnings.push(`Phase '${phaseName}': all ${results.length} agent(s) failed. Downstream phases may produce empty results.`);
+        }
+    }
+}

package/dist/esm/crew/protocol.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export {};

package/dist/esm/crew/provider.js

@@ -0,0 +1,13 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Shared provider creation for crew agents — ensures consistent provider
+ * instantiation and prevents usage stats fragmentation.
+ */
+import { LLMProviderFactory } from '../provider_factory.js';
+export async function getCrewProvider(providerOverride) {
+    if (providerOverride) {
+        return LLMProviderFactory.createFromString(providerOverride);
+    }
+    return LLMProviderFactory.createFromEnv();
+}

package/dist/esm/crew/sanitize.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Sanitize strings before interpolating into LLM prompts.
+ * Strips common prompt injection patterns while preserving useful content.
+ */
+const INJECTION_PATTERNS = [
+    /ignore\s+(all\s+)?previous\s+instructions/gi,
+    /disregard\s+(all\s+)?(above|prior|previous)/gi,
+    /system\s*:\s*/gi,
+    /\[INST\]/gi,
+    /<<SYS>>/gi,
+    /<\|im_start\|>/gi,
+    /\bHuman\s*:\s*/gi,
+    /\bAssistant\s*:\s*/gi,
+];
+const MAX_FIELD_LENGTH = 2000;
+export function sanitizeForPrompt(value) {
+    let sanitized = value.slice(0, MAX_FIELD_LENGTH);
+    for (const pattern of INJECTION_PATTERNS) {
+        sanitized = sanitized.replace(pattern, '[filtered]');
+    }
+    return sanitized;
+}
+export function sanitizeArray(values) {
+    return values.map((v) => sanitizeForPrompt(v));
+}

package/dist/esm/crew/types.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export {};

package/dist/esm/crew/workflows.js

@@ -0,0 +1,33 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export const WORKFLOWS = {
+    'full-qa': {
+        name: 'full-qa',
+        description: 'Full multi-agent QA analysis: understand → strategize → execute → validate',
+        phases: [
+            { name: 'preprocess', handler: 'built-in' },
+            { name: 'understand', parallel: ['impact-analyst', 'cross-impact', 'regression-advisor'] },
+            { name: 'strategize', sequential: ['strategist', 'test-designer'] },
+            { name: 'execute', parallel: ['generator'] },
+            { name: 'validate', sequential: ['executor', 'healer'] },
+        ],
+    },
+    'quick-check': {
+        name: 'quick-check',
+        description: 'Quick impact analysis with strategy recommendations',
+        phases: [
+            { name: 'preprocess', handler: 'built-in' },
+            { name: 'understand', parallel: ['impact-analyst'] },
+            { name: 'strategize', sequential: ['strategist'] },
+        ],
+    },
+    'design-only': {
+        name: 'design-only',
+        description: 'Impact analysis through test design — no generation or execution',
+        phases: [
+            { name: 'preprocess', handler: 'built-in' },
+            { name: 'understand', parallel: ['impact-analyst', 'cross-impact'] },
+            { name: 'strategize', sequential: ['strategist', 'test-designer'] },
+        ],
+    },
+};

package/dist/esm/index.js

@@ -30,6 +30,20 @@ export { buildApiSurface, loadOrBuildApiSurface } from './knowledge/api_surface.
 export { buildSpecIndex, getSpecsForFamily } from './knowledge/spec_index.js';
 // Agentic generation
 export { runAgenticGeneration } from './agentic/runner.js';
+// Crew (multi-agent QA workflows)
+export { CrewOrchestrator } from './crew/orchestrator.js';
+export { WORKFLOWS } from './crew/workflows.js';
+// Crew agents
+export { ImpactAnalystAgent } from './agents/impact-analyst.js';
+export { CoverageEvaluatorAgent } from './agents/coverage-evaluator.js';
+export { GeneratorAgent } from './agents/generator.js';
+export { ExecutorAgent } from './agents/executor.js';
+export { HealerAgent } from './agents/healer.js';
+export { ExplorerAgent } from './agents/explorer.js';
+export { StrategistAgent } from './agents/strategist.js';
+export { TestDesignerAgent } from './agents/test-designer.js';
+export { CrossImpactAgent } from './agents/cross-impact.js';
+export { RegressionAdvisorAgent } from './agents/regression-advisor.js';
 // Training (route-families bootstrap and maintenance)
 export { scanProject } from './training/scanner.js';
 export { mergeFamilies, detectStaleFamilies } from './training/merger.js';

package/dist/esm/prompts/cross-impact.js

@@ -0,0 +1,71 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { sanitizeForPrompt } from '../crew/sanitize.js';
+export function buildCrossImpactPrompt(ctx) {
+    const familiesBlock = ctx.families
+        .map((f) => {
+        const paths = [
+            ...(f.webappPaths || []),
+            ...(f.serverPaths || []),
+            ...(f.components || []),
+        ];
+        return `- ${f.id}: routes=[${f.routes.join(', ')}] paths=[${paths.join(', ')}] pageObjects=[${(f.pageObjects || []).join(', ')}]`;
+    })
+        .join('\n');
+    const changedBlock = ctx.changedFiles.map((f) => sanitizeForPrompt(f)).join('\n');
+    return [
+        'You are analyzing code changes in Mattermost to identify cross-family ripple effects.',
+        'When a change in one route family could affect another family through shared dependencies,',
+        'that is a cross-impact.',
+        '',
+        `CHANGED FILES (${ctx.changedFiles.length}):`,
+        changedBlock,
+        '',
+        `DIRECTLY IMPACTED FAMILIES: ${ctx.directlyImpactedFamilyIds.join(', ')}`,
+        '',
+        `ALL ROUTE FAMILIES (${ctx.families.length}):`,
+        familiesBlock,
+        '',
+        'TASK: Identify cross-family impacts. For each pair, explain the shared dependency.',
+        '',
+        'Look for:',
+        '1. Shared webapp paths (same component used by multiple families)',
+        '2. Shared page objects (same PO class referenced by multiple families)',
+        '3. Shared API endpoints (changes affecting data used by multiple families)',
+        '4. Shared components (React components imported across family boundaries)',
+        '5. Shared state management (Redux stores, contexts used across families)',
+        '',
+        'Return strict JSON only with this shape:',
+        '{"crossImpacts":[{"sourceFamily":"<directly impacted family>","affectedFamily":"<indirectly affected family>","sharedDependency":"<what connects them>","riskLevel":"high|medium|low","evidence":"<specific file/component/API that creates the dependency>"}]}',
+        '',
+        'Rules:',
+        '- Only report cross-impacts where both families are in the manifest.',
+        '- sourceFamily must be one of the directly impacted families.',
+        '- affectedFamily must be DIFFERENT from sourceFamily.',
+        '- Risk levels: high = shared data model/state, medium = shared UI component, low = shared utility.',
+        '- Evidence must cite specific files, components, or API paths.',
+        '- Return empty array if no cross-impacts are found.',
+    ].join('\n');
+}
+export function parseCrossImpactResponse(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.crossImpacts)) {
+                return parsed;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}

package/dist/esm/prompts/strategist.js

@@ -0,0 +1,79 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { sanitizeForPrompt } from '../crew/sanitize.js';
+export function buildStrategistPrompt(ctx) {
+    const flowsBlock = ctx.impactedFlows
+        .map((f) => {
+        const specs = f.existingSpecs.map((s) => `${s.path} (${s.coverageLevel})`).join(', ') || 'none';
+        return [
+            `- ${f.flowId} (${f.priority}): ${f.flowName}`,
+            `  Route Family: ${f.routeFamily}`,
+            `  Action: ${f.action}`,
+            `  Confidence: ${f.confidence}%`,
+            `  Existing Coverage: ${specs}`,
+            `  User Actions: ${sanitizeForPrompt(f.userActions.join('; ') || 'unknown')}`,
+            `  Changed Files: ${f.changedFiles.join(', ')}`,
+        ].join('\n');
+    })
+        .join('\n\n');
+    const crossImpactBlock = ctx.crossImpacts.length > 0
+        ? ctx.crossImpacts.map((ci) => `- ${ci.sourceFamily} → ${ci.affectedFamily} (${ci.riskLevel}): ${ci.sharedDependency} — ${ci.evidence}`).join('\n')
+        : 'No cross-family impacts detected.';
+    const regressionBlock = ctx.regressionRisks.length > 0
+        ? ctx.regressionRisks.map((r) => `- ${r.familyId} (risk=${r.riskScore}): ${r.reason}`).join('\n')
+        : 'No regression risk data available.';
+    return [
+        'You are a senior QA strategist designing the overall test strategy for a code change.',
+        '',
+        `IMPACTED FLOWS (${ctx.impactedFlows.length}):`,
+        flowsBlock,
+        '',
+        'CROSS-FAMILY IMPACTS:',
+        crossImpactBlock,
+        '',
+        'REGRESSION RISK:',
+        regressionBlock,
+        '',
+        'TASK: Design a prioritized test strategy for each impacted flow.',
+        '',
+        'For each flow, decide:',
+        '1. Approach: full-test (comprehensive), smoke-test (critical path only), skip, or manual-review',
+        '2. Priority: P0 (critical path), P1 (important), P2 (nice to have)',
+        '3. Test categories to cover (from: happy-path, edge-case, boundary, negative, state-transition, race-condition, permission, accessibility, performance)',
+        '4. Cross-impact risk level based on shared dependencies',
+        '',
+        'Return strict JSON only with this shape:',
+        '{"strategy":[{"flowId":"<id>","flowName":"<name>","priority":"P0|P1|P2","approach":"full-test|smoke-test|skip|manual-review","rationale":"<why this approach>","testCategories":["happy-path","edge-case",...],"crossImpactRisk":"high|medium|low|none"}]}',
+        '',
+        'Rules:',
+        '- P0 flows with create_spec or add_scenarios action should always get full-test.',
+        '- Flows with high cross-impact risk should be promoted to at least P1.',
+        '- Flows with high regression risk should include edge-case and boundary categories.',
+        '- Skip flows only if confidence < 30 AND no cross-impact risk.',
+        '- Include accessibility category for any flow involving interactive UI elements.',
+        '- Include permission category for any flow involving role-based features.',
+        '- Keep rationale concise (1-2 sentences) explaining why this approach was chosen.',
+    ].join('\n');
+}
+export function parseStrategistResponse(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.strategy)) {
+                return parsed;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}