@yasserkhanorg/impact-gate 2.0.0

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

@@ -0,0 +1,136 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Cross-Impact Analyst Agent — finds ripple effects across route families
+ * by analyzing shared dependencies between changed families and all other families.
+ */
+import { getCrewProvider } from '../crew/provider.js';
+import { buildCrossImpactPrompt, parseCrossImpactResponse } from '../prompts/cross-impact.js';
+const VALID_RISK = new Set(['high', 'medium', 'low']);
+const MAX_CROSS_IMPACTS = 50;
+export class CrossImpactAgent {
+    constructor() {
+        this.role = 'cross-impact';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.routeFamilies.length === 0) {
+            warnings.push('Cross-impact: no route families available.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        // Determine directly impacted families from family groups
+        const directlyImpacted = new Set(ctx.familyGroups.map((g) => g.familyId));
+        if (directlyImpacted.size === 0) {
+            warnings.push('Cross-impact: no directly impacted families.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        // First: deterministic cross-impact detection via shared paths
+        const deterministicCrossImpacts = this.detectDeterministic(ctx, directlyImpacted)
+            .slice(0, MAX_CROSS_IMPACTS);
+        ctx.crossImpacts.push(...deterministicCrossImpacts);
+        // Then: LLM-enriched analysis for semantic cross-impacts
+        try {
+            const provider = await getCrewProvider(ctx.providerOverride, ctx.budgetUSD, {
+                agentRole: 'cross-impact',
+                modelRoutingProviderType: ctx.modelRoutingProviderType,
+                modelRoutingOverrides: ctx.modelRoutingOverrides,
+                budgetLedger: ctx.budgetLedger,
+            });
+            const prompt = buildCrossImpactPrompt({
+                changedFiles: ctx.changedFiles,
+                families: ctx.routeFamilies,
+                directlyImpactedFamilyIds: Array.from(directlyImpacted),
+            });
+            const response = await provider.generateText(prompt, {
+                maxTokens: 3000,
+                temperature: 0,
+                timeout: 45000,
+                systemPrompt: 'Return only valid JSON. Do not include markdown fences unless necessary.',
+            });
+            const parsed = parseCrossImpactResponse(response.text);
+            if (parsed && parsed.crossImpacts.length > 0) {
+                const familyIds = new Set(ctx.routeFamilies.map((f) => f.id));
+                const llmCrossImpacts = parsed.crossImpacts
+                    .filter((ci) => familyIds.has(ci.sourceFamily) &&
+                    familyIds.has(ci.affectedFamily) &&
+                    ci.sourceFamily !== ci.affectedFamily)
+                    .map((ci) => ({
+                    sourceFamily: ci.sourceFamily,
+                    affectedFamily: ci.affectedFamily,
+                    sharedDependency: ci.sharedDependency || 'unknown',
+                    riskLevel: VALID_RISK.has(ci.riskLevel) ? ci.riskLevel : 'low',
+                    evidence: ci.evidence || '',
+                }));
+                // Deduplicate against deterministic results
+                const existing = new Set(ctx.crossImpacts.map((ci) => `${ci.sourceFamily}->${ci.affectedFamily}`));
+                for (const ci of llmCrossImpacts) {
+                    if (ctx.crossImpacts.length >= MAX_CROSS_IMPACTS)
+                        break;
+                    const key = `${ci.sourceFamily}->${ci.affectedFamily}`;
+                    if (!existing.has(key)) {
+                        ctx.crossImpacts.push(ci);
+                        existing.add(key);
+                    }
+                }
+            }
+            return {
+                role: this.role,
+                status: ctx.crossImpacts.length > 0 ? 'success' : 'partial',
+                output: ctx.crossImpacts,
+                usage: provider.getUsageStats(),
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Cross-impact LLM analysis failed: ${message}. Using deterministic results only.`);
+            return {
+                role: this.role,
+                status: deterministicCrossImpacts.length > 0 ? 'partial' : 'failed',
+                output: ctx.crossImpacts,
+                warnings,
+            };
+        }
+    }
+    /**
+     * Deterministic cross-impact detection: find families that share webapp/server paths
+     * or components with the directly impacted families.
+     */
+    detectDeterministic(ctx, directlyImpacted) {
+        const results = [];
+        for (const sourceId of directlyImpacted) {
+            const source = ctx.routeFamilies.find((f) => f.id === sourceId);
+            if (!source)
+                continue;
+            const sourcePaths = new Set([
+                ...(source.webappPaths || []),
+                ...(source.serverPaths || []),
+                ...(source.components || []),
+            ]);
+            if (sourcePaths.size === 0)
+                continue;
+            for (const target of ctx.routeFamilies) {
+                if (target.id === sourceId)
+                    continue;
+                const targetPaths = [
+                    ...(target.webappPaths || []),
+                    ...(target.serverPaths || []),
+                    ...(target.components || []),
+                ];
+                for (const path of targetPaths) {
+                    if (sourcePaths.has(path)) {
+                        results.push({
+                            sourceFamily: sourceId,
+                            affectedFamily: target.id,
+                            sharedDependency: path,
+                            riskLevel: 'medium',
+                            evidence: `Shared path: ${path} is referenced by both ${sourceId} and ${target.id}`,
+                        });
+                        break; // One match per family pair is enough
+                    }
+                }
+            }
+        }
+        return results;
+    }
+}

package/dist/esm/agents/executor.js

@@ -0,0 +1,71 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Executor Agent — wraps agentic test execution in the Agent interface.
+ * Runs generated specs through Playwright and collects results.
+ */
+import { getCrewProvider } from '../crew/provider.js';
+import { runAgenticGeneration } from '../agentic/runner.js';
+const MAX_FIX_ATTEMPTS = 2;
+const TEST_TIMEOUT_MS = 120000;
+export class ExecutorAgent {
+    constructor() {
+        this.role = 'executor';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        const writtenSpecs = ctx.generatedSpecs.filter((s) => s.written);
+        if (writtenSpecs.length === 0) {
+            warnings.push('Executor: no written specs to execute.');
+            return { role: this.role, status: 'partial', output: null, warnings };
+        }
+        // Build ScenarioInput[] from generated specs + impacted flows
+        const flowMap = new Map(ctx.impactedFlows.map((f) => [f.flowId, f]));
+        const scenarios = writtenSpecs.map((spec) => {
+            const flow = flowMap.get(spec.flowId);
+            return {
+                id: spec.flowId,
+                name: flow?.flowName || spec.flowId,
+                scenarios: flow?.scenariosToAdd || [],
+                routeFamily: flow?.routeFamily || 'unknown',
+                priority: flow?.priority || 'P2',
+                targetSpec: spec.mode === 'add_scenarios' ? spec.specPath : undefined,
+                changedFiles: flow?.changedFiles,
+                evidence: flow?.evidence,
+            };
+        });
+        try {
+            const provider = await getCrewProvider(ctx.providerOverride, ctx.budgetUSD, {
+                agentRole: 'executor',
+                modelRoutingProviderType: ctx.modelRoutingProviderType,
+                modelRoutingOverrides: ctx.modelRoutingOverrides,
+                budgetLedger: ctx.budgetLedger,
+            });
+            const summary = await runAgenticGeneration({
+                scenarios,
+                config: {
+                    maxAttempts: MAX_FIX_ATTEMPTS,
+                    project: 'chrome',
+                    testTimeoutMs: TEST_TIMEOUT_MS,
+                    provider: ctx.providerOverride,
+                    testsRoot: ctx.testsRoot,
+                },
+                provider,
+                apiSurface: ctx.apiSurface,
+            });
+            warnings.push(...summary.warnings);
+            return {
+                role: this.role,
+                status: summary.totalPassed > 0 ? 'success' : 'partial',
+                output: summary,
+                usage: provider.getUsageStats(),
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Executor failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}

package/dist/esm/agents/explorer.js

@@ -0,0 +1,39 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export class ExplorerAgent {
+    constructor() {
+        this.role = 'explorer';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        // Explorer requires browser environment — skip gracefully if not available
+        try {
+            // Build target flows from impacted flows
+            const targetFlows = ctx.impactedFlows
+                .filter((d) => d.action !== 'cannot_determine')
+                .map((d) => ({
+                id: d.flowId,
+                name: d.flowName,
+                url: d.specificRoute,
+                priority: d.priority,
+            }));
+            if (targetFlows.length === 0) {
+                warnings.push('Explorer: no target flows for exploration.');
+                return { role: this.role, status: 'partial', output: null, warnings };
+            }
+            // Convert QA findings to crew findings
+            warnings.push(`Explorer: ${targetFlows.length} flows available for exploration (requires browser environment).`);
+            return {
+                role: this.role,
+                status: 'partial',
+                output: { targetFlows },
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Explorer failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}

package/dist/esm/agents/generator.js

@@ -0,0 +1,73 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Generator Agent — wraps pipeline stage3 (test generation) in the Agent interface.
+ * Enhanced to accept TestCase[] from the Test Designer in addition to flat scenariosToAdd.
+ */
+import { runGenerationStage } from '../pipeline/stage3_generation.js';
+/**
+ * Enrich FlowDecisions with TestDesign data from the crew context.
+ * Converts structured TestCase[] into scenariosToAdd strings that the
+ * existing generation prompt can consume.
+ */
+function enrichDecisionsWithTestDesigns(ctx) {
+    if (ctx.testDesigns.length === 0) {
+        return ctx.impactedFlows;
+    }
+    const designsByFlow = new Map(ctx.testDesigns.map((td) => [td.flowId, td]));
+    return ctx.impactedFlows.map((decision) => {
+        const design = designsByFlow.get(decision.flowId);
+        if (!design || design.testCases.length === 0) {
+            return decision;
+        }
+        // Convert structured test cases to scenario descriptions for the generator prompt
+        const designedScenarios = design.testCases.map((tc) => {
+            const steps = tc.steps.join(' → ');
+            return `[${tc.type}] ${tc.name}: ${steps} → Expected: ${tc.expectedOutcome}`;
+        });
+        // Merge with any existing scenarios, preferring designed ones
+        const existingScenarios = decision.scenariosToAdd || [];
+        const mergedScenarios = [...designedScenarios, ...existingScenarios];
+        return {
+            ...decision,
+            scenariosToAdd: mergedScenarios,
+            // Intentionally promote run_existing → add_scenarios when the test-designer
+            // produced new test cases. This ensures designed tests are generated even if
+            // impact-analyst thought existing coverage was sufficient. The test-designer
+            // only runs for flows the strategist deemed worth testing.
+            action: decision.action === 'run_existing' && designedScenarios.length > 0
+                ? 'add_scenarios'
+                : decision.action,
+        };
+    });
+}
+export class GeneratorAgent {
+    constructor() {
+        this.role = 'generator';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        const enrichedDecisions = enrichDecisionsWithTestDesigns(ctx);
+        const actionable = enrichedDecisions.filter((d) => d.action === 'create_spec' || d.action === 'add_scenarios');
+        if (actionable.length === 0) {
+            warnings.push('Generator: no actionable decisions for generation.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        try {
+            const result = await runGenerationStage(enrichedDecisions, ctx.apiSurface, ctx.testsRoot, { provider: ctx.providerOverride });
+            ctx.generatedSpecs.push(...result.generated);
+            warnings.push(...result.warnings);
+            return {
+                role: this.role,
+                status: result.generatedCount > 0 ? 'success' : 'partial',
+                output: result,
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Generator failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}

package/dist/esm/agents/healer.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Healer Agent — wraps pipeline stage4 (test healing) in the Agent interface.
+ */
+import { runHealStage, resolveHealTargets } from '../pipeline/stage4_heal.js';
+export class HealerAgent {
+    constructor() {
+        this.role = 'healer';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        const healTargets = resolveHealTargets(ctx.testsRoot, { generatedSpecs: ctx.generatedSpecs }, ctx.impactedFlows);
+        if (healTargets.length === 0) {
+            warnings.push('Healer: no heal targets found.');
+            return { role: this.role, status: 'partial', output: null, warnings };
+        }
+        const result = await runHealStage(ctx.testsRoot, healTargets, { mcp: true });
+        warnings.push(...result.warnings);
+        return {
+            role: this.role,
+            status: result.healSuccess > 0 ? 'success' : 'partial',
+            output: result,
+            warnings,
+        };
+    }
+}

package/dist/esm/agents/impact-analyst.js

@@ -0,0 +1,34 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Impact Analyst Agent — wraps pipeline stage1 (impact analysis) in the Agent interface.
+ */
+import { runImpactStage } from '../pipeline/stage1_impact.js';
+export class ImpactAnalystAgent {
+    constructor() {
+        this.role = 'impact-analyst';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.familyGroups.length === 0) {
+            warnings.push('Impact analyst: no family groups to analyze.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        try {
+            const result = await runImpactStage(ctx.familyGroups, ctx.manifest, ctx.specIndex, ctx.apiSurface, ctx.context, { provider: ctx.providerOverride });
+            ctx.impactedFlows.push(...result.decisions);
+            warnings.push(...result.warnings);
+            return {
+                role: this.role,
+                status: result.decisions.length > 0 ? 'success' : 'partial',
+                output: result.decisions,
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Impact analyst failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}

package/dist/esm/agents/regression-advisor.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Regression Advisor Agent — identifies historically regression-prone areas
+ * using traceability data and advises the Strategist on risk scores.
+ * Mostly deterministic (traceability data analysis), with optional LLM enrichment.
+ */
+import { readCalibration, readFlakyTests } from '../agent/feedback.js';
+const FLAKY_RISK_MULTIPLIER = 15;
+const LOW_PRECISION_RISK_MULTIPLIER = 30;
+const PATTERN_RISK_SCORE = 30;
+const PATTERN_RISK_ADDITIVE = 20;
+const MAX_RISK_SCORE = 100;
+const MIN_PRECISION_THRESHOLD = 0.5;
+const MIN_CALIBRATION_SAMPLES = 3;
+export class RegressionAdvisorAgent {
+    constructor() {
+        this.role = 'regression-advisor';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        const risks = [];
+        // Analyze calibration data for historical failure patterns
+        const calibration = readCalibration(ctx.testsRoot);
+        const flakyData = readFlakyTests(ctx.testsRoot);
+        // Build risk from flaky test data
+        if (flakyData && flakyData.tests.length > 0) {
+            const flakyByFamily = new Map();
+            for (const test of flakyData.tests) {
+                // Use subsystem field as family identifier
+                if (test.subsystem) {
+                    flakyByFamily.set(test.subsystem, (flakyByFamily.get(test.subsystem) || 0) + 1);
+                }
+            }
+            for (const [familyId, count] of flakyByFamily) {
+                const isImpacted = ctx.familyGroups.some((g) => g.familyId === familyId);
+                if (isImpacted) {
+                    risks.push({
+                        familyId,
+                        filePattern: '*',
+                        riskScore: Math.min(MAX_RISK_SCORE, count * FLAKY_RISK_MULTIPLIER),
+                        reason: `${count} flaky test(s) historically in this family`,
+                        historicalFailures: count,
+                    });
+                }
+            }
+        }
+        // Build risk from calibration data (subsystem-level precision/recall)
+        if (calibration && calibration.bySubsystem) {
+            for (const [subsystem, metrics] of Object.entries(calibration.bySubsystem)) {
+                const isImpacted = ctx.familyGroups.some((g) => g.familyId === subsystem);
+                if (!isImpacted)
+                    continue;
+                // Low precision means many false positives — the subsystem is noisy
+                if (metrics.precision < MIN_PRECISION_THRESHOLD && metrics.samples >= MIN_CALIBRATION_SAMPLES) {
+                    const existing = risks.find((r) => r.familyId === subsystem);
+                    const lowPrecisionScore = Math.round((1 - metrics.precision) * LOW_PRECISION_RISK_MULTIPLIER);
+                    if (existing) {
+                        existing.riskScore = Math.min(MAX_RISK_SCORE, existing.riskScore + lowPrecisionScore);
+                        existing.reason += `; low calibration precision (${(metrics.precision * 100).toFixed(0)}%)`;
+                    }
+                    else {
+                        risks.push({
+                            familyId: subsystem,
+                            filePattern: '*',
+                            riskScore: lowPrecisionScore,
+                            reason: `Low calibration precision (${(metrics.precision * 100).toFixed(0)}%) — historically noisy subsystem`,
+                            historicalFailures: metrics.samples,
+                        });
+                    }
+                }
+            }
+        }
+        // Analyze changed files for known regression-prone patterns
+        for (const group of ctx.familyGroups) {
+            const hasApiChange = group.files.some((f) => f.path.includes('/api/') || f.path.includes('/actions/') || f.path.includes('/reducers/'));
+            const hasAuthChange = group.files.some((f) => f.path.includes('auth') || f.path.includes('login') || f.path.includes('session'));
+            const hasDBChange = group.files.some((f) => f.path.includes('/store/') || f.path.includes('/model/') || f.path.includes('migration'));
+            if (hasApiChange || hasAuthChange || hasDBChange) {
+                const existing = risks.find((r) => r.familyId === group.familyId);
+                const patterns = [
+                    hasApiChange && 'API changes',
+                    hasAuthChange && 'auth changes',
+                    hasDBChange && 'data model changes',
+                ].filter(Boolean).join(', ');
+                if (existing) {
+                    existing.riskScore = Math.min(MAX_RISK_SCORE, existing.riskScore + PATTERN_RISK_ADDITIVE);
+                    existing.reason += `; regression-prone patterns: ${patterns}`;
+                }
+                else {
+                    risks.push({
+                        familyId: group.familyId,
+                        filePattern: group.files.map((f) => f.path).join(', '),
+                        riskScore: PATTERN_RISK_SCORE,
+                        reason: `Regression-prone file patterns detected: ${patterns}`,
+                        historicalFailures: 0,
+                    });
+                }
+            }
+        }
+        ctx.regressionRisks.push(...risks);
+        if (risks.length === 0) {
+            warnings.push('Regression advisor: no historical risk data found.');
+        }
+        return {
+            role: this.role,
+            status: risks.length > 0 ? 'success' : 'partial',
+            output: risks,
+            warnings,
+        };
+    }
+}

package/dist/esm/agents/strategist.js

@@ -0,0 +1,88 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Strategist Agent — designs overall test strategy from impact analysis,
+ * cross-impact data, and regression risk.
+ */
+import { getCrewProvider } from '../crew/provider.js';
+import { buildStrategistPrompt, parseStrategistResponse } from '../prompts/strategist.js';
+const VALID_APPROACHES = new Set(['full-test', 'smoke-test', 'skip', 'manual-review']);
+const VALID_CATEGORIES = new Set([
+    'happy-path', 'edge-case', 'boundary', 'negative',
+    'state-transition', 'race-condition', 'permission', 'accessibility', 'performance',
+]);
+const VALID_RISK = new Set(['high', 'medium', 'low', 'none']);
+export class StrategistAgent {
+    constructor() {
+        this.role = 'strategist';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.impactedFlows.length === 0) {
+            warnings.push('Strategist: no impacted flows to strategize.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        const prompt = buildStrategistPrompt({
+            impactedFlows: ctx.impactedFlows,
+            crossImpacts: ctx.crossImpacts,
+            regressionRisks: ctx.regressionRisks,
+        });
+        try {
+            const provider = await getCrewProvider(ctx.providerOverride, ctx.budgetUSD, {
+                agentRole: 'strategist',
+                modelRoutingProviderType: ctx.modelRoutingProviderType,
+                modelRoutingOverrides: ctx.modelRoutingOverrides,
+                budgetLedger: ctx.budgetLedger,
+            });
+            const response = await provider.generateText(prompt, {
+                maxTokens: 4000,
+                temperature: 0,
+                timeout: 45000,
+                systemPrompt: 'Return only valid JSON. Do not include markdown fences unless necessary.',
+            });
+            const parsed = parseStrategistResponse(response.text);
+            if (!parsed || parsed.strategy.length === 0) {
+                warnings.push('Strategist: LLM returned no strategy.');
+                // Fall back to default strategy
+                ctx.strategyEntries.push(...this.buildDefaultStrategy(ctx));
+                return { role: this.role, status: 'partial', output: ctx.strategyEntries, warnings };
+            }
+            const entries = parsed.strategy.map((s) => ({
+                flowId: s.flowId,
+                flowName: s.flowName,
+                priority: (['P0', 'P1', 'P2'].includes(s.priority) ? s.priority : 'P2'),
+                approach: VALID_APPROACHES.has(s.approach) ? s.approach : 'full-test',
+                rationale: s.rationale || '',
+                testCategories: (s.testCategories || []).filter((c) => VALID_CATEGORIES.has(c)),
+                crossImpactRisk: VALID_RISK.has(s.crossImpactRisk) ? s.crossImpactRisk : 'none',
+            }));
+            ctx.strategyEntries.push(...entries);
+            return {
+                role: this.role,
+                status: 'success',
+                output: entries,
+                usage: provider.getUsageStats(),
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Strategist LLM failed: ${message}. Using default strategy.`);
+            ctx.strategyEntries.push(...this.buildDefaultStrategy(ctx));
+            return { role: this.role, status: 'partial', output: ctx.strategyEntries, warnings };
+        }
+    }
+    buildDefaultStrategy(ctx) {
+        return ctx.impactedFlows
+            .filter((f) => f.action !== 'cannot_determine')
+            .map((f) => ({
+            flowId: f.flowId,
+            flowName: f.flowName,
+            priority: f.priority,
+            approach: (f.action === 'create_spec' || f.action === 'add_scenarios' ? 'full-test' : 'smoke-test'),
+            rationale: 'Default strategy based on impact action.',
+            testCategories: ['happy-path', 'edge-case'],
+            crossImpactRisk: 'none',
+        }));
+    }
+}