swarm-engine 1.1.0 → 1.3.0

package/dist/runtime/engine.js

@@ -19,14 +19,13 @@ import { KnowledgeCompounder } from './compounder.js';
 import { ModelRouter } from './model-router.js';
 import { AutonomyTracker } from './autonomy.js';
 import { ContinuousVerifier } from './verifier.js';
-import { optimizeForCache, estimateCacheSavings } from './cache-optimizer.js';
-import { classifyTaskComplexity, selectStartingTier } from './cascade.js';
-import { createLivingSpec, updateSpecFromPhase, formatLivingSpec } from './living-spec.js';
+import { estimateCacheSavings } from './cache-optimizer.js';
+import { createLivingSpec, updateSpecFromPhase } from './living-spec.js';
 import { estimateTokens } from '../utils/tokens.js';
-import { redactSecrets } from '../utils/redact.js';
-import { join } from 'path';
-import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
-import { randomUUID } from 'crypto';
+import { unlinkSync } from 'fs';
+import { AgentRunner } from './agent-runner.js';
+import { LearningEngine } from './learning-engine.js';
+import { closeDatabase } from './database.js';
 /**
  * The Swarm Orchestration Engine.
  *
@@ -60,6 +59,8 @@ export class SwarmEngine {
     signalHandlers = [];
     sharedContextFiles = [];
     livingSpec = null;
+    agentRunner;
+    learningEngine;
     constructor(options) {
         this.options = options;
         this.registry = options.registry;
@@ -85,43 +86,36 @@ export class SwarmEngine {
         this.stats.attachToEventBus(this.bus, undefined);
         this.costModel = new CostModel(this.stats);
         this.reflectionEngine = new ReflectionEngine();
-        try {
-            this.traceStore = new TraceStore();
-        }
-        catch (e) {
-            this.log.warn('TraceStore init failed', { error: e instanceof Error ? e.message : e });
-        }
+        this.traceStore = this.tryInit(() => new TraceStore(), 'TraceStore');
         this.replanner = new AdaptiveReplanner(options.logger, this.traceStore ?? undefined);
-        try {
-            this.heuristicStore = new HeuristicStore();
-        }
-        catch (e) {
-            this.log.warn('HeuristicStore init failed', { error: e instanceof Error ? e.message : e });
-        }
-        try {
-            this.modelRouter = new ModelRouter();
-        }
-        catch (e) {
-            this.log.warn('ModelRouter init failed', { error: e instanceof Error ? e.message : e });
-        }
-        try {
-            this.autonomyTracker = new AutonomyTracker();
-        }
-        catch (e) {
-            this.log.warn('AutonomyTracker init failed', { error: e instanceof Error ? e.message : e });
-        }
-        try {
-            this.compounder = new KnowledgeCompounder();
-        }
-        catch (e) {
-            this.log.warn('KnowledgeCompounder init failed', { error: e instanceof Error ? e.message : e });
-        }
+        this.heuristicStore = this.tryInit(() => new HeuristicStore(), 'HeuristicStore');
+        this.modelRouter = this.tryInit(() => new ModelRouter(), 'ModelRouter');
+        this.autonomyTracker = this.tryInit(() => new AutonomyTracker(), 'AutonomyTracker');
+        this.compounder = this.tryInit(() => new KnowledgeCompounder(), 'KnowledgeCompounder');
         if (options.worktreeEnabled) {
             try {
                 this.worktreeManager = new WorktreeManager(options.cwd);
             }
-            catch { /* not a git repo */ }
+            catch {
+                /* not a git repo */
+            }
         }
+        this.agentRunner = new AgentRunner({
+            registry: this.registry,
+            executor: this.executor,
+            bus: this.bus,
+            logger: options.logger,
+            compaction: this.compaction,
+            worktreeManager: this.worktreeManager,
+        });
+        this.learningEngine = new LearningEngine({
+            traceStore: this.traceStore,
+            heuristicStore: this.heuristicStore,
+            modelRouter: this.modelRouter,
+            autonomyTracker: this.autonomyTracker,
+            compounder: this.compounder,
+            log: options.logger,
+        });
         if (options.pluginLoader) {
             options.pluginLoader.wireHooks(this.bus);
         }
@@ -147,16 +141,14 @@ export class SwarmEngine {
         orchestration.status = 'running';
         orchestration.startedAt = new Date();
         this.phaseOutputs = new Map();
+        // TODO: Checkpoint doesn't store phase outputs — resumed phases lose inter-phase context
         this.reflections = [];
         this.sharedContextFiles = [];
         this.abortController = new AbortController();
         this.livingSpec = createLivingSpec(config.description);
         // Start continuous verification
-        let continuousVerifier = null;
-        if (this.verifier) {
-            continuousVerifier = new ContinuousVerifier(this.verifier, this.bus);
-            continuousVerifier.start();
-        }
+        const continuousVerifier = new ContinuousVerifier(this.verifier, this.bus);
+        continuousVerifier.start();
         try {
             // Execute phases using work-queue approach (handles DAGs correctly)
             // If resuming, seed completed phases so the DAG executor skips them
@@ -173,17 +165,19 @@ export class SwarmEngine {
                     break;
                 }
                 // Find all runnable phases (dependencies met, not yet completed)
-                const runnable = orchestration.phases.filter(p => {
+                const runnable = orchestration.phases.filter((p) => {
                     if (completed.has(p.config.name))
                         return false;
                     if (p.status === 'failed')
                         return false;
+                    if (p.status === 'skipped')
+                        return false;
                     const deps = p.config.dependsOn ?? [];
-                    return deps.every(d => completed.has(d));
+                    return deps.every((d) => completed.has(d));
                 });
                 if (runnable.length === 0) {
                     // No runnable phases — either all done or deadlocked
-                    const incomplete = orchestration.phases.filter(p => !completed.has(p.config.name) && p.status !== 'failed');
+                    const incomplete = orchestration.phases.filter((p) => !completed.has(p.config.name) && p.status !== 'failed');
                     if (incomplete.length > 0) {
                         // Deadlock — blocked phases with unmet dependencies
                         for (const p of incomplete) {
@@ -191,15 +185,14 @@ export class SwarmEngine {
                         }
                         orchestration.status = 'failed';
                         this.log.error('Orchestration deadlocked: blocked phases with unmet dependencies', {
-                            blocked: incomplete.map(p => p.config.name),
+                            blocked: incomplete.map((p) => p.config.name),
                         });
                     }
                     break;
                 }
-                // Execute runnable phases (could be parallel if multiple are ready)
+                // Handle approval gates sequentially (can't prompt in parallel)
+                const approved = [];
                 for (const phase of runnable) {
-                    orchestration.currentPhase = orchestration.phases.indexOf(phase);
-                    // Check for approval gate
                     if (phase.config.requiresApproval) {
                         this.log.info(`Phase requires approval: ${phase.config.name}`);
                         this.bus.emit('orchestration:paused', {
@@ -207,10 +200,9 @@ export class SwarmEngine {
                             phase: phase.config.name,
                             agentCount: phase.config.agents.length,
                         }, 'engine');
-                        // In interactive mode, wait for approval
                         if (!this.options.nonInteractive) {
-                            const approved = await this.requestApproval(phase.config.name, phase.config.agents);
-                            if (!approved) {
+                            const ok = await this.requestApproval(phase.config.name, phase.config.agents);
+                            if (!ok) {
                                 phase.status = 'skipped';
                                 this.log.info(`Phase skipped (not approved): ${phase.config.name}`);
                                 completed.add(phase.config.name);
@@ -218,14 +210,25 @@ export class SwarmEngine {
                             }
                         }
                     }
+                    approved.push(phase);
+                }
+                // Execute approved phases in parallel
+                orchestration.currentPhase = orchestration.phases.indexOf(approved[approved.length - 1] ?? runnable[0]);
+                const results = await Promise.allSettled(approved.map(async (phase) => {
                     const outputs = await this.executePhase(orchestration, phase);
                     this.phaseOutputs.set(phase.config.name, outputs);
+                }));
+                // Process results — mark completed or failed
+                for (let i = 0; i < results.length; i++) {
+                    const phase = approved[i];
+                    if (results[i].status === 'rejected') {
+                        phase.status = 'failed';
+                    }
                     if (phase.status === 'completed') {
                         completed.add(phase.config.name);
                     }
                     else if (phase.status === 'failed') {
                         orchestration.status = 'failed';
-                        break;
                     }
                 }
                 if (orchestration.status === 'failed')
@@ -233,12 +236,13 @@ export class SwarmEngine {
                 // Check cost budget after each batch of phases
                 if (orchestration.config.costBudget) {
                     const spent = orchestration.phases
-                        .filter(p => p.status === 'completed')
+                        .filter((p) => p.status === 'completed')
                         .reduce((sum, p) => sum + p.usage.costUsd, 0);
                     if (spent >= orchestration.config.costBudget) {
                         orchestration.status = 'failed';
                         this.log.warn(`Cost budget exceeded: $${spent.toFixed(2)} >= $${orchestration.config.costBudget}`, {
-                            spent, budget: orchestration.config.costBudget,
+                            spent,
+                            budget: orchestration.config.costBudget,
                         });
                         this.bus.emit('system:warning', {
                             reason: 'budget-exceeded',
@@ -250,7 +254,7 @@ export class SwarmEngine {
                     }
                 }
             }
-            if (orchestration.status !== 'failed') {
+            if (orchestration.status !== 'failed' && orchestration.status !== 'cancelled') {
                 orchestration.status = 'completed';
             }
         }
@@ -261,7 +265,7 @@ export class SwarmEngine {
             });
         }
         orchestration.completedAt = new Date();
-        continuousVerifier?.stop();
+        continuousVerifier.stop();
         // Clean up shared context files
         for (const f of this.sharedContextFiles) {
             try {
@@ -270,91 +274,8 @@ export class SwarmEngine {
             catch { }
         }
         this.sharedContextFiles = [];
-        // Build phase data once for all consumers (avoids 4x redundant mapping)
-        const phaseData = orchestration.phases.map(p => ({
-            name: p.config.name,
-            status: p.status,
-            agentCount: p.agents.length,
-            tokens: p.usage.totalTokens,
-            durationMs: p.usage.durationMs,
-            confidence: p.agents[0]?.result?.confidence ?? 'unknown',
-        }));
-        const traceData = {
-            orchestrationId: config.id,
-            task: config.description,
-            pattern: config.pattern,
-            status: orchestration.status,
-            totalTokens: orchestration.usage.totalTokens,
-            costUsd: orchestration.usage.costUsd,
-            durationMs: orchestration.usage.durationMs,
-            phaseCount: orchestration.phases.length,
-            agentCount: orchestration.phases.reduce((n, p) => n + p.agents.length, 0),
-            phases: phaseData,
-            reflections: this.reflections.map(r => redactSecrets(r)),
-        };
-        // Store execution trace for learning
-        if (this.traceStore) {
-            try {
-                this.traceStore.store(traceData);
-            }
-            catch { /* Don't fail orchestration if trace storage fails */ }
-            // Extract heuristics from the trace for future learning
-            if (this.heuristicStore) {
-                try {
-                    this.heuristicStore.extractFromTrace(traceData);
-                }
-                catch { /* Don't fail orchestration if heuristic extraction fails */ }
-            }
-            // Auto-compound knowledge from completed orchestrations
-            if (orchestration.status === 'completed' && this.compounder) {
-                try {
-                    const doc = this.compounder.extractFromTrace({ ...traceData, status: 'completed' }, this.reflections);
-                    if (doc)
-                        this.compounder.store(doc);
-                }
-                catch { /* Don't fail orchestration if compounding fails */ }
-            }
-            // Auto-capture outcomes to memory
-            try {
-                const { traceToMemoryEntries } = await import('./traces.js');
-                const memEntries = traceToMemoryEntries(traceData);
-                // Store in memory if SwarmMemory is available
-                let memory;
-                try {
-                    const { SwarmMemory } = await import('../memory/index.js');
-                    memory = new SwarmMemory();
-                    for (const entry of memEntries) {
-                        memory.store({ type: entry.type, title: entry.title, content: entry.content });
-                    }
-                }
-                catch { /* Memory not available */ }
-                finally {
-                    try {
-                        memory?.close();
-                    }
-                    catch { }
-                }
-            }
-            catch { /* Don't fail orchestration */ }
-        }
-        // Record model outcomes for routing
-        if (this.modelRouter) {
-            for (const phase of orchestration.phases) {
-                for (const agent of phase.agents) {
-                    const model = agent.config.model;
-                    if (!model)
-                        continue;
-                    const success = agent.status === 'shutdown' || agent.status === 'idle';
-                    this.modelRouter.record(model, agent.config.name, success, success ? 1.0 : 0.0);
-                }
-            }
-        }
-        // Record autonomy outcome
-        if (this.autonomyTracker) {
-            const success = orchestration.status === 'completed';
-            const intervention = orchestration.phases.some(p => p.config.requiresApproval);
-            this.autonomyTracker.record(config.pattern, success, intervention);
-        }
+        // Record learning outcomes (traces, heuristics, model routing, autonomy)
+        await this.learningEngine.recordOutcome(orchestration, config, this.reflections);
         // 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', {
@@ -377,7 +298,10 @@ export class SwarmEngine {
     async runPattern(patternName, task, options) {
         const pattern = this.patterns.get(patternName);
         if (!pattern) {
-            throw new Error(`Unknown pattern: ${patternName}. Available: ${this.patterns.list().map(p => p.name).join(', ')}`);
+            throw new Error(`Unknown pattern: ${patternName}. Available: ${this.patterns
+                .list()
+                .map((p) => p.name)
+                .join(', ')}`);
         }
         // Inject task into all agent prompts
         const config = {
@@ -385,9 +309,9 @@ export class SwarmEngine {
             name: `${patternName}: ${task.slice(0, 50)}`,
             description: task,
             pattern: patternName,
-            phases: pattern.phases.map(phase => ({
+            phases: pattern.phases.map((phase) => ({
                 ...phase,
-                agents: phase.agents.map(a => ({
+                agents: phase.agents.map((a) => ({
                     ...a,
                     prompt: `${task}\n\n${a.prompt ?? ''}`.trim(),
                 })),
@@ -396,17 +320,7 @@ export class SwarmEngine {
         };
         // Substitute pattern parameters into agent prompts
         if (options?.params && pattern.parameters) {
-            for (const phase of config.phases) {
-                for (const agent of phase.agents) {
-                    if (agent.prompt) {
-                        for (const [key, value] of Object.entries(options.params)) {
-                            // Use string replacement instead of regex to avoid ReDoS from user-controlled keys
-                            const placeholder = '${' + key + '}';
-                            agent.prompt = agent.prompt.split(placeholder).join(String(value));
-                        }
-                    }
-                }
-            }
+            this.substituteParams(config.phases, options.params);
         }
         return this.execute(config);
     }
@@ -417,37 +331,24 @@ export class SwarmEngine {
     plan(patternName, task, options) {
         const pattern = this.patterns.get(patternName);
         if (!pattern) {
-            throw new Error(`Unknown pattern: ${patternName}. Available: ${this.patterns.list().map(p => p.name).join(', ')}`);
+            throw new Error(`Unknown pattern: ${patternName}. Available: ${this.patterns
+                .list()
+                .map((p) => p.name)
+                .join(', ')}`);
         }
         // Check for similar past traces to inform planning
-        if (this.traceStore) {
-            try {
-                const similar = this.traceStore.findSimilar(task, 3);
-                if (similar.length > 0) {
-                    let traceContext = '';
-                    const best = similar.find(t => t.status === 'completed');
-                    if (best) {
-                        traceContext = `Past successful orchestration for similar task used pattern "${best.pattern}" with ${best.agentCount} agents (${best.totalTokens} tokens, ${Math.round(best.durationMs / 1000)}s).`;
-                    }
-                    const failed = similar.find(t => t.status === 'failed');
-                    if (failed && failed.reflections.length > 0) {
-                        traceContext += ` Previous attempt failed. Lessons: ${failed.reflections[0]?.slice(0, 200)}`;
-                    }
-                    if (traceContext) {
-                        this.log.info('Found similar past traces', { context: traceContext.slice(0, 200) });
-                    }
-                }
-            }
-            catch { /* Don't fail planning if trace lookup fails */ }
+        const traceContext = this.learningEngine.findSimilarTraces(task);
+        if (traceContext) {
+            this.log.info('Found similar past traces', { context: traceContext.slice(0, 200) });
         }
         const id = generateId();
-        const phases = pattern.phases.map(phase => ({
+        const phases = pattern.phases.map((phase) => ({
             name: phase.name,
             parallel: phase.parallel,
             dependsOn: phase.dependsOn,
             requiresApproval: phase.requiresApproval,
             tokenBudget: phase.tokenBudget,
-            agents: phase.agents.map(a => {
+            agents: phase.agents.map((a) => {
                 const agentConfig = this.registry.getConfig(a.type);
                 return {
                     name: a.name,
@@ -462,14 +363,7 @@ export class SwarmEngine {
         }));
         // Substitute pattern parameters if provided
         if (options?.params && pattern.parameters) {
-            for (const phase of phases) {
-                for (const agent of phase.agents) {
-                    for (const [key, value] of Object.entries(options.params)) {
-                        const placeholder = '${' + key + '}';
-                        agent.prompt = agent.prompt.split(placeholder).join(String(value));
-                    }
-                }
-            }
+            this.substituteParams(phases, options.params);
         }
         const planResult = {
             id,
@@ -485,34 +379,9 @@ export class SwarmEngine {
         if (rewrites.length > 0) {
             this.log.info('Plan rewritten', { rewrites });
         }
-        // Retrieve relevant heuristics and inject into first phase
-        if (this.heuristicStore) {
-            try {
-                const heuristics = this.heuristicStore.retrieve(task);
-                if (heuristics.length > 0) {
-                    const context = this.heuristicStore.formatForContext(heuristics);
-                    for (const agent of rewrittenPlan.phases[0]?.agents ?? []) {
-                        agent.prompt = `${context}\n\n${agent.prompt}`;
-                    }
-                    this.log.info('Injected heuristics into plan', { count: heuristics.length });
-                }
-            }
-            catch { /* Don't fail planning if heuristic retrieval fails */ }
-        }
-        // Inject relevant past solutions from knowledge compounder (singleton)
-        if (this.compounder) {
-            try {
-                const solutions = this.compounder.findRelevant(task, 3);
-                if (solutions.length > 0) {
-                    const solutionContext = this.compounder.formatForContext(solutions);
-                    for (const agent of rewrittenPlan.phases[0]?.agents ?? []) {
-                        agent.prompt = `${solutionContext}\n\n${agent.prompt}`;
-                    }
-                    this.log.info('Injected past solutions into plan', { count: solutions.length });
-                }
-            }
-            catch { /* Don't fail planning if solution retrieval fails */ }
-        }
+        // Inject learned heuristics and past solutions into the plan
+        this.learningEngine.injectHeuristics(rewrittenPlan);
+        this.learningEngine.injectSolutions(rewrittenPlan);
         // Search over candidate plans to find the best one
         const searcher = new PlanSearcher(this.costModel, this.traceStore ?? undefined);
         const candidates = searcher.search(rewrittenPlan, {
@@ -525,7 +394,7 @@ export class SwarmEngine {
         bestPlan.estimates = this.costModel.estimate(bestPlan);
         bestPlan.rewrites = rewrites;
         if (candidates.length > 1) {
-            bestPlan._alternatives = candidates.slice(1).map(c => ({
+            bestPlan._alternatives = candidates.slice(1).map((c) => ({
                 source: c.source,
                 costUsd: c.cost.costUsd,
                 quality: c.cost.qualityScore,
@@ -544,11 +413,17 @@ export class SwarmEngine {
             const dropout = this.replanner.evaluateDropout(orchestration, phase.config);
             if (dropout) {
                 this.log.info(`Agent dropout: ${dropout.reason}`);
-                phase.config.agents = phase.config.agents.filter(a => dropout.agentsToKeep.includes(a.name));
+                phase.config.agents = phase.config.agents.filter((a) => dropout.agentsToKeep.includes(a.name));
                 this.bus.emit('system:warning', { type: 'agent-dropout', ...dropout }, 'adaptive');
             }
         }
         const maxRetries = phase.config.maxRetries ?? 2;
+        const runContext = {
+            phaseOutputs: this.phaseOutputs,
+            livingSpec: this.livingSpec,
+            sharedContextFiles: this.sharedContextFiles,
+            cwd: this.options.cwd,
+        };
         this.log.info(`Phase started: ${phase.config.name}`, {
             agents: phase.config.agents.length,
             parallel: phase.config.parallel,
@@ -562,7 +437,7 @@ export class SwarmEngine {
         try {
             if (phase.config.parallel) {
                 // Run all agents in parallel (with retry)
-                const results = await Promise.allSettled(phase.config.agents.map(assignment => this.executeAgentWithRetry(assignment, phase, orchestration, maxRetries)));
+                const results = await Promise.allSettled(phase.config.agents.map((assignment) => this.agentRunner.executeAgentWithRetry(assignment, phase, orchestration, maxRetries, runContext)));
                 // Log cache savings estimate for parallel phases
                 if (phase.config.agents.length > 1) {
                     const phaseContext = this.compaction.buildContextPrefix(this.phaseOutputs);
@@ -573,7 +448,7 @@ export class SwarmEngine {
                     }
                 }
                 // Check for failures
-                const failures = results.filter(r => r.status === 'rejected');
+                const failures = results.filter((r) => r.status === 'rejected');
                 if (failures.length > 0) {
                     const failureCount = failures.length;
                     this.log.warn(`Phase had ${failureCount} agent failures`, {
@@ -594,7 +469,7 @@ export class SwarmEngine {
             else {
                 // Run agents sequentially (with retry)
                 for (const assignment of phase.config.agents) {
-                    await this.executeAgentWithRetry(assignment, phase, orchestration, maxRetries);
+                    await this.agentRunner.executeAgentWithRetry(assignment, phase, orchestration, maxRetries, runContext);
                     // Check phase token budget after each agent
                     if (phase.config.tokenBudget) {
                         const phaseTokens = phase.agents.reduce((sum, a) => sum + a.usage.totalTokens, 0);
@@ -616,7 +491,7 @@ export class SwarmEngine {
         phase.completedAt = new Date();
         phase.usage = phase.agents.reduce((total, agent) => mergeUsageStats(total, agent.usage), emptyUsageStats());
         // Run verification after implementation phases
-        if (this.verifier && (phase.config.name.includes('implement') || phase.config.name.includes('integrate'))) {
+        if (phase.config.kind === 'implement' || phase.config.kind === 'integrate') {
             const results = await this.verifier.verify();
             const summary = Verifier.summarize(results);
             this.log.info(`Verification: ${summary}`, { phase: phase.config.name });
@@ -647,8 +522,8 @@ export class SwarmEngine {
         });
         // Collect agent outputs for inter-phase context
         const outputs = phase.agents
-            .filter(a => a.result?.output)
-            .map(a => `[${a.config.name}]: ${a.result.output.slice(0, 2000)}`);
+            .filter((a) => a.result?.output)
+            .map((a) => `[${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);
@@ -665,121 +540,6 @@ export class SwarmEngine {
         }
         return outputs;
     }
-    /**
-     * Execute a single agent within a phase.
-     */
-    async executeAgent(assignment, phase, orchestration) {
-        // Spawn from registry, passing all assignment overrides
-        const instance = this.registry.spawn(assignment.type, {
-            name: assignment.name,
-            model: assignment.model,
-            backend: assignment.backend,
-            backendModel: assignment.backendModel,
-        });
-        phase.agents.push(instance);
-        // Build task prompt with cache-friendly ordering:
-        // Shared prefix (orchestration + phase context) comes first for API cache hits,
-        // agent-specific content (definition + task) comes last.
-        const orchestrationContext = `## Orchestration: ${orchestration.config.name}\nPattern: ${orchestration.config.pattern}`;
-        const phaseContext = this.compaction.buildContextPrefix(this.phaseOutputs);
-        const agentPrompt = instance.config.prompt;
-        const baseTask = assignment.prompt || `Execute task as ${assignment.type}`;
-        const optimized = optimizeForCache(orchestrationContext, phaseContext, agentPrompt, baseTask);
-        // For parallel phases with large shared prefix, use shared context file
-        const sharedContextPath = phase.config.parallel
-            ? this.writeSharedContext(optimized.sharedPrefix)
-            : null;
-        // Cascade model selection: if no explicit model override, pick starting tier by complexity
-        if (!assignment.model) {
-            const complexity = classifyTaskComplexity(baseTask);
-            const startTier = selectStartingTier(complexity);
-            if (startTier !== instance.config.model) {
-                instance.config.model = startTier;
-            }
-        }
-        // Inject living spec into task context
-        const specPrefix = this.livingSpec ? formatLivingSpec(this.livingSpec) + '\n\n' : '';
-        const task = sharedContextPath
-            ? `Read the shared context file at ${sharedContextPath} first, then:\n\n${specPrefix}${optimized.agentSuffix}`
-            : `${specPrefix}${optimized.full}`;
-        // Transition to running
-        this.registry.updateStatus(instance.id, 'running');
-        // Create worktree if enabled and assignment requests it
-        let worktreeId;
-        if (this.worktreeManager && assignment.worktree) {
-            try {
-                const wt = this.worktreeManager.create(instance.id, assignment.name);
-                worktreeId = wt.id;
-                this.bus.emit('worktree:created', { agentId: instance.id, worktreeId: wt.id, path: wt.path }, instance.id);
-            }
-            catch (err) {
-                this.log.warn(`Failed to create worktree for ${assignment.name}: ${err}`);
-            }
-        }
-        // Execute with timeout
-        const timeoutMs = (instance.config.timeout ?? 300) * 1000; // default 5 min
-        let timer;
-        const timeoutPromise = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error(`Agent timeout after ${timeoutMs / 1000}s`)), timeoutMs);
-        });
-        try {
-            await Promise.race([
-                this.executor.execute(instance, task),
-                timeoutPromise,
-            ]);
-            clearTimeout(timer);
-            // Merge worktree if created
-            if (worktreeId && this.worktreeManager) {
-                try {
-                    this.worktreeManager.merge(worktreeId);
-                    this.bus.emit('worktree:merged', { agentId: instance.id, worktreeId }, instance.id);
-                }
-                catch (err) {
-                    this.log.warn(`Failed to merge worktree ${worktreeId}: ${err}`);
-                }
-            }
-            // Transition to idle (completed successfully)
-            this.registry.updateStatus(instance.id, 'idle');
-            // Then shutdown
-            this.registry.updateStatus(instance.id, 'shutdown');
-            return instance;
-        }
-        catch (error) {
-            clearTimeout(timer);
-            if (String(error).includes('timeout')) {
-                this.registry.updateStatus(instance.id, 'timeout');
-            }
-            else {
-                this.registry.updateStatus(instance.id, 'error');
-            }
-            instance.error = error instanceof Error ? error.message : String(error);
-            throw error;
-        }
-    }
-    async executeAgentWithRetry(assignment, phase, orchestration, maxRetries = 2) {
-        let lastError;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                return await this.executeAgent(assignment, phase, orchestration);
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // Remove the failed instance from phase agents to prevent duplicates on retry
-                const failedIndex = phase.agents.findIndex(a => a.config.name === assignment.name && (a.status === 'error' || a.status === 'timeout'));
-                if (failedIndex >= 0)
-                    phase.agents.splice(failedIndex, 1);
-                if (attempt < maxRetries) {
-                    const delayMs = Math.min(1000 * Math.pow(2, attempt) + Math.random() * 1000, 30000);
-                    this.log.warn(`Agent failed, retrying in ${Math.round(delayMs / 1000)}s (attempt ${attempt + 1}/${maxRetries})`, {
-                        agent: assignment.name,
-                        error: lastError.message,
-                    });
-                    await new Promise(resolve => setTimeout(resolve, delayMs));
-                }
-            }
-        }
-        throw lastError;
-    }
     // ─── Resume ────────────────────────────────────────────────────
     /**
      * Resume an orchestration from a checkpoint.
@@ -817,10 +577,8 @@ export class SwarmEngine {
         const { createInterface } = await import('readline');
         const rl = createInterface({ input: process.stdin, output: process.stdout });
         return new Promise((resolve) => {
-            const agentList = agents.map(a => `  ${a.name} (${a.type})`).join('\n');
-            rl.question(`\n⏸  Phase "${phaseName}" requires approval.\n` +
-                `   Agents:\n${agentList}\n` +
-                `   Proceed? [Y/n] `, (answer) => {
+            const agentList = agents.map((a) => `  ${a.name} (${a.type})`).join('\n');
+            rl.question(`\n⏸  Phase "${phaseName}" requires approval.\n` + `   Agents:\n${agentList}\n` + `   Proceed? [Y/n] `, (answer) => {
                 rl.close();
                 resolve(answer.toLowerCase() !== 'n');
             });
@@ -856,26 +614,7 @@ export class SwarmEngine {
                     // Best effort — lifecycle may not allow transition
                 }
             }
-            try {
-                this.stats.close();
-            }
-            catch { /* best effort */ }
-            try {
-                this.traceStore?.close();
-            }
-            catch { /* best effort */ }
-            try {
-                this.heuristicStore?.close();
-            }
-            catch { /* best effort */ }
-            try {
-                this.modelRouter?.close();
-            }
-            catch { }
-            try {
-                this.autonomyTracker?.close();
-            }
-            catch { }
+            this.close();
             this.bus.emit('system:warning', { message: 'Graceful shutdown complete' }, 'engine');
         };
         process.on('SIGINT', handler);
@@ -889,28 +628,14 @@ export class SwarmEngine {
         }
         this.signalHandlers = [];
     }
-    /** Close all resources (stats, traces, heuristics, model router, autonomy tracker). */
+    /** Close all resources (stats, traces, heuristics, model router, autonomy tracker, database). */
     close() {
         try {
             this.stats.close();
         }
         catch { }
-        try {
-            this.traceStore?.close();
-        }
-        catch { }
-        try {
-            this.heuristicStore?.close();
-        }
-        catch { }
-        try {
-            this.modelRouter?.close();
-        }
-        catch { }
-        try {
-            this.autonomyTracker?.close();
-        }
-        catch { }
+        this.learningEngine.close();
+        closeDatabase();
         this.removeSignalHandlers();
     }
     // ─── Queries ───────────────────────────────────────────────────
@@ -930,33 +655,43 @@ export class SwarmEngine {
      * Get active orchestrations.
      */
     getActiveOrchestrations() {
-        return [...this.orchestrations.values()].filter(o => o.status === 'running' || o.status === 'paused');
+        return [...this.orchestrations.values()].filter((o) => o.status === 'running' || o.status === 'paused');
     }
     get patternRegistry() {
         return this.patterns;
     }
-    // ─── Shared Context ────────────────────────────────────────────
+    // ─── Helpers ───────────────────────────────────────────────────
+    tryInit(factory, name) {
+        try {
+            return factory();
+        }
+        catch (e) {
+            this.log.warn(`${name} init failed`, { error: e instanceof Error ? e.message : e });
+            return null;
+        }
+    }
     /**
-     * Write shared context to a file for parallel agents to read,
-     * avoiding duplicating large context in each agent's prompt.
+     * Substitute ${key} placeholders in agent prompts.
+     * Uses string split/join instead of regex to avoid ReDoS from user-controlled keys.
      */
-    writeSharedContext(context) {
-        if (!context || context.length < 2000)
-            return null; // Not worth sharing for small contexts
-        const contextDir = join(this.options.cwd ?? process.cwd(), '.swarm');
-        if (!existsSync(contextDir))
-            mkdirSync(contextDir, { recursive: true });
-        const contextPath = join(contextDir, `shared-context-${randomUUID().slice(0, 8)}.md`);
-        writeFileSync(contextPath, redactSecrets(context), { mode: 0o600 });
-        this.sharedContextFiles.push(contextPath);
-        return contextPath;
+    substituteParams(phases, params) {
+        for (const phase of phases) {
+            for (const agent of phase.agents) {
+                if (agent.prompt) {
+                    for (const [key, value] of Object.entries(params)) {
+                        const placeholder = '${' + key + '}';
+                        agent.prompt = agent.prompt.split(placeholder).join(String(value));
+                    }
+                }
+            }
+        }
     }
     // ─── Factory ───────────────────────────────────────────────────
     createInstance(config) {
         return {
             config,
             status: 'pending',
-            phases: config.phases.map(phaseConfig => ({
+            phases: config.phases.map((phaseConfig) => ({
                 config: phaseConfig,
                 status: 'pending',
                 agents: [],