@yasserkhanorg/e2e-agents 1.7.7 → 1.8.1

package/README.md

@@ -11,6 +11,9 @@ AI-powered E2E test impact analysis, generation, healing, and autonomous QA for
 Given a git diff, `e2e-ai-agents` determines which E2E test flows are impacted, identifies coverage gaps, and can generate or heal Playwright tests — all from the CLI. The companion `e2e-qa-agent` goes further: it opens a real browser, explores your app autonomously, and produces a QA report with findings and a release-readiness verdict.
 
 **Pipeline:** `impact` → `plan` → `generate` → `heal` → `finalize`
+**Crew (v1.8.0):** `impact` + `cross-impact` + `regression-advisor` → `strategist` → `test-designer` → `generator` → `executor` → `healer`
+
+> **How does this compare to other tools?** See [docs/comparison.md](docs/comparison.md) for a detailed analysis against Launchable, Codecov ATS, Qodo, Testsigma, mabl, GitHub Copilot, and others.
 
 ## Installation
 
@@ -54,6 +57,58 @@ npx e2e-ai-agents llm-health
 
 `plan` and `suggest` are aliases. `analyze` is a convenience wrapper that runs impact + plan and optionally generation/healing in one invocation. Use `--help` for all available flags.
 
+## Multi-Agent Crew (v1.8.0)
+
+The Crew orchestrates 10 specialized agents for deep test analysis. While the standard pipeline gives a fast pass/fail gate, the Crew produces structured test designs, cross-family impact maps, and prioritized test strategies.
+
+```bash
+# Quick strategy: impact + strategy recommendations (~$0.10, ~1 min)
+npx e2e-ai-agents crew --workflow quick-check --path /path/to/project --tests-root ./e2e-tests --since origin/master
+
+# Full test design without generation (~$0.50-2.00, ~5-40 min)
+npx e2e-ai-agents crew --workflow design-only --path /path/to/project --tests-root ./e2e-tests --since origin/master
+
+# End-to-end: design + generate + execute + heal (~$2-5, ~10-60 min)
+npx e2e-ai-agents crew --workflow full-qa --path /path/to/project --tests-root ./e2e-tests --since origin/master
+
+# With budget cap and JSON output
+npx e2e-ai-agents crew --workflow design-only --budget-usd 2.00 --json --path /path/to/project --tests-root ./e2e-tests --since origin/master
+```
+
+### What the Crew Adds Beyond the Pipeline
+
+| Capability | Pipeline | Crew |
+|-----------|---------|------|
+| Impact detection | Per-family, isolated | Same + cross-family ripple detection |
+| Test scenarios | Flat `scenariosToAdd` strings | Structured `TestCase[]` with type, preconditions, steps, expected outcome, rationale |
+| Test categories | None | 9: happy-path, edge-case, boundary, negative, state-transition, race-condition, permission, accessibility, performance |
+| Strategy | None | Per-flow approach (full-test / smoke-test / skip) with priority and rationale |
+| Regression awareness | None | Risk scoring from flaky history, calibration data, and file-pattern heuristics |
+
+### Programmatic API
+
+```typescript
+import { CrewOrchestrator, ImpactAnalystAgent, StrategistAgent, TestDesignerAgent, CrossImpactAgent, RegressionAdvisorAgent } from '@yasserkhanorg/e2e-agents';
+
+const orchestrator = new CrewOrchestrator();
+orchestrator.registerAgent(new ImpactAnalystAgent());
+orchestrator.registerAgent(new CrossImpactAgent());
+orchestrator.registerAgent(new RegressionAdvisorAgent());
+orchestrator.registerAgent(new StrategistAgent());
+orchestrator.registerAgent(new TestDesignerAgent());
+
+const result = await orchestrator.run({
+    appPath: './webapp',
+    testsRoot: './e2e-tests',
+    gitSince: 'origin/master',
+    workflow: 'design-only',
+});
+
+console.log(result.context.testDesigns);   // Structured test cases
+console.log(result.context.crossImpacts);  // Cross-family links
+console.log(result.context.strategyEntries); // Prioritized strategy
+```
+
 ## Route-Families Training
 
 ### What it produces

package/dist/agent/git.d.ts

@@ -9,5 +9,10 @@ export interface GitChangeResult {
 export interface GitChangeOptions {
     includeUncommitted?: boolean;
 }
+/**
+ * Check if a file path is a test file (spec, test, or in test directories).
+ * Shared across pipeline and crew orchestrators.
+ */
+export declare function isTestFile(file: string): boolean;
 export declare function getChangedFiles(appRoot: string, since: string, options?: GitChangeOptions): GitChangeResult;
 //# sourceMappingURL=git.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/agent/git.ts"],"names":[],"mappings":"AAkHA,MAAM,WAAW,eAAe;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,kLAAkL;IAClL,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,YAAY,GAAG,QAAQ,CAAC;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAChC;AAiFD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe,CA8D3G"}
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/agent/git.ts"],"names":[],"mappings":"AAkHA,MAAM,WAAW,eAAe;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,kLAAkL;IAClL,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,YAAY,GAAG,QAAQ,CAAC;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAChC;AAiFD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOhD;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe,CA8D3G"}

package/dist/agent/git.js

@@ -2,6 +2,7 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTestFile = isTestFile;
 exports.getChangedFiles = getChangedFiles;
 const child_process_1 = require("child_process");
 const utils_js_1 = require("./utils.js");
@@ -178,6 +179,18 @@ function isCommentOnlyDiff(file, repoRoot, baseRef) {
         return content === '' || commentEntry.pattern.test(content);
     });
 }
+/**
+ * Check if a file path is a test file (spec, test, or in test directories).
+ * Shared across pipeline and crew orchestrators.
+ */
+function isTestFile(file) {
+    const normalized = file.replace(/\\/g, '/');
+    return /\.(spec|test)\.(ts|tsx|js|jsx)$/.test(normalized) ||
+        /_test\.go$/.test(normalized) ||
+        normalized.includes('__tests__/') ||
+        normalized.includes('/tests/') ||
+        normalized.includes('/test/');
+}
 function getChangedFiles(appRoot, since, options) {
     try {
         const files = new Set();

package/dist/agents/coverage-evaluator.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 CoverageEvaluatorAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=coverage-evaluator.d.ts.map

package/dist/agents/coverage-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-evaluator.d.ts","sourceRoot":"","sources":["../../src/agents/coverage-evaluator.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,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;CAmC1E"}

package/dist/agents/coverage-evaluator.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoverageEvaluatorAgent = void 0;
+/**
+ * Coverage Evaluator Agent — wraps pipeline stage2 (coverage evaluation) in the Agent interface.
+ */
+const stage2_coverage_js_1 = require("../pipeline/stage2_coverage.js");
+class CoverageEvaluatorAgent {
+    constructor() {
+        this.role = 'coverage-evaluator';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.impactedFlows.length === 0) {
+            warnings.push('Coverage evaluator: no impacted flows to evaluate.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        try {
+            const result = await (0, stage2_coverage_js_1.runCoverageStage)(ctx.impactedFlows, ctx.specIndex, ctx.context, ctx.testsRoot, { provider: ctx.providerOverride });
+            // Replace impacted flows with coverage-enriched versions.
+            // This is intentionally a full replace (not push) because coverage evaluation
+            // returns the same flow IDs with updated coverage fields.
+            ctx.impactedFlows = result.decisions;
+            warnings.push(...result.warnings);
+            return {
+                role: this.role,
+                status: 'success',
+                output: result.decisions,
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Coverage evaluator failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}
+exports.CoverageEvaluatorAgent = CoverageEvaluatorAgent;

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

@@ -0,0 +1,13 @@
+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 CrossImpactAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+    /**
+     * Deterministic cross-impact detection: find families that share webapp/server paths
+     * or components with the directly impacted families.
+     */
+    private detectDeterministic;
+}
+//# sourceMappingURL=cross-impact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cross-impact.d.ts","sourceRoot":"","sources":["../../src/agents/cross-impact.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,EAAc,MAAM,kBAAkB,CAAC;AAK7D,qBAAa,gBAAiB,YAAW,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAkB;IAEpC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAuFvE;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAyC9B"}

package/dist/agents/cross-impact.js

@@ -0,0 +1,135 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossImpactAgent = void 0;
+/**
+ * Cross-Impact Analyst Agent — finds ripple effects across route families
+ * by analyzing shared dependencies between changed families and all other families.
+ */
+const provider_js_1 = require("../crew/provider.js");
+const cross_impact_js_1 = require("../prompts/cross-impact.js");
+const VALID_RISK = new Set(['high', 'medium', 'low']);
+const MAX_CROSS_IMPACTS = 50;
+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 (0, provider_js_1.getCrewProvider)(ctx.providerOverride);
+            const prompt = (0, cross_impact_js_1.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 = (0, cross_impact_js_1.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;
+    }
+}
+exports.CrossImpactAgent = CrossImpactAgent;

package/dist/agents/executor.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 ExecutorAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/agents/executor.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,EAAC,MAAM,kBAAkB,CAAC;AAKhD,qBAAa,aAAc,YAAW,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAc;IAEhC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAwD1E"}

package/dist/agents/executor.js

@@ -0,0 +1,70 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutorAgent = void 0;
+/**
+ * Executor Agent — wraps agentic test execution in the Agent interface.
+ * Runs generated specs through Playwright and collects results.
+ */
+const provider_js_1 = require("../crew/provider.js");
+const runner_js_1 = require("../agentic/runner.js");
+const MAX_FIX_ATTEMPTS = 2;
+const TEST_TIMEOUT_MS = 120000;
+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 (0, provider_js_1.getCrewProvider)(ctx.providerOverride);
+            const summary = await (0, runner_js_1.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 };
+        }
+    }
+}
+exports.ExecutorAgent = ExecutorAgent;

package/dist/agents/explorer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Explorer Agent — wraps the QA agent browser exploration loop in the Agent interface.
+ * This agent is optional and only runs when a browser environment is available.
+ */
+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 ExplorerAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=explorer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"explorer.d.ts","sourceRoot":"","sources":["../../src/agents/explorer.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,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,aAAc,YAAW,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAc;IAEhC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAmC1E"}

package/dist/agents/explorer.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplorerAgent = void 0;
+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 };
+        }
+    }
+}
+exports.ExplorerAgent = ExplorerAgent;

package/dist/agents/generator.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 GeneratorAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/agents/generator.ts"],"names":[],"mappings":"AASA,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;AA6ChD,qBAAa,cAAe,YAAW,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAe;IAEjC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAoC1E"}

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"}