@yasserkhanorg/impact-gate 2.0.0

package/dist/cli.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_js_1 = require("./agent/config.js");
+const parse_args_js_1 = require("./cli/parse_args.js");
+const defaults_js_1 = require("./cli/defaults.js");
+const usage_js_1 = require("./cli/usage.js");
+const llm_health_js_1 = require("./cli/commands/llm_health.js");
+const analyze_js_1 = require("./cli/commands/analyze.js");
+const feedback_js_1 = require("./cli/commands/feedback.js");
+const traceability_js_1 = require("./cli/commands/traceability.js");
+const finalize_js_1 = require("./cli/commands/finalize.js");
+const heal_js_1 = require("./cli/commands/heal.js");
+const impact_js_1 = require("./cli/commands/impact.js");
+const plan_js_1 = require("./cli/commands/plan.js");
+const generate_js_1 = require("./cli/commands/generate.js");
+const init_js_1 = require("./cli/commands/init.js");
+const train_js_1 = require("./cli/commands/train.js");
+const crew_js_1 = require("./cli/commands/crew.js");
+const cost_report_js_1 = require("./cli/commands/cost_report.js");
+const gate_js_1 = require("./cli/commands/gate.js");
+const bootstrap_js_1 = require("./cli/commands/bootstrap.js");
+const errors_js_1 = require("./cli/errors.js");
+// Commands that skip default resolution (they handle their own setup)
+const SKIP_DEFAULTS_COMMANDS = new Set(['init', 'llm-health', 'cost-report', 'bootstrap']);
+// Commands that need path/testsRoot/framework/since
+const NEEDS_DEFAULTS_COMMANDS = new Set([
+    'impact', 'plan', 'suggest', 'crew', 'generate', 'heal', 'analyze', 'train',
+    'feedback', 'traceability-capture', 'traceability-ingest', 'finalize-generated-tests',
+]);
+async function main() {
+    const args = (0, parse_args_js_1.parseArgs)(process.argv.slice(2));
+    const autoConfig = (0, parse_args_js_1.resolveAutoConfig)(args);
+    // Auto-detect defaults for commands that need them (when no config file found)
+    if (args.command && NEEDS_DEFAULTS_COMMANDS.has(args.command) && !SKIP_DEFAULTS_COMMANDS.has(args.command)) {
+        const defaults = (0, defaults_js_1.resolveDefaults)({
+            path: args.path,
+            testsRoot: args.testsRoot,
+            framework: args.framework,
+            gitSince: args.gitSince,
+        });
+        args.path = args.path || defaults.path;
+        args.testsRoot = args.testsRoot || defaults.testsRoot;
+        args.framework = args.framework || defaults.framework;
+        args.gitSince = args.gitSince || defaults.since;
+    }
+    if (args.command === 'init') {
+        const hasYes = process.argv.includes('--yes') || process.argv.includes('-y');
+        await (0, init_js_1.runInitCommand)(hasYes);
+        return;
+    }
+    if (args.command === 'bootstrap') {
+        await (0, bootstrap_js_1.runBootstrapCommand)(args);
+        return;
+    }
+    if (args.command === 'train') {
+        await (0, train_js_1.runTrainCommand)(args, autoConfig);
+        return;
+    }
+    if (args.help) {
+        (0, usage_js_1.printUsage)();
+        process.exit(0);
+    }
+    if (!args.command) {
+        (0, usage_js_1.printUsage)();
+        process.exit(1);
+    }
+    if (args.command === 'llm-health') {
+        await (0, llm_health_js_1.runLlmHealth)();
+        return;
+    }
+    if (args.command === 'analyze') {
+        await (0, analyze_js_1.runAnalyzeCommand)(args, autoConfig);
+        return;
+    }
+    if (args.command === 'feedback') {
+        (0, feedback_js_1.runFeedbackCommand)(args, autoConfig);
+        return;
+    }
+    if (args.command === 'traceability-capture') {
+        (0, traceability_js_1.runTraceabilityCaptureCommand)(args, autoConfig);
+        return;
+    }
+    if (args.command === 'traceability-ingest') {
+        (0, traceability_js_1.runTraceabilityIngestCommand)(args, autoConfig);
+        return;
+    }
+    if (args.command === 'finalize-generated-tests') {
+        (0, finalize_js_1.runFinalizeCommand)(args, autoConfig);
+        return;
+    }
+    if (args.command === 'heal') {
+        (0, heal_js_1.runHealCommand)(args, autoConfig);
+        return;
+    }
+    if (args.command === 'crew') {
+        await (0, crew_js_1.runCrewCommand)(args, autoConfig);
+        return;
+    }
+    if (args.command === 'cost-report') {
+        (0, cost_report_js_1.runCostReportCommand)(args);
+        return;
+    }
+    if (args.command === 'gate') {
+        await (0, gate_js_1.runGateCommand)(args, autoConfig);
+        return;
+    }
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required (or provide a config file with path set)');
+        (0, usage_js_1.printUsage)();
+        process.exit(1);
+    }
+    const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'impact',
+        framework: args.framework,
+        timeLimitMinutes: args.timeLimitMinutes,
+        budget: {
+            maxUSD: args.budgetUSD,
+            maxTokens: args.budgetTokens,
+        },
+        testPatterns: args.testPatterns,
+        flowPatterns: args.flowPatterns,
+        flowExclude: args.flowExclude,
+        flowCatalogPath: args.flowCatalogPath,
+        specPDF: args.specPDF,
+        gitSince: args.gitSince,
+        llmProvider: args.llmProvider,
+        pipeline: args.pipeline
+            ? {
+                enabled: true,
+                scenarios: args.pipelineScenarios,
+                outputDir: args.pipelineOutput,
+                baseUrl: args.pipelineBaseUrl,
+                browser: args.pipelineBrowser,
+                headless: args.pipelineHeadless,
+                project: args.pipelineProject,
+                parallel: args.pipelineParallel,
+                dryRun: args.pipelineDryRun,
+                mcp: args.pipelineMcp,
+                mcpAllowFallback: args.pipelineMcpAllowFallback,
+                mcpOnly: args.pipelineMcpOnly,
+                mcpCommandTimeoutMs: args.pipelineMcpTimeoutMs,
+                mcpRetries: args.pipelineMcpRetries,
+            }
+            : undefined,
+        policy: args.policyMinConfidence !== undefined ||
+            args.policySafeMergeConfidence !== undefined ||
+            args.policyWarningsThreshold !== undefined ||
+            (args.policyRiskyPatterns && args.policyRiskyPatterns.length > 0) ||
+            args.policyEnforcementMode !== undefined ||
+            (args.policyBlockActions && args.policyBlockActions.length > 0)
+            ? {
+                minConfidenceForTargeted: args.policyMinConfidence,
+                safeMergeMinConfidence: args.policySafeMergeConfidence,
+                forceFullOnWarningsAtOrAbove: args.policyWarningsThreshold,
+                riskyFilePatterns: args.policyRiskyPatterns,
+                enforcementMode: args.policyEnforcementMode,
+                blockOnActions: args.policyBlockActions,
+            }
+            : undefined,
+    });
+    if (args.command === 'impact') {
+        (0, impact_js_1.runImpactCommand)(args, config);
+        return;
+    }
+    if (args.command === 'suggest' || args.command === 'plan') {
+        await (0, plan_js_1.runPlanCommand)(args, autoConfig, config);
+        return;
+    }
+    if (args.command === 'generate') {
+        await (0, generate_js_1.runGenerateCommand)(args, config);
+        return;
+    }
+    console.error(`Unknown command: ${args.command}`);
+    (0, usage_js_1.printUsage)();
+    process.exit(1);
+}
+main().catch((error) => {
+    const exitCode = (0, errors_js_1.classifyError)(error);
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    if (exitCode === errors_js_1.EXIT_CODES.BUDGET_EXCEEDED) {
+        console.error('Hint: Increase --budget or use --degraded-mode to skip AI features.');
+    }
+    else if (exitCode === errors_js_1.EXIT_CODES.PROVIDER_UNAVAILABLE) {
+        console.error('Hint: Check API key or use --degraded-mode for deterministic analysis only.');
+    }
+    process.exit(exitCode);
+});

package/dist/crew/context.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Crew Context — shared mutable state accumulated by agents across workflow phases.
+ */
+import type { RouteFamily, RouteFamilyManifest } from '../knowledge/route_families.js';
+import type { ApiSurfaceCatalog } from '../knowledge/api_surface.js';
+import type { SpecIndex } from '../knowledge/spec_index.js';
+import type { FlowDecision } from '../validation/output_schema.js';
+import type { ProviderUsageStats } from '../provider_interface.js';
+import type { GeneratedSpec } from '../pipeline/stage3_generation.js';
+import type { LoadedContext } from '../knowledge/context_loader.js';
+import type { FamilyGroup, PreprocessResult } from '../pipeline/stage0_preprocess.js';
+import type { BudgetLedger } from '../budget_ledger.js';
+import type { AgentMessage } from './protocol.js';
+import type { TestDesign, CrossImpact, Finding, StrategyEntry, RegressionRisk } from './types.js';
+export interface CrewContext {
+    changedFiles: string[];
+    routeFamilies: RouteFamily[];
+    manifest: RouteFamilyManifest | null;
+    apiSurface: ApiSurfaceCatalog;
+    specIndex: SpecIndex;
+    context: LoadedContext;
+    familyGroups: FamilyGroup[];
+    preprocessResult: PreprocessResult | null;
+    appPath: string;
+    testsRoot: string;
+    gitSince: string;
+    providerOverride?: string;
+    budgetUSD?: number;
+    modelRoutingProviderType?: string;
+    modelRoutingOverrides?: Record<string, string>;
+    /** @internal Shared budget enforcement — not part of the public API. */
+    budgetLedger?: BudgetLedger;
+    impactedFlows: FlowDecision[];
+    strategyEntries: StrategyEntry[];
+    testDesigns: TestDesign[];
+    crossImpacts: CrossImpact[];
+    regressionRisks: RegressionRisk[];
+    findings: Finding[];
+    generatedSpecs: GeneratedSpec[];
+    usage: ProviderUsageStats;
+    agentUsage: AgentUsageEntry[];
+    messages: AgentMessage[];
+    warnings: string[];
+}
+export interface AgentUsageEntry {
+    agent: string;
+    family?: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    durationMs: number;
+}
+export declare function createEmptyUsageStats(): ProviderUsageStats;
+export declare function mergeUsageStats(target: ProviderUsageStats, source: ProviderUsageStats): void;
+//# sourceMappingURL=context.d.ts.map

package/dist/crew/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/crew/context.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AACrF,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAC,WAAW,EAAE,gBAAgB,EAAC,MAAM,kCAAkC,CAAC;AACpF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAC,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,YAAY,CAAC;AAEhG,MAAM,WAAW,WAAW;IAExB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACrC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,aAAa,CAAC;IACvB,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAG1C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C,wEAAwE;IACxE,YAAY,CAAC,EAAE,YAAY,CAAC;IAG5B,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,eAAe,EAAE,aAAa,EAAE,CAAC;IACjC,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,cAAc,EAAE,aAAa,EAAE,CAAC;IAGhC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,qBAAqB,IAAI,kBAAkB,CAa1D;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAe5F"}

package/dist/crew/context.js

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

@@ -0,0 +1,50 @@
+import type { RouteFamilyConfig } from '../knowledge/route_families.js';
+import type { ApiSurfaceConfig } from '../knowledge/api_surface.js';
+import type { Agent, AgentMessage, AgentResult } from './protocol.js';
+import type { CrewContext } from './context.js';
+import type { AgentRole } from './types.js';
+import type { WorkflowName } from './workflows.js';
+export interface CrewConfig {
+    appPath: string;
+    testsRoot: string;
+    gitSince: string;
+    gitIncludeUncommitted?: boolean;
+    routeFamilies?: RouteFamilyConfig;
+    apiSurface?: ApiSurfaceConfig;
+    workflow?: WorkflowName;
+    providerOverride?: string;
+    budgetUSD?: number;
+    dryRun?: boolean;
+    plugins?: string[];
+}
+export interface CrewResult {
+    context: CrewContext;
+    warnings: string[];
+    timings: Record<string, number>;
+    dryRun?: boolean;
+}
+export declare class CrewOrchestrator {
+    private agents;
+    registerAgent(agent: Agent): void;
+    /**
+     * Load and register plugins from file paths.
+     * Each module must default-export an object satisfying AgentPlugin.
+     */
+    loadPlugins(pluginPaths: string[]): Promise<string[]>;
+    run(config: CrewConfig): Promise<CrewResult>;
+    dispatch(role: AgentRole, action: string, ctx: CrewContext): Promise<AgentResult>;
+    parallel(roles: AgentRole[], action: string, ctx: CrewContext): Promise<AgentResult[]>;
+    broadcast(msg: AgentMessage, ctx: CrewContext): Promise<void>;
+    private runBuiltInPhase;
+    private runParallel;
+    private runSequential;
+    /**
+     * Inject loaded plugins into workflow phases based on their `phase` and `runAfter` fields.
+     * Plugins with `runAfter` dependencies are appended to the sequential list of the matching phase;
+     * plugins without `runAfter` are appended to the parallel list.
+     * Returns a new array of phases (does not mutate the original workflow definition).
+     */
+    private injectPluginsIntoPhases;
+    private checkPhaseResults;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/crew/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/crew/orchestrator.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAC,KAAK,EAAE,YAAY,EAAe,WAAW,EAAY,MAAM,eAAe,CAAC;AAC5F,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAA6B,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAG7E,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAA+B;IAE7C,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAIjC;;;OAGG;IACG,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAqCrD,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAiG5C,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IA0CjF,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtF,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;YAerD,eAAe;YAwBf,WAAW;YAMX,aAAa;IAS3B;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IA2E/B,OAAO,CAAC,iBAAiB;CAM5B"}

package/dist/crew/orchestrator.js

@@ -0,0 +1,329 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrewOrchestrator = void 0;
+/**
+ * Crew Orchestrator — executes workflow definitions by dispatching to agents.
+ */
+const git_js_1 = require("../agent/git.js");
+const stage0_preprocess_js_1 = require("../pipeline/stage0_preprocess.js");
+const logger_js_1 = require("../logger.js");
+const base_provider_js_1 = require("../base_provider.js");
+const budget_ledger_js_1 = require("../budget_ledger.js");
+const context_js_1 = require("./context.js");
+const workflows_js_1 = require("./workflows.js");
+class CrewOrchestrator {
+    constructor() {
+        this.agents = new Map();
+    }
+    registerAgent(agent) {
+        this.agents.set(agent.role, agent);
+    }
+    /**
+     * Load and register plugins from file paths.
+     * Each module must default-export an object satisfying AgentPlugin.
+     */
+    async loadPlugins(pluginPaths) {
+        const loaded = [];
+        for (const pluginPath of pluginPaths) {
+            try {
+                // Security: Only allow relative paths (starting with . or ..) to prevent loading arbitrary modules.
+                // Absolute paths, URLs, and node_modules references are rejected.
+                if (!pluginPath.startsWith('.')) {
+                    logger_js_1.logger.warn(`Plugin path must be relative (start with ./): ${pluginPath} — skipped`);
+                    continue;
+                }
+                const resolved = new URL(pluginPath, `file://${process.cwd()}/`).href;
+                // Security: reject paths that resolve outside the workspace (e.g., ../../etc/evil.js)
+                const cwd = `file://${process.cwd()}/`;
+                if (!resolved.startsWith(cwd)) {
+                    logger_js_1.logger.warn(`Plugin path '${pluginPath}' resolves outside workspace — skipped`);
+                    continue;
+                }
+                const mod = await import(resolved);
+                const plugin = mod.default || mod;
+                if (!plugin.role || typeof plugin.execute !== 'function') {
+                    logger_js_1.logger.warn(`Plugin at ${pluginPath} missing required role/execute — skipped`);
+                    continue;
+                }
+                // Warn if plugin overrides a built-in agent
+                if (this.agents.has(plugin.role)) {
+                    logger_js_1.logger.warn(`Plugin '${plugin.role}' overrides built-in agent — ensure this is intentional`);
+                }
+                this.agents.set(plugin.role, plugin);
+                loaded.push(plugin.role);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                logger_js_1.logger.warn(`Failed to load plugin ${pluginPath}: ${msg}`);
+            }
+        }
+        return loaded;
+    }
+    async run(config) {
+        const workflow = workflows_js_1.WORKFLOWS[config.workflow || 'full-qa'];
+        const timings = {};
+        const warnings = [];
+        // Load plugins if configured, then inject them into workflow phases
+        const pluginRoles = [];
+        if (config.plugins && config.plugins.length > 0) {
+            const loaded = await this.loadPlugins(config.plugins);
+            pluginRoles.push(...loaded);
+            if (loaded.length > 0) {
+                logger_js_1.logger.info(`Loaded ${loaded.length} plugins: ${loaded.join(', ')}`);
+            }
+        }
+        const effectivePhases = this.injectPluginsIntoPhases(workflow.phases, pluginRoles);
+        // Step 1: Get changed files
+        const gitResult = (0, git_js_1.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) => !(0, git_js_1.isTestFile)(f));
+        if (changedFiles.length === 0) {
+            warnings.push('No changed application files detected.');
+        }
+        // Create shared budget ledger for aggregate cost tracking across all agents
+        const budgetLedger = config.budgetUSD ? new budget_ledger_js_1.BudgetLedger(config.budgetUSD) : undefined;
+        // 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,
+            budgetUSD: config.budgetUSD,
+            budgetLedger,
+            impactedFlows: [],
+            strategyEntries: [],
+            testDesigns: [],
+            crossImpacts: [],
+            regressionRisks: [],
+            findings: [],
+            generatedSpecs: [],
+            usage: (0, context_js_1.createEmptyUsageStats)(),
+            agentUsage: [],
+            messages: [],
+            warnings,
+        };
+        // Execute each phase
+        for (const phase of effectivePhases) {
+            const timer = logger_js_1.logger.timer(`crew:${phase.name}`);
+            if (phase.handler === 'built-in') {
+                await this.runBuiltInPhase(phase.name, ctx, config);
+                // Dry-run: after preprocess, return summary without running agents
+                if (config.dryRun && phase.name === 'preprocess') {
+                    timings[phase.name] = timer.end();
+                    ctx.warnings.push('Dry run — no LLM calls were made.');
+                    return { context: ctx, warnings, timings, dryRun: true };
+                }
+            }
+            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 — prefer ledger (aggregate across all providers) over ctx.usage
+            const currentCost = budgetLedger ? budgetLedger.totalCost : ctx.usage.totalCost;
+            if (config.budgetUSD && currentCost >= config.budgetUSD) {
+                warnings.push(`Budget limit reached ($${currentCost.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 };
+        const startMs = Date.now();
+        try {
+            const result = await agent.execute(task, ctx);
+            const durationMs = Date.now() - startMs;
+            if (result.usage) {
+                (0, context_js_1.mergeUsageStats)(ctx.usage, result.usage);
+                ctx.agentUsage.push({
+                    agent: role,
+                    inputTokens: result.usage.totalInputTokens,
+                    outputTokens: result.usage.totalOutputTokens,
+                    cost: result.usage.totalCost,
+                    durationMs,
+                });
+            }
+            if (result.warnings && result.warnings.length > 0) {
+                ctx.warnings.push(...result.warnings);
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof base_provider_js_1.BudgetExceededError) {
+                ctx.warnings.push(`Budget exceeded ($${error.currentCost.toFixed(4)} >= $${error.budgetUSD}). Agent '${role}' skipped.`);
+                return { role, status: 'failed', output: null, warnings: [error.message] };
+            }
+            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 = (0, stage0_preprocess_js_1.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_js_1.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_js_1.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);
+    }
+    /**
+     * Inject loaded plugins into workflow phases based on their `phase` and `runAfter` fields.
+     * Plugins with `runAfter` dependencies are appended to the sequential list of the matching phase;
+     * plugins without `runAfter` are appended to the parallel list.
+     * Returns a new array of phases (does not mutate the original workflow definition).
+     */
+    injectPluginsIntoPhases(phases, pluginRoles) {
+        if (pluginRoles.length === 0)
+            return phases;
+        // Build mutable copies keyed by phase name
+        const phaseMap = new Map();
+        const ordered = [];
+        for (const p of phases) {
+            ordered.push(p.name);
+            if (p.handler === 'built-in') {
+                phaseMap.set(p.name, { handler: 'built-in' });
+            }
+            else if (p.parallel) {
+                phaseMap.set(p.name, { parallel: [...p.parallel] });
+            }
+            else if (p.sequential) {
+                phaseMap.set(p.name, { sequential: [...p.sequential] });
+            }
+        }
+        for (const role of pluginRoles) {
+            const agent = this.agents.get(role);
+            if (!agent)
+                continue;
+            const plugin = agent;
+            if (!plugin.phase)
+                continue;
+            const target = phaseMap.get(plugin.phase);
+            if (!target) {
+                logger_js_1.logger.warn(`Plugin '${role}' targets phase '${plugin.phase}' which does not exist in workflow — skipped`);
+                continue;
+            }
+            if (target.handler === 'built-in') {
+                logger_js_1.logger.warn(`Plugin '${role}' targets built-in phase '${plugin.phase}' — not supported, skipped`);
+                continue;
+            }
+            const pluginRole = role;
+            if (plugin.runAfter && plugin.runAfter.length > 0) {
+                // Validate that runAfter dependencies are either in this phase or a prior phase
+                const phaseRoles = target.parallel || target.sequential || [];
+                const missingDeps = plugin.runAfter.filter((dep) => !phaseRoles.includes(dep) && !this.agents.has(dep));
+                if (missingDeps.length > 0) {
+                    logger_js_1.logger.warn(`Plugin '${role}' has unresolved runAfter deps [${missingDeps.join(', ')}] — injecting anyway`);
+                }
+                // Plugin has dependencies — must run sequentially
+                if (target.sequential) {
+                    target.sequential.push(pluginRole);
+                }
+                else if (target.parallel) {
+                    // Convert to sequential to respect dependency ordering
+                    target.sequential = [...target.parallel, pluginRole];
+                    delete target.parallel;
+                }
+            }
+            else {
+                if (target.parallel) {
+                    target.parallel.push(pluginRole);
+                }
+                else if (target.sequential) {
+                    target.sequential.push(pluginRole);
+                }
+            }
+            logger_js_1.logger.info(`Plugin '${role}' injected into phase '${plugin.phase}'`);
+        }
+        // Rebuild WorkflowPhase array
+        return ordered.map((name) => {
+            const entry = phaseMap.get(name);
+            if (entry.handler === 'built-in')
+                return { name, handler: 'built-in' };
+            if (entry.parallel)
+                return { name, parallel: entry.parallel };
+            if (entry.sequential)
+                return { name, sequential: entry.sequential };
+            throw new Error(`Phase '${name}' has no handler, parallel, or sequential agents after plugin injection`);
+        });
+    }
+    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.`);
+        }
+    }
+}
+exports.CrewOrchestrator = CrewOrchestrator;