swarm-engine 1.38.0 → 1.41.0

package/dist/runtime/engine.js

@@ -23,6 +23,9 @@ 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';
@@ -43,6 +46,9 @@ 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.
  *
@@ -81,19 +87,134 @@ export class SwarmEngine {
     executionGraph = null;
     graphAnalyzer = null;
     graphLearner = null;
-    reviewFeedback = null;
-    causalEngine = null;
-    gnnPredictor = null;
-    adversarialEvolver = null;
-    metaSelector = null;
-    predictiveDropout = null;
-    gnnWeights = null;
-    patternSynthesizer = null;
-    trajectoryPredictor = null;
-    metaAdversarial = null;
-    ruleEvolver = null;
-    taskDiscovery = null;
-    orchestrationEmbedder = 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;
@@ -127,46 +248,36 @@ export class SwarmEngine {
         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;
-        this.reviewFeedback = this.executionGraph ? this.tryInit(() => new ReviewFeedbackRecorder(this.executionGraph), 'ReviewFeedbackRecorder') : null;
-        // Cutting-edge ML features
-        this.causalEngine = this.executionGraph
-            ? this.tryInit(() => new CausalGraphEngine(this.executionGraph), 'CausalGraphEngine')
-            : null;
-        this.gnnPredictor = this.executionGraph
-            ? this.tryInit(() => new FailurePropagationPredictor(this.executionGraph), 'FailurePropagationPredictor')
-            : null;
-        this.adversarialEvolver = this.executionGraph
-            ? this.tryInit(() => new AdversarialEvolver(this.executionGraph), 'AdversarialEvolver')
+        this.graphLearner = this.executionGraph
+            ? this.tryInit(() => new GraphLearner(this.executionGraph), 'GraphLearner')
             : null;
-        this.metaSelector = this.executionGraph
-            ? this.tryInit(() => new MetaPatternSelector(this.executionGraph), 'MetaPatternSelector')
+        this.graphAnalyzer = this.executionGraph
+            ? this.tryInit(() => new GraphAnalyzer(this.executionGraph), 'GraphAnalyzer')
             : null;
-        this.predictiveDropout = this.executionGraph
-            ? this.tryInit(() => new PredictiveDropout(this.executionGraph), 'PredictiveDropout')
-            : null;
-        // Initialize GNN weights (training happens lazily via background scheduling)
-        if (this.gnnPredictor) {
-            try {
-                this.gnnWeights = this.gnnPredictor.initWeights();
-            }
-            catch { /* silent */ }
-        }
-        // Self-aware engine features
-        this.patternSynthesizer = this.executionGraph ? this.tryInit(() => new PatternSynthesizer(this.executionGraph), 'PatternSynthesizer') : null;
-        this.trajectoryPredictor = this.executionGraph ? this.tryInit(() => new TrajectoryPredictor(this.executionGraph), 'TrajectoryPredictor') : null;
-        this.metaAdversarial = this.executionGraph ? this.tryInit(() => new MetaAdversarialTester(this.executionGraph), 'MetaAdversarialTester') : null;
-        this.ruleEvolver = this.executionGraph ? this.tryInit(() => new RuleEvolver(this.executionGraph), 'RuleEvolver') : null;
-        this.taskDiscovery = this.executionGraph ? this.tryInit(() => new TaskDiscovery(this.executionGraph), 'TaskDiscovery') : null;
-        this.orchestrationEmbedder = this.executionGraph ? this.tryInit(() => new OrchestrationEmbedder(this.executionGraph), 'OrchestrationEmbedder') : 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 */ }
+            catch {
+                /* silent */
+            }
         }
         // Rule evolution proposal on startup (skip in mock mode and when no historical data)
         if (this.ruleEvolver && !this.options.mock) {
@@ -219,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,
@@ -233,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 = [];
@@ -257,7 +429,7 @@ export class SwarmEngine {
             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);
+                    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');
@@ -341,17 +513,31 @@ export class SwarmEngine {
                                 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);
+                                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');
+                                    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 */ }
+                            catch {
+                                /* Graph gate evaluation failed — continue */
+                            }
                         }
                         // Trajectory prediction after each completed phase
                         if (this.trajectoryPredictor) {
@@ -376,9 +562,17 @@ export class SwarmEngine {
                 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);
+                            .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) {
@@ -450,11 +644,13 @@ export class SwarmEngine {
                     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,
+                        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})`);
@@ -661,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;
     }
     /**
@@ -681,20 +895,86 @@ export class SwarmEngine {
         // 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);
+                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));
+                    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,
@@ -788,7 +1068,7 @@ export class SwarmEngine {
             }
         }
         // 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 });
@@ -817,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);