@yasserkhanorg/impact-gate 2.0.0

package/dist/agents/generator.js

@@ -0,0 +1,77 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorAgent = void 0;
+/**
+ * Generator Agent — wraps pipeline stage3 (test generation) in the Agent interface.
+ * Enhanced to accept TestCase[] from the Test Designer in addition to flat scenariosToAdd.
+ */
+const stage3_generation_js_1 = require("../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,
+        };
+    });
+}
+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 (0, stage3_generation_js_1.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 };
+        }
+    }
+}
+exports.GeneratorAgent = GeneratorAgent;

package/dist/agents/healer.d.ts

@@ -0,0 +1,8 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class HealerAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=healer.d.ts.map

package/dist/agents/healer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"healer.d.ts","sourceRoot":"","sources":["../../src/agents/healer.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAEhD,qBAAa,WAAY,YAAW,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAY;IAE9B,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAwB1E"}

package/dist/agents/healer.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealerAgent = void 0;
+/**
+ * Healer Agent — wraps pipeline stage4 (test healing) in the Agent interface.
+ */
+const stage4_heal_js_1 = require("../pipeline/stage4_heal.js");
+class HealerAgent {
+    constructor() {
+        this.role = 'healer';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        const healTargets = (0, stage4_heal_js_1.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 (0, stage4_heal_js_1.runHealStage)(ctx.testsRoot, healTargets, { mcp: true });
+        warnings.push(...result.warnings);
+        return {
+            role: this.role,
+            status: result.healSuccess > 0 ? 'success' : 'partial',
+            output: result,
+            warnings,
+        };
+    }
+}
+exports.HealerAgent = HealerAgent;

package/dist/agents/impact-analyst.d.ts

@@ -0,0 +1,8 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class ImpactAnalystAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=impact-analyst.d.ts.map

package/dist/agents/impact-analyst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-analyst.d.ts","sourceRoot":"","sources":["../../src/agents/impact-analyst.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAEhD,qBAAa,kBAAmB,YAAW,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAoB;IAEtC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAiC1E"}

package/dist/agents/impact-analyst.js

@@ -0,0 +1,38 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImpactAnalystAgent = void 0;
+/**
+ * Impact Analyst Agent — wraps pipeline stage1 (impact analysis) in the Agent interface.
+ */
+const stage1_impact_js_1 = require("../pipeline/stage1_impact.js");
+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 (0, stage1_impact_js_1.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 };
+        }
+    }
+}
+exports.ImpactAnalystAgent = ImpactAnalystAgent;

package/dist/agents/regression-advisor.d.ts

@@ -0,0 +1,8 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class RegressionAdvisorAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=regression-advisor.d.ts.map

package/dist/agents/regression-advisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regression-advisor.d.ts","sourceRoot":"","sources":["../../src/agents/regression-advisor.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAiB,MAAM,kBAAkB,CAAC;AAUhE,qBAAa,sBAAuB,YAAW,KAAK;IAChD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAwB;IAE1C,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CA0G1E"}

package/dist/agents/regression-advisor.js

@@ -0,0 +1,116 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegressionAdvisorAgent = void 0;
+/**
+ * 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.
+ */
+const feedback_js_1 = require("../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;
+class RegressionAdvisorAgent {
+    constructor() {
+        this.role = 'regression-advisor';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        const risks = [];
+        // Analyze calibration data for historical failure patterns
+        const calibration = (0, feedback_js_1.readCalibration)(ctx.testsRoot);
+        const flakyData = (0, feedback_js_1.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,
+        };
+    }
+}
+exports.RegressionAdvisorAgent = RegressionAdvisorAgent;

package/dist/agents/strategist.d.ts

@@ -0,0 +1,9 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class StrategistAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+    private buildDefaultStrategy;
+}
+//# sourceMappingURL=strategist.d.ts.map

package/dist/agents/strategist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategist.d.ts","sourceRoot":"","sources":["../../src/agents/strategist.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAA8B,MAAM,kBAAkB,CAAC;AAS7E,qBAAa,eAAgB,YAAW,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAgB;IAElC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAkEvE,OAAO,CAAC,oBAAoB;CAa/B"}

package/dist/agents/strategist.js

@@ -0,0 +1,92 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategistAgent = void 0;
+/**
+ * Strategist Agent — designs overall test strategy from impact analysis,
+ * cross-impact data, and regression risk.
+ */
+const provider_js_1 = require("../crew/provider.js");
+const strategist_js_1 = require("../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']);
+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 = (0, strategist_js_1.buildStrategistPrompt)({
+            impactedFlows: ctx.impactedFlows,
+            crossImpacts: ctx.crossImpacts,
+            regressionRisks: ctx.regressionRisks,
+        });
+        try {
+            const provider = await (0, provider_js_1.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 = (0, strategist_js_1.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',
+        }));
+    }
+}
+exports.StrategistAgent = StrategistAgent;

package/dist/agents/test-designer.d.ts

@@ -0,0 +1,8 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class TestDesignerAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=test-designer.d.ts.map

package/dist/agents/test-designer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-designer.d.ts","sourceRoot":"","sources":["../../src/agents/test-designer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAoD,MAAM,kBAAkB,CAAC;AASnG,qBAAa,iBAAkB,YAAW,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAmB;IAErC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAwG1E"}

package/dist/agents/test-designer.js

@@ -0,0 +1,111 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestDesignerAgent = void 0;
+/**
+ * Test Designer Agent — designs structured test cases across 9 categories.
+ * Takes strategist output + API surface + existing specs and produces TestDesign[].
+ */
+const provider_js_1 = require("../crew/provider.js");
+const spec_index_js_1 = require("../knowledge/spec_index.js");
+const test_designer_js_1 = require("../prompts/test-designer.js");
+const MAX_TEST_CASES_PER_FLOW = 15;
+const VALID_TYPES = new Set([
+    'happy-path', 'edge-case', 'boundary', 'negative',
+    'state-transition', 'race-condition', 'permission', 'accessibility', 'performance',
+]);
+class TestDesignerAgent {
+    constructor() {
+        this.role = 'test-designer';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.strategyEntries.length === 0) {
+            warnings.push('Test designer: no strategy entries to design tests for.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        // Only design tests for flows with full-test or smoke-test approach
+        const designable = ctx.strategyEntries.filter((s) => s.approach === 'full-test' || s.approach === 'smoke-test');
+        if (designable.length === 0) {
+            warnings.push('Test designer: all flows are skip or manual-review.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        let provider;
+        try {
+            provider = await (0, provider_js_1.getCrewProvider)(ctx.providerOverride, ctx.budgetUSD, {
+                agentRole: 'test-designer',
+                modelRoutingProviderType: ctx.modelRoutingProviderType,
+                modelRoutingOverrides: ctx.modelRoutingOverrides,
+                budgetLedger: ctx.budgetLedger,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Test designer provider unavailable: ${message}`);
+            return { role: this.role, status: 'failed', output: [], warnings };
+        }
+        const designs = [];
+        for (const strategy of designable) {
+            const flow = ctx.impactedFlows.find((f) => f.flowId === strategy.flowId);
+            if (!flow) {
+                warnings.push(`Test designer: strategy entry '${strategy.flowId}' has no matching flow.`);
+                continue;
+            }
+            const familySpecs = (0, spec_index_js_1.getSpecsForFamily)(ctx.specIndex, flow.routeFamily, flow.featureId);
+            const relevantCrossImpacts = ctx.crossImpacts.filter((ci) => ci.sourceFamily === flow.routeFamily || ci.affectedFamily === flow.routeFamily);
+            const prompt = (0, test_designer_js_1.buildTestDesignerPrompt)({
+                flow,
+                strategy,
+                apiSurface: ctx.apiSurface,
+                existingSpecs: familySpecs,
+                crossImpacts: relevantCrossImpacts,
+            });
+            try {
+                const response = await provider.generateText(prompt, {
+                    maxTokens: 4000,
+                    temperature: 0.1,
+                    timeout: 60000,
+                    systemPrompt: 'Return only valid JSON. Do not include markdown fences unless necessary.',
+                });
+                const parsed = (0, test_designer_js_1.parseTestDesignerResponse)(response.text);
+                if (!parsed || parsed.testDesign.testCases.length === 0) {
+                    warnings.push(`Test designer: no test cases returned for flow ${strategy.flowId}.`);
+                    continue;
+                }
+                const validatedCases = parsed.testDesign.testCases
+                    .filter((tc) => tc.name && tc.steps && tc.steps.length > 0)
+                    .map((tc) => ({
+                    name: tc.name,
+                    type: VALID_TYPES.has(tc.type) ? tc.type : 'happy-path',
+                    preconditions: Array.isArray(tc.preconditions) ? tc.preconditions : [],
+                    steps: Array.isArray(tc.steps) ? tc.steps : [],
+                    expectedOutcome: tc.expectedOutcome || '',
+                    priority: (['P0', 'P1', 'P2'].includes(tc.priority) ? tc.priority : 'P2'),
+                    rationale: tc.rationale || '',
+                }))
+                    .slice(0, MAX_TEST_CASES_PER_FLOW);
+                if (validatedCases.length > 0) {
+                    designs.push({
+                        flowId: strategy.flowId,
+                        flowName: strategy.flowName,
+                        testCases: validatedCases,
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                warnings.push(`Test designer failed for flow ${strategy.flowId}: ${message}`);
+            }
+        }
+        ctx.testDesigns.push(...designs);
+        return {
+            role: this.role,
+            status: designs.length > 0 ? 'success' : 'partial',
+            output: designs,
+            usage: provider.getUsageStats(),
+            warnings,
+        };
+    }
+}
+exports.TestDesignerAgent = TestDesignerAgent;

package/dist/anthropic_provider.d.ts

@@ -0,0 +1,65 @@
+import type { AnthropicConfig, GenerateOptions, ImageInput, LLMResponse, ProviderCapabilities } from './provider_interface.js';
+import { BaseProvider } from './base_provider.js';
+/**
+ * Anthropic Provider - Claude AI models
+ *
+ * Features:
+ * - Highest quality AI (98% accuracy in testing)
+ * - Vision support (analyze screenshots, compare UI)
+ * - Fast response times (<1 second)
+ * - 200K token context window
+ * - Prompt caching (reduces costs by 90% on repeated prompts)
+ *
+ * Costs (Claude Sonnet 4.5):
+ * - Input: $3 per 1M tokens
+ * - Output: $15 per 1M tokens
+ * - Cached input: $0.30 per 1M tokens
+ * - Estimated: ~$30-80/month for autonomous testing
+ *
+ * Use cases:
+ * - Vision tasks (screenshot comparison)
+ * - Complex failure diagnosis
+ * - High-stakes production testing
+ * - When quality is paramount
+ *
+ * Models:
+ * - claude-sonnet-4-5-20250929 (recommended - best balance)
+ * - claude-opus-4-5-20251101 (highest quality, slower, more expensive)
+ * - claude-haiku-4-0-20250430 (fastest, cheapest, lower quality)
+ */
+export declare class AnthropicProvider extends BaseProvider {
+    name: string;
+    private client;
+    private model;
+    capabilities: ProviderCapabilities;
+    constructor(config: AnthropicConfig);
+    generateText(prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    analyzeImage(images: ImageInput[], prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    streamText(prompt: string, options?: GenerateOptions): AsyncGenerator<string, void, unknown>;
+    private extractTextFromResponse;
+    /**
+     * SECURITY: Type-safe usage extraction
+     * Avoids unsafe `as any` casts
+     */
+    private extractUsageFromResponse;
+    /**
+     * SECURITY: Extract status code safely
+     */
+    private extractStatusCode;
+    /**
+     * Check if API key is valid and service is accessible
+     */
+    checkHealth(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+}
+/**
+ * Helper to check Anthropic setup
+ */
+export declare function checkAnthropicSetup(apiKey: string): Promise<{
+    valid: boolean;
+    message: string;
+    estimatedMonthlyCost: string;
+}>;
+//# sourceMappingURL=anthropic_provider.d.ts.map

package/dist/anthropic_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic_provider.d.ts","sourceRoot":"","sources":["../src/anthropic_provider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACR,eAAe,EACf,eAAe,EACf,UAAU,EACV,WAAW,EACX,oBAAoB,EACvB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAehD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IAC/C,IAAI,SAAe;IACnB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAAS;IAEtB,YAAY,EAAE,oBAAoB,CAShC;gBAEU,MAAM,EAAE,eAAe;IA4B7B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IA6D7E,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAgHlG,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;IA4CnG,OAAO,CAAC,uBAAuB;IAU/B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAchC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;CAyBpE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/D,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB,EAAE,MAAM,CAAC;CAChC,CAAC,CAyBD"}