swarm-engine 1.3.0 → 1.41.0

package/dist/runtime/engine.js

@@ -23,9 +23,32 @@ import { estimateCacheSavings } from './cache-optimizer.js';
 import { createLivingSpec, updateSpecFromPhase } from './living-spec.js';
 import { estimateTokens } from '../utils/tokens.js';
 import { unlinkSync } from 'fs';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const execFileAsync = promisify(execFile);
 import { AgentRunner } from './agent-runner.js';
 import { LearningEngine } from './learning-engine.js';
+import { ExecutionGraph } from './execution-graph.js';
+import { GraphLearner } from './graph-learner.js';
+import { GraphAnalyzer } from './graph-analyzer.js';
+import { GraphContextRouter } from './graph-context-router.js';
+import { ReviewFeedbackRecorder } from './graph-feedback.js';
+import { parseReviewOutput } from './review-schema.js';
 import { closeDatabase } from './database.js';
+import { CausalGraphEngine } from './graph-causal.js';
+import { FailurePropagationPredictor } from './graph-gnn.js';
+import { AdversarialEvolver } from './graph-adversarial.js';
+import { MetaPatternSelector } from './graph-meta.js';
+import { PredictiveDropout } from './graph-dropout.js';
+import { PatternSynthesizer } from './graph-synthesis.js';
+import { TrajectoryPredictor } from './graph-trajectory.js';
+import { MetaAdversarialTester } from './graph-meta-adversarial.js';
+import { RuleEvolver } from './graph-self-evolve.js';
+import { TaskDiscovery } from './graph-discovery.js';
+import { OrchestrationEmbedder } from './graph-embeddings.js';
+import { HandoffParser } from './structured-handoff.js';
+import { classifyTaskComplexity } from './cascade.js';
+import { SwarmMcpServer } from './sdk-mcp-server.js';
 /**
  * The Swarm Orchestration Engine.
  *
@@ -61,6 +84,137 @@ export class SwarmEngine {
     livingSpec = null;
     agentRunner;
     learningEngine;
+    executionGraph = null;
+    graphAnalyzer = null;
+    graphLearner = null;
+    // Lazy-initialized ML modules (only constructed on first access)
+    _reviewFeedback;
+    _causalEngine;
+    _gnnPredictor;
+    _adversarialEvolver;
+    _metaSelector;
+    _predictiveDropout;
+    _gnnWeights;
+    _patternSynthesizer;
+    _trajectoryPredictor;
+    _metaAdversarial;
+    _ruleEvolver;
+    _taskDiscovery;
+    _orchestrationEmbedder;
+    swarmMcpServer = null;
+    decisions = new Map();
+    get reviewFeedback() {
+        if (this._reviewFeedback === undefined) {
+            this._reviewFeedback = this.executionGraph
+                ? this.tryInit(() => new ReviewFeedbackRecorder(this.executionGraph), 'ReviewFeedbackRecorder')
+                : null;
+        }
+        return this._reviewFeedback;
+    }
+    get causalEngine() {
+        if (this._causalEngine === undefined) {
+            this._causalEngine = this.executionGraph
+                ? this.tryInit(() => new CausalGraphEngine(this.executionGraph), 'CausalGraphEngine')
+                : null;
+        }
+        return this._causalEngine;
+    }
+    get gnnPredictor() {
+        if (this._gnnPredictor === undefined) {
+            this._gnnPredictor = this.executionGraph
+                ? this.tryInit(() => new FailurePropagationPredictor(this.executionGraph), 'FailurePropagationPredictor')
+                : null;
+        }
+        return this._gnnPredictor;
+    }
+    get adversarialEvolver() {
+        if (this._adversarialEvolver === undefined) {
+            this._adversarialEvolver = this.executionGraph
+                ? this.tryInit(() => new AdversarialEvolver(this.executionGraph), 'AdversarialEvolver')
+                : null;
+        }
+        return this._adversarialEvolver;
+    }
+    get metaSelector() {
+        if (this._metaSelector === undefined) {
+            this._metaSelector = this.executionGraph
+                ? this.tryInit(() => new MetaPatternSelector(this.executionGraph), 'MetaPatternSelector')
+                : null;
+        }
+        return this._metaSelector;
+    }
+    get predictiveDropout() {
+        if (this._predictiveDropout === undefined) {
+            this._predictiveDropout = this.executionGraph
+                ? this.tryInit(() => new PredictiveDropout(this.executionGraph), 'PredictiveDropout')
+                : null;
+        }
+        return this._predictiveDropout;
+    }
+    get gnnWeights() {
+        if (this._gnnWeights === undefined) {
+            if (this.gnnPredictor) {
+                try {
+                    this._gnnWeights = this.gnnPredictor.initWeights();
+                }
+                catch {
+                    this._gnnWeights = null;
+                }
+            }
+            else {
+                this._gnnWeights = null;
+            }
+        }
+        return this._gnnWeights;
+    }
+    get patternSynthesizer() {
+        if (this._patternSynthesizer === undefined) {
+            this._patternSynthesizer = this.executionGraph
+                ? this.tryInit(() => new PatternSynthesizer(this.executionGraph), 'PatternSynthesizer')
+                : null;
+        }
+        return this._patternSynthesizer;
+    }
+    get trajectoryPredictor() {
+        if (this._trajectoryPredictor === undefined) {
+            this._trajectoryPredictor = this.executionGraph
+                ? this.tryInit(() => new TrajectoryPredictor(this.executionGraph), 'TrajectoryPredictor')
+                : null;
+        }
+        return this._trajectoryPredictor;
+    }
+    get metaAdversarial() {
+        if (this._metaAdversarial === undefined) {
+            this._metaAdversarial = this.executionGraph
+                ? this.tryInit(() => new MetaAdversarialTester(this.executionGraph), 'MetaAdversarialTester')
+                : null;
+        }
+        return this._metaAdversarial;
+    }
+    get ruleEvolver() {
+        if (this._ruleEvolver === undefined) {
+            this._ruleEvolver = this.executionGraph
+                ? this.tryInit(() => new RuleEvolver(this.executionGraph), 'RuleEvolver')
+                : null;
+        }
+        return this._ruleEvolver;
+    }
+    get taskDiscovery() {
+        if (this._taskDiscovery === undefined) {
+            this._taskDiscovery = this.executionGraph
+                ? this.tryInit(() => new TaskDiscovery(this.executionGraph), 'TaskDiscovery')
+                : null;
+        }
+        return this._taskDiscovery;
+    }
+    get orchestrationEmbedder() {
+        if (this._orchestrationEmbedder === undefined) {
+            this._orchestrationEmbedder = this.executionGraph
+                ? this.tryInit(() => new OrchestrationEmbedder(this.executionGraph), 'OrchestrationEmbedder')
+                : null;
+        }
+        return this._orchestrationEmbedder;
+    }
     constructor(options) {
         this.options = options;
         this.registry = options.registry;
@@ -92,6 +246,51 @@ export class SwarmEngine {
         this.modelRouter = this.tryInit(() => new ModelRouter(), 'ModelRouter');
         this.autonomyTracker = this.tryInit(() => new AutonomyTracker(), 'AutonomyTracker');
         this.compounder = this.tryInit(() => new KnowledgeCompounder(), 'KnowledgeCompounder');
+        this.executionGraph = this.tryInit(() => new ExecutionGraph(), 'ExecutionGraph');
+        this.executionGraph?.attachToEventBus(this.bus);
+        // Create SwarmMcpServer for SDK tool injection
+        try {
+            this.swarmMcpServer = new SwarmMcpServer({
+                phaseOutputs: this.phaseOutputs,
+                graph: this.executionGraph,
+                decisions: this.decisions,
+            });
+        }
+        catch {
+            this.swarmMcpServer = null;
+        }
+        // Create graph analysis deps (reused by AgentRunner + LearningEngine)
+        this.graphLearner = this.executionGraph
+            ? this.tryInit(() => new GraphLearner(this.executionGraph), 'GraphLearner')
+            : null;
+        this.graphAnalyzer = this.executionGraph
+            ? this.tryInit(() => new GraphAnalyzer(this.executionGraph), 'GraphAnalyzer')
+            : null;
+        // ML modules (reviewFeedback, causalEngine, gnnPredictor, adversarialEvolver,
+        // metaSelector, predictiveDropout, gnnWeights, patternSynthesizer, trajectoryPredictor,
+        // metaAdversarial, ruleEvolver, taskDiscovery, orchestrationEmbedder) are lazy-initialized
+        // via property getters — they are only constructed on first access.
+        // Prune stale graph data on init (Feature 6: graph decay)
+        if (this.executionGraph) {
+            try {
+                this.executionGraph.pruneOlderThan(90);
+            }
+            catch {
+                /* silent */
+            }
+        }
+        // Rule evolution proposal on startup (skip in mock mode and when no historical data)
+        if (this.ruleEvolver && !this.options.mock) {
+            try {
+                const proposals = this.ruleEvolver.evolveRules(50);
+                if (proposals.length > 0) {
+                    this.log.info(`Rule evolver proposes ${proposals.length} rule updates (top: ${proposals[0].rule.name}, +${Math.round(proposals[0].backtestedImprovement * 100)}%)`);
+                }
+            }
+            catch (e) {
+                this.log.debug(`Rule evolution failed: ${e}`);
+            }
+        }
         if (options.worktreeEnabled) {
             try {
                 this.worktreeManager = new WorktreeManager(options.cwd);
@@ -107,6 +306,9 @@ export class SwarmEngine {
             logger: options.logger,
             compaction: this.compaction,
             worktreeManager: this.worktreeManager,
+            contextRouter: this.executionGraph ? new GraphContextRouter(this.executionGraph) : undefined,
+            graphLearner: this.graphLearner,
+            graphAnalyzer: this.graphAnalyzer,
         });
         this.learningEngine = new LearningEngine({
             traceStore: this.traceStore,
@@ -114,6 +316,10 @@ export class SwarmEngine {
             modelRouter: this.modelRouter,
             autonomyTracker: this.autonomyTracker,
             compounder: this.compounder,
+            graphLearner: this.graphLearner,
+            metaSelector: this.metaSelector,
+            predictiveDropout: this.predictiveDropout,
+            orchestrationEmbedder: this.orchestrationEmbedder,
             log: options.logger,
         });
         if (options.pluginLoader) {
@@ -124,10 +330,35 @@ export class SwarmEngine {
     /**
      * Execute an orchestration from config.
      */
-    async execute(config) {
+    async execute(config, executeOptions) {
         // Re-use existing instance if present (e.g., when resuming from checkpoint)
         const orchestration = this.orchestrations.get(config.id) ?? this.createInstance(config);
         this.orchestrations.set(config.id, orchestration);
+        // Dry run mode: execute only the first phase in 'plan' mode, then return
+        if (executeOptions?.dryRun) {
+            this.log.info('Dry run mode: running first phase in plan mode');
+            const firstPhase = orchestration.phases[0];
+            if (firstPhase) {
+                this.executor.setPermissionMode('plan');
+                try {
+                    this.phaseOutputs.clear();
+                    orchestration.status = 'running';
+                    orchestration.startedAt = new Date();
+                    const outputs = await this.executePhase(orchestration, firstPhase);
+                    this.phaseOutputs.set(firstPhase.config.name, outputs);
+                    orchestration.status = 'completed';
+                }
+                catch (error) {
+                    orchestration.status = 'failed';
+                    this.log.error('Dry run failed', { error: error instanceof Error ? error.message : String(error) });
+                }
+                finally {
+                    this.executor.setPermissionMode(this.options.permissionMode ?? 'default');
+                    orchestration.completedAt = new Date();
+                }
+                return orchestration;
+            }
+        }
         this.log.info(`Starting orchestration: ${config.name}`, {
             pattern: config.pattern,
             phases: config.phases.length,
@@ -138,9 +369,45 @@ export class SwarmEngine {
             pattern: config.pattern,
             phaseCount: config.phases.length,
         }, 'engine');
+        // Single-agent fast path for simple tasks
+        if (config.phases?.length === 1 && config.phases[0].agents?.length === 1) {
+            try {
+                const complexity = classifyTaskComplexity(config.description || '');
+                if (complexity === 'simple') {
+                    this.log.info('Simple task detected — using single-agent fast path');
+                    this.bus.emit('system:warning', { type: 'single-agent-bypass', task: config.description }, 'engine');
+                    try {
+                        const phase = config.phases[0];
+                        const agent = phase.agents[0];
+                        const runContext = {
+                            phaseOutputs: new Map(),
+                            intraPhaseOutputs: new Map(),
+                            livingSpec: null,
+                            sharedContextFiles: [],
+                        };
+                        const instance = await this.agentRunner.executeAgentWithRetry(agent, orchestration.phases[0], orchestration, 0, runContext);
+                        orchestration.status = instance.result?.output ? 'completed' : 'failed';
+                        orchestration.startedAt = new Date();
+                        orchestration.completedAt = new Date();
+                        orchestration.phases[0].status = orchestration.status;
+                        if (instance.result)
+                            orchestration.phases[0].agents = [instance];
+                        orchestration.usage = instance.usage;
+                        return orchestration;
+                    }
+                    catch (e) {
+                        this.log.debug(`Single-agent bypass failed, falling through to normal execution: ${e}`);
+                        // Fall through to normal execution
+                    }
+                }
+            }
+            catch {
+                /* classification failed — fall through */
+            }
+        }
         orchestration.status = 'running';
         orchestration.startedAt = new Date();
-        this.phaseOutputs = new Map();
+        this.phaseOutputs.clear();
         // TODO: Checkpoint doesn't store phase outputs — resumed phases lose inter-phase context
         this.reflections = [];
         this.sharedContextFiles = [];
@@ -158,6 +425,20 @@ export class SwarmEngine {
                     completed.add(phase.config.name);
                 }
             }
+            // GNN pre-execution risk prediction (Feature 2: GNN Failure Propagation)
+            if (this.gnnPredictor && this.gnnWeights) {
+                try {
+                    const risks = this.gnnPredictor.predict(orchestration.config.id, this.gnnWeights);
+                    const highRisk = risks.filter((r) => r.riskScore > 0.7);
+                    if (highRisk.length > 0) {
+                        this.log.warn(`GNN predicts high failure risk for ${highRisk.length} nodes`);
+                        this.bus.emit('system:warning', { type: 'gnn-risk', risks: highRisk }, 'engine');
+                    }
+                }
+                catch (e) {
+                    this.log.debug(`GNN prediction failed: ${e}`);
+                }
+            }
             while (completed.size < orchestration.phases.length) {
                 // Check if abort was requested
                 if (this.abortController.signal.aborted) {
@@ -226,11 +507,84 @@ export class SwarmEngine {
                     }
                     if (phase.status === 'completed') {
                         completed.add(phase.config.name);
+                        // Confidence-gated phase transition (Feature 3)
+                        if (this.graphAnalyzer) {
+                            try {
+                                const reflection = this.reflectionEngine.reflect(phase);
+                                const patternStats = this.graphLearner?.getPatternStats(orchestration.config.pattern)?.[0];
+                                const gateOutputs = this.phaseOutputs.get(phase.config.name) || [];
+                                const gate = this.graphAnalyzer.evaluatePhaseConfidence({
+                                    kind: phase.config.kind ?? 'implement',
+                                    agentCount: phase.agents.length,
+                                    outputs: gateOutputs,
+                                    usage: phase.usage,
+                                }, { confidence: reflection.confidence }, patternStats
+                                    ? { successRate: patternStats.successRate, avgDurationMs: patternStats.avgDurationMs }
+                                    : undefined);
+                                if (gate.result === 'halt') {
+                                    this.log.warn(`Phase gate HALT: ${gate.reason}`);
+                                    orchestration.status = 'failed';
+                                }
+                                if (gate.result === 'warn') {
+                                    this.log.warn(`Phase gate WARNING: ${gate.reason}`);
+                                    this.bus.emit('system:warning', {
+                                        type: 'gate-warning',
+                                        orchestrationId: orchestration.config.id,
+                                        phase: phase.config.name,
+                                        reason: gate.reason,
+                                    }, 'engine');
+                                }
+                            }
+                            catch {
+                                /* Graph gate evaluation failed — continue */
+                            }
+                        }
+                        // Trajectory prediction after each completed phase
+                        if (this.trajectoryPredictor) {
+                            try {
+                                const features = this.trajectoryPredictor.extractFeatures(orchestration, phase);
+                                const pred = this.trajectoryPredictor.predict(features);
+                                if (pred.successProbability < 0.3 && pred.confidence !== 'low') {
+                                    this.log.warn(`Trajectory predictor: ${(pred.successProbability * 100).toFixed(0)}% success probability (${pred.trajectory})`);
+                                    this.bus.emit('system:warning', { type: 'trajectory-risk', ...pred }, 'engine');
+                                }
+                            }
+                            catch (e) {
+                                this.log.debug(`Trajectory prediction failed: ${e}`);
+                            }
+                        }
                     }
                     else if (phase.status === 'failed') {
                         orchestration.status = 'failed';
                     }
                 }
+                // Trajectory forecast over remaining phases
+                if (this.trajectoryPredictor) {
+                    try {
+                        const forecastCompleted = orchestration.phases
+                            .filter((p) => p.status === 'completed')
+                            .map((p) => ({
+                            name: p.config.name,
+                            status: p.status,
+                            tokens: p.usage?.totalTokens || 0,
+                            durationMs: p.usage?.durationMs || 0,
+                            confidence: 'medium',
+                        }));
+                        const forecastRemaining = orchestration.phases
+                            .filter((p) => p.status === 'pending')
+                            .map((p) => p.config.name);
+                        if (forecastRemaining.length > 0) {
+                            const forecast = this.trajectoryPredictor.predictTrajectory(orchestration.config.id, forecastCompleted, forecastRemaining, orchestration.config.pattern);
+                            if (forecast.overallSuccessProb < 0.3) {
+                                this.log.warn(`Trajectory forecast: ${Math.round(forecast.overallSuccessProb * 100)}% success probability`);
+                                this.bus.emit('system:warning', { type: 'trajectory-forecast', forecast }, 'engine');
+                            }
+                        }
+                    }
+                    catch (e) {
+                        this.log.debug(`Trajectory forecast failed: ${e}`);
+                    }
+                }
                 if (orchestration.status === 'failed')
                     break;
                 // Check cost budget after each batch of phases
@@ -264,6 +618,50 @@ export class SwarmEngine {
                 error: error instanceof Error ? error.message : String(error),
             });
         }
+        // Post-failure causal analysis (Feature 1: Causal Inference)
+        // Note: suggestIntervention scans all historical orchestrations — skip when graph is large
+        if (orchestration.status === 'failed' && this.causalEngine && this.executionGraph) {
+            try {
+                const orchCount = this.executionGraph.getNodesByType('orchestration').length;
+                if (orchCount <= 200) {
+                    const suggestions = this.causalEngine.suggestIntervention(orchestration.config.id);
+                    if (suggestions.length > 0) {
+                        this.log.info(`Causal analysis suggests: ${suggestions[0].reasoning}`);
+                        this.bus.emit('system:warning', { type: 'causal-suggestion', suggestions }, 'engine');
+                    }
+                }
+            }
+            catch (e) {
+                this.log.debug(`Causal suggestion failed: ${e}`);
+            }
+        }
+        // Self-audit on failure: red-team the engine's own ML subsystems
+        // Skipped in mock mode and when insufficient historical data to avoid test overhead
+        if (orchestration.status === 'failed' && this.metaAdversarial && !this.options.mock) {
+            try {
+                const orchCount = this.executionGraph?.getNodesByType('orchestration').length ?? 0;
+                if (orchCount >= 5) {
+                    const report = this.metaAdversarial.runFullAudit({
+                        patternSelector: this.metaSelector ?? undefined,
+                        dropout: this.predictiveDropout ?? undefined,
+                        causal: this.causalEngine
+                            ? {
+                                estimateCausalEffect: (t, tv, cv) => 
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                this.causalEngine.estimateCausalEffect(t, tv, cv),
+                            }
+                            : undefined,
+                    });
+                    if (report.overallRisk !== 'low') {
+                        this.log.warn(`Self-audit found ${report.vulnerabilities.length} ML vulnerabilities (risk: ${report.overallRisk})`);
+                        this.bus.emit('system:warning', { type: 'self-audit', overallRisk: report.overallRisk, recommendations: report.recommendations }, 'engine');
+                    }
+                }
+            }
+            catch (e) {
+                this.log.debug(`Meta-adversarial audit failed: ${e}`);
+            }
+        }
         orchestration.completedAt = new Date();
         continuousVerifier.stop();
         // Clean up shared context files
@@ -276,6 +674,15 @@ export class SwarmEngine {
         this.sharedContextFiles = [];
         // Record learning outcomes (traces, heuristics, model routing, autonomy)
         await this.learningEngine.recordOutcome(orchestration, config, this.reflections);
+        // Train trajectory predictor on final outcome
+        if (this.trajectoryPredictor) {
+            try {
+                this.trajectoryPredictor.recordOutcome(orchestration, orchestration.status === 'completed');
+            }
+            catch (e) {
+                this.log.debug(`Trajectory training failed: ${e}`);
+            }
+        }
         // Compute total usage
         orchestration.usage = orchestration.phases.reduce((total, phase) => mergeUsageStats(total, phase.usage), emptyUsageStats());
         this.bus.emit(orchestration.status === 'completed' ? 'orchestration:complete' : 'orchestration:failed', {
@@ -382,6 +789,56 @@ export class SwarmEngine {
         // Inject learned heuristics and past solutions into the plan
         this.learningEngine.injectHeuristics(rewrittenPlan);
         this.learningEngine.injectSolutions(rewrittenPlan);
+        // Meta-pattern recommendation (Feature 4: Meta-Pattern Selector)
+        if (this.metaSelector) {
+            try {
+                const recommendation = this.metaSelector.selectPattern(task);
+                if (recommendation.confidence > 0.6) {
+                    this.log.info(`Meta-selector recommends: ${recommendation.pattern} (${Math.round(recommendation.confidence * 100)}% confidence)`);
+                }
+            }
+            catch (e) {
+                this.log.debug(`Meta-pattern selection failed: ${e}`);
+            }
+        }
+        // Task discovery: log discovered backlog items from historical failure patterns (skip in mock mode)
+        if (this.taskDiscovery && !this.options.mock) {
+            try {
+                const backlog = this.taskDiscovery.generateBacklog(3);
+                if (backlog.length > 0) {
+                    this.log.info(`Task discovery: ${backlog.length} actionable items found (top: ${backlog[0]?.title})`);
+                }
+            }
+            catch (e) {
+                this.log.debug(`Task discovery failed: ${e}`);
+            }
+        }
+        // Pattern synthesis: log insights from topology analysis (skip in mock mode)
+        if (this.patternSynthesizer && !this.options.mock) {
+            try {
+                const insights = this.patternSynthesizer.analyzeTopologyDiffs(3);
+                if (insights.length > 0) {
+                    const top = insights[0];
+                    this.log.info(`Pattern synthesis top insight: "${top.feature}" (correlation: ${top.successCorrelation.toFixed(2)}, n=${top.sampleSize})`);
+                }
+            }
+            catch (e) {
+                this.log.debug(`Pattern synthesis failed: ${e}`);
+            }
+        }
+        // Pattern synthesis: suggest novel pattern from historical success topology
+        if (this.patternSynthesizer && !this.options.mock) {
+            try {
+                const synthesized = this.patternSynthesizer.synthesizePattern(task);
+                if (synthesized && synthesized.confidence > 0.5) {
+                    this.log.info(`Pattern synthesis suggests: ${synthesized.name} (${Math.round(synthesized.confidence * 100)}% confidence)`);
+                    this.bus.emit('system:warning', { type: 'pattern-synthesis', pattern: synthesized }, 'engine');
+                }
+            }
+            catch (e) {
+                this.log.debug(`Pattern synthesis suggestion failed: ${e}`);
+            }
+        }
         // Search over candidate plans to find the best one
         const searcher = new PlanSearcher(this.costModel, this.traceStore ?? undefined);
         const candidates = searcher.search(rewrittenPlan, {
@@ -400,6 +857,24 @@ export class SwarmEngine {
                 quality: c.cost.qualityScore,
             }));
         }
+        // Emit plan preview event so listeners can inspect before execution
+        try {
+            this.bus.emit('system:warning', {
+                type: 'plan-preview',
+                pattern: patternName,
+                phases: bestPlan.phases.map((p) => ({
+                    name: p.name,
+                    kind: p.kind,
+                    agentCount: p.agents?.length || 0,
+                    agents: p.agents?.map((a) => ({ type: a.type, model: a.model })) || [],
+                })),
+                estimatedCost: bestPlan.estimates,
+                task: task.slice(0, 200),
+            }, 'engine');
+        }
+        catch {
+            /* plan preview emit failed — non-critical */
+        }
         return bestPlan;
     }
     /**
@@ -417,9 +892,89 @@ export class SwarmEngine {
                 this.bus.emit('system:warning', { type: 'agent-dropout', ...dropout }, 'adaptive');
             }
         }
+        // Predictive dropout from ML model (Feature 5: Predictive Dropout)
+        if (this.predictiveDropout && phase.config.agents.length > 1) {
+            try {
+                const recommendations = this.predictiveDropout.predictRedundant(phase.config.agents.map((a) => ({ id: a.name || a.type, agentType: a.type })), phase.config.kind ?? 'implement', 0, orchestration.config.pattern || '');
+                const toDrop = recommendations.filter((r) => r.shouldDropOut);
+                if (toDrop.length > 0) {
+                    this.log.info(`Predictive dropout: skipping ${toDrop.map((d) => d.agentType).join(', ')}`);
+                    phase.config.agents = phase.config.agents.filter((a) => !toDrop.some((d) => d.agentType === a.type));
+                }
+            }
+            catch (e) {
+                this.log.debug(`Predictive dropout failed: ${e}`);
+            }
+        }
+        // Feature 5: Diff-based review context — inject git diff before review phases
+        if (phase.config.kind === 'review' && !this.options.mock) {
+            try {
+                const cwd = this.options.cwd || process.cwd();
+                const { stdout: diff } = await execFileAsync('git', ['diff', '--stat', 'HEAD'], {
+                    cwd,
+                    timeout: 10000,
+                    encoding: 'utf-8',
+                });
+                const trimmedDiff = diff.slice(0, 3000);
+                if (trimmedDiff.trim()) {
+                    const { stdout: diffDetail } = await execFileAsync('git', ['diff', 'HEAD'], {
+                        cwd,
+                        timeout: 10000,
+                        encoding: 'utf-8',
+                    });
+                    const existing = this.phaseOutputs.get(phase.config.name) || [];
+                    existing.unshift(`## Git Diff Summary\n\`\`\`\n${trimmedDiff}\n\`\`\`\n\n## Detailed Changes\n\`\`\`diff\n${diffDetail.slice(0, 5000)}\n\`\`\``);
+                    this.phaseOutputs.set(phase.config.name, existing);
+                }
+            }
+            catch (e) {
+                this.log.debug(`Diff context failed: ${e}`);
+            }
+        }
+        // Feature 6: Pre-review lint wiring — run lint/typecheck before review phases
+        if (phase.config.kind === 'review' && this.verifier && !this.options.mock) {
+            try {
+                const lintResults = await this.verifier.verify();
+                const failures = lintResults.filter((r) => !r.passed);
+                if (failures.length > 0) {
+                    const lintOutput = failures.map((f) => `${f.step}: ${f.output?.slice(0, 500)}`).join('\n');
+                    const existing = this.phaseOutputs.get(phase.config.name) || [];
+                    existing.unshift(`## Pre-Review Lint/Typecheck Results\n${lintOutput}`);
+                    this.phaseOutputs.set(phase.config.name, existing);
+                }
+            }
+            catch (e) {
+                this.log.debug(`Pre-review checks failed: ${e}`);
+            }
+        }
         const maxRetries = phase.config.maxRetries ?? 2;
+        // Smart phase output routing: filter prior outputs by relevance instead of passing everything
+        let filteredOutputs = this.phaseOutputs;
+        if (phase.config.kind === 'review') {
+            // Review phase only needs implement/integrate/test outputs, not research
+            const reviewFiltered = new Map();
+            for (const [phaseName, outputs] of this.phaseOutputs) {
+                if (phaseName.includes('implement') || phaseName.includes('integrate') || phaseName.includes('test')) {
+                    reviewFiltered.set(phaseName, outputs);
+                }
+            }
+            // Fall back to all outputs if nothing matched
+            if (reviewFiltered.size > 0)
+                filteredOutputs = reviewFiltered;
+        }
+        if (phase.config.kind === 'test') {
+            // Test phase only needs implement outputs
+            const testFiltered = new Map();
+            for (const [phaseName, outputs] of this.phaseOutputs) {
+                if (phaseName.includes('implement')) {
+                    testFiltered.set(phaseName, outputs);
+                }
+            }
+            if (testFiltered.size > 0)
+                filteredOutputs = testFiltered;
+        }
         const runContext = {
-            phaseOutputs: this.phaseOutputs,
+            phaseOutputs: filteredOutputs,
             livingSpec: this.livingSpec,
             sharedContextFiles: this.sharedContextFiles,
             cwd: this.options.cwd,
@@ -467,9 +1022,16 @@ export class SwarmEngine {
                 }
             }
             else {
-                // Run agents sequentially (with retry)
+                // Run agents sequentially (with retry) — accumulate intra-phase outputs for live re-routing (Feature 1)
+                const intraPhaseOutputs = new Map();
                 for (const assignment of phase.config.agents) {
-                    await this.agentRunner.executeAgentWithRetry(assignment, phase, orchestration, maxRetries, runContext);
+                    const agentInstance = await this.agentRunner.executeAgentWithRetry(assignment, phase, orchestration, maxRetries, { ...runContext, intraPhaseOutputs });
+                    // After agent completes, add its output to intra-phase buffer for next sequential agent
+                    if (agentInstance?.result?.output) {
+                        const existing = intraPhaseOutputs.get(phase.config.name) || [];
+                        existing.push(agentInstance.result.output);
+                        intraPhaseOutputs.set(phase.config.name, existing);
+                    }
                     // Check phase token budget after each agent
                     if (phase.config.tokenBudget) {
                         const phaseTokens = phase.agents.reduce((sum, a) => sum + a.usage.totalTokens, 0);
@@ -490,8 +1052,23 @@ export class SwarmEngine {
         }
         phase.completedAt = new Date();
         phase.usage = phase.agents.reduce((total, agent) => mergeUsageStats(total, agent.usage), emptyUsageStats());
+        // Record review feedback into the knowledge graph (Feature 7)
+        if (phase.config.kind === 'review' && this.reviewFeedback) {
+            for (const agent of phase.agents) {
+                if (agent.result?.output) {
+                    try {
+                        this.reviewFeedback.recordFindings(orchestration.config.id, phase.config.name, agent.result.output, agent.config.name);
+                        const findings = parseReviewOutput(agent.result.output, agent.config.name);
+                        this.reviewFeedback.adjustContextWeights(orchestration.config.id, findings);
+                    }
+                    catch (e) {
+                        this.log.debug(`Review feedback recording failed: ${e}`);
+                    }
+                }
+            }
+        }
         // Run verification after implementation phases
-        if (phase.config.kind === 'implement' || phase.config.kind === 'integrate') {
+        if ((phase.config.kind === 'implement' || phase.config.kind === 'integrate') && !this.options.mock) {
             const results = await this.verifier.verify();
             const summary = Verifier.summarize(results);
             this.log.info(`Verification: ${summary}`, { phase: phase.config.name });
@@ -520,10 +1097,18 @@ export class SwarmEngine {
             agents: phase.agents.length,
             usage: phase.usage,
         });
-        // Collect agent outputs for inter-phase context
+        // Collect agent outputs for inter-phase context (structured handoff)
         const outputs = phase.agents
             .filter((a) => a.result?.output)
-            .map((a) => `[${a.config.name}]: ${a.result.output.slice(0, 2000)}`);
+            .map((a) => {
+            try {
+                const handoff = HandoffParser.parseAgentOutput(a.result.output);
+                return HandoffParser.serializeForNextPhase([{ agentName: a.config.name, handoff }], 4000);
+            }
+            catch {
+                return `[${a.config.name}]: ${a.result.output.slice(0, 2000)}`;
+            }
+        });
         // Update living spec with phase outputs
         if (this.livingSpec) {
             this.livingSpec = updateSpecFromPhase(this.livingSpec, phase.config.name, outputs);
@@ -635,6 +1220,10 @@ export class SwarmEngine {
         }
         catch { }
         this.learningEngine.close();
+        try {
+            this.executionGraph?.close();
+        }
+        catch { }
         closeDatabase();
         this.removeSignalHandlers();
     }
@@ -660,6 +1249,9 @@ export class SwarmEngine {
     get patternRegistry() {
         return this.patterns;
     }
+    get graph() {
+        return this.executionGraph;
+    }
     // ─── Helpers ───────────────────────────────────────────────────
     tryInit(factory, name) {
         try {