agentic-flow 1.9.0 → 1.9.2

package/{agentic-flow/dist → dist}/cli/config-wizard.js

@@ -21,6 +21,12 @@ const CONFIG_DEFINITIONS = [
         required: false,
         validation: (val) => val.startsWith('sk-or-') || 'Must start with sk-or-'
     },
+    {
+        key: 'GOOGLE_GEMINI_API_KEY',
+        value: '',
+        description: 'Google Gemini API key for Gemini models',
+        required: false
+    },
     {
         key: 'COMPLETION_MODEL',
         value: 'claude-sonnet-4-5-20250929',
@@ -30,9 +36,9 @@ const CONFIG_DEFINITIONS = [
     {
         key: 'PROVIDER',
         value: 'anthropic',
-        description: 'Default provider (anthropic, openrouter, onnx)',
+        description: 'Default provider (anthropic, openrouter, gemini, onnx)',
         required: false,
-        validation: (val) => ['anthropic', 'openrouter', 'onnx'].includes(val) || 'Must be anthropic, openrouter, or onnx'
+        validation: (val) => ['anthropic', 'openrouter', 'gemini', 'onnx'].includes(val) || 'Must be anthropic, openrouter, gemini, or onnx'
     },
     {
         key: 'AGENTS_DIR',
@@ -231,15 +237,17 @@ export class ConfigWizard {
         console.log('📊 Configuration Summary:\n');
         const hasAnthropic = this.currentConfig.has('ANTHROPIC_API_KEY');
         const hasOpenRouter = this.currentConfig.has('OPENROUTER_API_KEY');
+        const hasGemini = this.currentConfig.has('GOOGLE_GEMINI_API_KEY');
         const provider = this.currentConfig.get('PROVIDER') || 'anthropic';
         console.log('Providers configured:');
         console.log(`  ${hasAnthropic ? '✅' : '❌'} Anthropic (Claude)`);
         console.log(`  ${hasOpenRouter ? '✅' : '❌'} OpenRouter (Alternative models)`);
+        console.log(`  ${hasGemini ? '✅' : '❌'} Gemini (Google AI)`);
         console.log(`  ⚙️  ONNX (Local inference) - always available`);
         console.log('');
         console.log(`Default provider: ${provider}`);
         console.log('');
-        if (!hasAnthropic && !hasOpenRouter) {
+        if (!hasAnthropic && !hasOpenRouter && !hasGemini) {
             console.log('⚠️  Warning: No API keys configured!');
             console.log('   You can use ONNX local inference, but quality may be limited.');
             console.log('   Run with --provider onnx to use local inference.\n');
@@ -339,8 +347,9 @@ EXAMPLES:
 AVAILABLE CONFIGURATION KEYS:
   ANTHROPIC_API_KEY     - Anthropic API key (sk-ant-...)
   OPENROUTER_API_KEY    - OpenRouter API key (sk-or-v1-...)
+  GOOGLE_GEMINI_API_KEY - Google Gemini API key
   COMPLETION_MODEL      - Default model name
-  PROVIDER              - Default provider (anthropic, openrouter, onnx)
+  PROVIDER              - Default provider (anthropic, openrouter, gemini, onnx)
   AGENTS_DIR            - Custom agents directory
   PROXY_PORT            - Proxy server port (default: 3000)
   USE_OPENROUTER        - Force OpenRouter (true/false)

package/dist/cli/federation-cli.d.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * Federation Hub CLI - Manage ephemeral agent federation
+ * Supports hub server, agent lifecycle, stats, and monitoring
+ */
+export interface FederationHubConfig {
+    port?: number;
+    dbPath?: string;
+    maxAgents?: number;
+    syncInterval?: number;
+    verbose?: boolean;
+}
+export interface AgentConfig {
+    agentId?: string;
+    tenantId?: string;
+    lifetime?: number;
+    hubEndpoint?: string;
+    agentType?: string;
+}
+/**
+ * Federation Hub CLI Manager
+ */
+export declare class FederationCLI {
+    private hubProcess;
+    /**
+     * Start federation hub server
+     */
+    startHub(config?: FederationHubConfig): Promise<void>;
+    /**
+     * Spawn ephemeral agent
+     */
+    spawnAgent(config?: AgentConfig): Promise<void>;
+    /**
+     * Show hub statistics
+     */
+    stats(hubEndpoint?: string): Promise<void>;
+    /**
+     * Show federation status
+     */
+    status(): Promise<void>;
+    /**
+     * Run multi-agent collaboration test
+     */
+    testCollaboration(): Promise<void>;
+    /**
+     * Print help message
+     */
+    printHelp(): void;
+}
+/**
+ * CLI command handler
+ */
+export declare function handleFederationCommand(args: string[]): Promise<void>;

package/{agentic-flow/dist → dist}/cli-proxy.js

@@ -1058,26 +1058,33 @@ OPTIMIZATION BENEFITS:
   📊 10+ Models: Claude, GPT-4o, Gemini, DeepSeek, Llama, ONNX local
   ⚡ Zero Overhead: <5ms decision time, no API calls during optimization
 
-PROXY MODE (Claude Code CLI Integration):
-  The OpenRouter proxy allows Claude Code to use alternative models via API translation.
+TWO WAYS TO USE AGENTIC-FLOW:
 
-  Terminal 1 - Start Proxy Server:
-    npx agentic-flow proxy
-    # Or with custom port: PROXY_PORT=8080 npx agentic-flow proxy
-    # Proxy runs at http://localhost:3000 by default
+  1️⃣  DIRECT AGENT EXECUTION (agentic-flow agents)
+      Run agents directly in your terminal with full control:
 
-  Terminal 2 - Use with Claude Code:
-    export ANTHROPIC_BASE_URL="http://localhost:3000"
-    export ANTHROPIC_API_KEY="sk-ant-proxy-dummy-key"
-    export OPENROUTER_API_KEY="sk-or-v1-xxxxx"
+      npx agentic-flow --agent coder --task "Create Python script"
+      npx agentic-flow --agent researcher --task "Research AI trends"
 
-    # Now Claude Code will route through OpenRouter proxy
-    claude-code --agent coder --task "Create API"
+      This runs agentic-flow's 80+ specialized agents directly.
 
-  Proxy automatically translates Anthropic API calls to OpenRouter format.
-  Model override happens automatically: Claude requests → OpenRouter models.
+  2️⃣  CLAUDE CODE INTEGRATION (proxy for Claude Code CLI)
+      Use Claude Code CLI with OpenRouter/Gemini models via proxy:
 
-  Benefits for Claude Code users:
+      # Option A: Auto-spawn Claude Code with proxy (easiest)
+      npx agentic-flow claude-code --provider openrouter "Build API"
+
+      # Option B: Manual proxy setup (advanced)
+      Terminal 1 - Start Proxy:
+        npx agentic-flow proxy --provider openrouter
+
+      Terminal 2 - Configure Claude Code:
+        export ANTHROPIC_BASE_URL="http://localhost:3000"
+        export ANTHROPIC_API_KEY="sk-ant-proxy-dummy-key"
+        export OPENROUTER_API_KEY="sk-or-v1-xxxxx"
+        claude  # Now uses OpenRouter via proxy
+
+  Benefits of proxy mode:
   • 85-99% cost savings vs Claude Sonnet 4.5
   • Access to 100+ models (DeepSeek, Llama, Gemini, etc.)
   • Leaderboard tracking on OpenRouter

package/dist/hooks/parallel-validation.js

@@ -0,0 +1,166 @@
+/**
+ * Validation hooks to ensure agents follow parallel execution best practices
+ */
+/**
+ * Validate agent's parallel execution patterns
+ */
+export function validateParallelExecution(response, metrics) {
+    const issues = [];
+    const recommendations = [];
+    let score = 1.0;
+    // Check 1: Sequential subprocess spawning
+    if (hasSequentialSubprocessSpawning(response)) {
+        issues.push("Sequential subprocess spawning detected");
+        recommendations.push("Use Promise.all() to spawn all subprocesses concurrently:\n" +
+            "await Promise.all([exec('agent1'), exec('agent2'), exec('agent3')])");
+        score -= 0.3;
+    }
+    // Check 2: Missing ReasoningBank coordination
+    if ((response.subprocesses?.length || 0) > 1 && !usesReasoningBank(response)) {
+        issues.push("Multiple subprocesses without ReasoningBank coordination");
+        recommendations.push("Store subprocess results in ReasoningBank for proper coordination:\n" +
+            "await reasoningBank.storePattern({ sessionId: 'swarm/task-id/agent-id', task, output, reward, success })");
+        score -= 0.2;
+    }
+    // Check 3: Small batch sizes
+    if (metrics.avgBatchSize < 3) {
+        issues.push(`Small batch size detected: ${metrics.avgBatchSize} (recommended: 5+)`);
+        recommendations.push("Increase batch size to maximize parallelism. Target 5-10 concurrent operations.");
+        score -= 0.1;
+    }
+    // Check 4: No QUIC transport for large-scale operations
+    if (metrics.subprocessesSpawned > 10 && !usesQuicTransport(response)) {
+        issues.push("Large-scale operation without QUIC transport");
+        recommendations.push("Use QUIC transport for 50-70% performance improvement:\n" +
+            "npx agentic-flow --agent TYPE --task TASK --transport quic");
+        score -= 0.15;
+    }
+    // Check 5: Missing result synthesis
+    if ((response.subprocesses?.length || 0) > 1 && !synthesizesResults(response)) {
+        issues.push("Multiple subprocesses without result synthesis");
+        recommendations.push("Combine subprocess results into a unified report:\n" +
+            "const allResults = await Promise.all(subprocesses.map(retrieveResult));\n" +
+            "const report = synthesize(allResults);");
+        score -= 0.15;
+    }
+    // Check 6: No pattern storage for successful executions
+    if (score > 0.8 && !storesSuccessPattern(response)) {
+        recommendations.push("Store successful execution patterns in ReasoningBank for learning:\n" +
+            "await reasoningBank.storePattern({ sessionId, task, output, reward, success })");
+        score -= 0.1;
+    }
+    return {
+        score: Math.max(0, score),
+        issues,
+        recommendations,
+        metrics: {
+            parallelOpsCount: countParallelOps(response),
+            sequentialOpsCount: countSequentialOps(response),
+            avgBatchSize: metrics.avgBatchSize,
+            subprocessesSpawned: metrics.subprocessesSpawned,
+            reasoningBankUsage: metrics.reasoningBankUsage
+        }
+    };
+}
+// Helper functions
+function hasSequentialSubprocessSpawning(response) {
+    // Check if subprocess spawning uses await in sequence vs Promise.all
+    const code = response.code || response.output || '';
+    const hasAwaitExec = /await\s+exec/.test(code);
+    const hasPromiseAll = /Promise\.all\(/i.test(code);
+    return hasAwaitExec && !hasPromiseAll;
+}
+function usesReasoningBank(response) {
+    const code = response.code || response.output || '';
+    return /reasoningBank\.(store|retrieve|search|storePattern)/.test(code);
+}
+function usesQuicTransport(response) {
+    const code = response.code || response.output || '';
+    return /--transport\s+quic/i.test(code) || /QuicTransport/.test(code);
+}
+function synthesizesResults(response) {
+    const code = response.code || response.output || '';
+    return /synthesize|combine|merge|aggregate/i.test(code);
+}
+function storesSuccessPattern(response) {
+    const code = response.code || response.output || '';
+    return /storePattern|reasoningBank\.store/.test(code);
+}
+function countParallelOps(response) {
+    const code = response.code || response.output || '';
+    const promiseAllMatches = code.match(/Promise\.all\(/g);
+    return promiseAllMatches?.length || 0;
+}
+function countSequentialOps(response) {
+    const code = response.code || response.output || '';
+    const awaitMatches = code.match(/await\s+(?!Promise\.all)/g);
+    return awaitMatches?.length || 0;
+}
+/**
+ * Post-execution hook: Log validation results and suggestions
+ */
+export async function postExecutionValidation(response, metrics) {
+    const validation = validateParallelExecution(response, metrics);
+    console.log('\n📊 Parallel Execution Validation');
+    console.log('═'.repeat(60));
+    console.log(`Score: ${(validation.score * 100).toFixed(1)}%`);
+    console.log(`Parallel Ops: ${validation.metrics.parallelOpsCount}`);
+    console.log(`Sequential Ops: ${validation.metrics.sequentialOpsCount}`);
+    console.log(`Batch Size: ${validation.metrics.avgBatchSize}`);
+    console.log(`Subprocesses: ${validation.metrics.subprocessesSpawned}`);
+    console.log(`ReasoningBank Usage: ${validation.metrics.reasoningBankUsage}`);
+    if (validation.issues.length > 0) {
+        console.log('\n⚠️  Issues Detected:');
+        validation.issues.forEach((issue, i) => {
+            console.log(`  ${i + 1}. ${issue}`);
+        });
+    }
+    if (validation.recommendations.length > 0) {
+        console.log('\n💡 Recommendations:');
+        validation.recommendations.forEach((rec, i) => {
+            console.log(`  ${i + 1}. ${rec}`);
+        });
+    }
+    console.log('═'.repeat(60));
+    return validation;
+}
+/**
+ * Grade parallel execution quality
+ */
+export function gradeParallelExecution(score) {
+    if (score >= 0.9) {
+        return {
+            grade: 'A',
+            description: 'Excellent parallel execution',
+            color: 'green'
+        };
+    }
+    else if (score >= 0.75) {
+        return {
+            grade: 'B',
+            description: 'Good parallel execution with minor improvements needed',
+            color: 'blue'
+        };
+    }
+    else if (score >= 0.6) {
+        return {
+            grade: 'C',
+            description: 'Acceptable parallel execution with room for improvement',
+            color: 'yellow'
+        };
+    }
+    else if (score >= 0.4) {
+        return {
+            grade: 'D',
+            description: 'Poor parallel execution, needs significant improvements',
+            color: 'orange'
+        };
+    }
+    else {
+        return {
+            grade: 'F',
+            description: 'Sequential execution detected, parallelism not utilized',
+            color: 'red'
+        };
+    }
+}

package/dist/hooks/swarm-learning-optimizer.js

@@ -0,0 +1,350 @@
+/**
+ * Swarm Learning Optimizer
+ *
+ * Enhances parallel execution with adaptive learning, pattern recognition,
+ * and automated topology selection using ReasoningBank intelligence.
+ */
+export class SwarmLearningOptimizer {
+    reasoningBank;
+    NAMESPACE = 'swarm/optimization';
+    constructor(reasoningBank) {
+        this.reasoningBank = reasoningBank;
+    }
+    /**
+     * Store swarm execution metrics for learning
+     */
+    async storeExecutionPattern(taskDescription, metrics, success) {
+        const sessionId = `${this.NAMESPACE}/${metrics.topology}/${Date.now()}`;
+        await this.reasoningBank.storePattern({
+            sessionId,
+            task: taskDescription,
+            input: JSON.stringify({ taskComplexity: metrics.taskComplexity, agentCount: metrics.agentCount }),
+            output: JSON.stringify(metrics),
+            reward: this.calculateReward(metrics, success),
+            success,
+            latencyMs: metrics.totalTimeMs,
+            tokensUsed: 0, // Not tracking tokens for swarm ops
+            critique: this.generateCritique(metrics, success)
+        });
+    }
+    /**
+     * Calculate reward score for swarm execution (0-1)
+     */
+    calculateReward(metrics, success) {
+        if (!success)
+            return 0.0;
+        let reward = 0.5; // Base reward for success
+        // Reward for high success rate (+0.2)
+        if (metrics.successRate >= 90) {
+            reward += 0.2;
+        }
+        else if (metrics.successRate >= 75) {
+            reward += 0.1;
+        }
+        // Reward for speedup (+0.2)
+        if (metrics.speedup) {
+            if (metrics.speedup >= 3.0) {
+                reward += 0.2;
+            }
+            else if (metrics.speedup >= 2.0) {
+                reward += 0.15;
+            }
+            else if (metrics.speedup >= 1.5) {
+                reward += 0.1;
+            }
+        }
+        // Reward for efficiency (operations/time) (+0.1)
+        const opsPerSecond = (metrics.operations / metrics.totalTimeMs) * 1000;
+        if (opsPerSecond > 0.1) {
+            reward += 0.1;
+        }
+        return Math.min(1.0, reward);
+    }
+    /**
+     * Generate critique for learning
+     */
+    generateCritique(metrics, success) {
+        const critiques = [];
+        if (!success) {
+            critiques.push('Swarm execution failed - investigate error handling');
+        }
+        if (metrics.successRate < 80) {
+            critiques.push(`Low success rate (${metrics.successRate}%) - review agent reliability`);
+        }
+        if (metrics.speedup && metrics.speedup < 1.2) {
+            critiques.push(`Minimal speedup (${metrics.speedup}x) - consider different topology or larger batches`);
+        }
+        if (metrics.batchSize < 3) {
+            critiques.push('Small batch size - may not fully utilize parallel capabilities');
+        }
+        if (metrics.topology === 'mesh' && metrics.agentCount > 10) {
+            critiques.push('Mesh topology with many agents (O(n²) coordination) - consider hierarchical');
+        }
+        if (critiques.length === 0) {
+            if (metrics.speedup && metrics.speedup >= 3.0) {
+                return 'Excellent parallel execution - pattern worth reusing';
+            }
+            return 'Good swarm execution - successful pattern';
+        }
+        return critiques.join('. ');
+    }
+    /**
+     * Get optimization recommendations based on learned patterns
+     */
+    async getOptimization(taskDescription, taskComplexity, estimatedAgentCount) {
+        // Search for similar successful patterns
+        const similarPatterns = await this.reasoningBank.searchPatterns(taskDescription, {
+            k: 10,
+            minReward: 0.7,
+            onlySuccesses: true
+        });
+        if (similarPatterns.length === 0) {
+            // No learned patterns - return default recommendations
+            return this.getDefaultRecommendation(taskComplexity, estimatedAgentCount);
+        }
+        // Analyze patterns to find optimal configuration
+        const topologyScores = new Map();
+        for (const pattern of similarPatterns) {
+            try {
+                const metrics = JSON.parse(pattern.output);
+                const topology = metrics.topology;
+                if (!topologyScores.has(topology)) {
+                    topologyScores.set(topology, { totalReward: 0, count: 0, avgSpeedup: 0 });
+                }
+                const score = topologyScores.get(topology);
+                score.totalReward += pattern.reward;
+                score.count += 1;
+                score.avgSpeedup += metrics.speedup || 1.0;
+            }
+            catch (e) {
+                // Skip invalid pattern data
+                continue;
+            }
+        }
+        // Find best topology based on average reward and speedup
+        let bestTopology = 'hierarchical';
+        let bestScore = 0;
+        let bestSpeedup = 1.0;
+        const alternatives = [];
+        for (const [topology, data] of topologyScores.entries()) {
+            const avgReward = data.totalReward / data.count;
+            const avgSpeedup = data.avgSpeedup / data.count;
+            const score = avgReward * 0.6 + (avgSpeedup / 5.0) * 0.4; // Weighted score
+            if (score > bestScore) {
+                if (bestScore > 0) {
+                    // Previous best becomes alternative
+                    alternatives.push({
+                        topology: bestTopology,
+                        confidence: Math.round(bestScore * 100) / 100,
+                        reasoning: `Average speedup: ${bestSpeedup.toFixed(2)}x from ${topologyScores.get(bestTopology).count} executions`
+                    });
+                }
+                bestScore = score;
+                bestTopology = topology;
+                bestSpeedup = avgSpeedup;
+            }
+            else {
+                alternatives.push({
+                    topology,
+                    confidence: Math.round(score * 100) / 100,
+                    reasoning: `Average speedup: ${avgSpeedup.toFixed(2)}x from ${data.count} executions`
+                });
+            }
+        }
+        // Determine optimal batch size based on task complexity and learned patterns
+        const optimalBatchSize = this.determineOptimalBatchSize(taskComplexity, estimatedAgentCount, similarPatterns);
+        return {
+            recommendedTopology: bestTopology,
+            recommendedBatchSize: optimalBatchSize,
+            recommendedAgentCount: Math.min(estimatedAgentCount, this.getMaxAgentsForTopology(bestTopology)),
+            expectedSpeedup: bestSpeedup,
+            confidence: Math.round(bestScore * 100) / 100,
+            reasoning: `Based on ${similarPatterns.length} similar successful executions. ` +
+                `${bestTopology} topology achieved ${bestSpeedup.toFixed(2)}x average speedup.`,
+            alternatives: alternatives.sort((a, b) => b.confidence - a.confidence).slice(0, 2)
+        };
+    }
+    /**
+     * Get default recommendations when no learned patterns exist
+     */
+    getDefaultRecommendation(taskComplexity, estimatedAgentCount) {
+        // Default topology selection based on agent count and complexity
+        let topology;
+        let expectedSpeedup;
+        let reasoning;
+        if (estimatedAgentCount <= 5) {
+            topology = 'mesh';
+            expectedSpeedup = 2.5;
+            reasoning = 'Mesh topology optimal for small swarms (≤5 agents) - full peer-to-peer coordination';
+        }
+        else if (estimatedAgentCount <= 10) {
+            topology = 'hierarchical';
+            expectedSpeedup = 3.5;
+            reasoning = 'Hierarchical topology optimal for medium swarms (6-10 agents) - efficient delegation';
+        }
+        else {
+            topology = 'hierarchical';
+            expectedSpeedup = 4.0;
+            reasoning = 'Hierarchical topology required for large swarms (>10 agents) - avoids O(n²) coordination overhead';
+        }
+        // Adjust for task complexity
+        if (taskComplexity === 'critical' || taskComplexity === 'high') {
+            expectedSpeedup *= 1.2; // Higher complexity benefits more from parallelization
+        }
+        const batchSize = this.determineOptimalBatchSize(taskComplexity, estimatedAgentCount, []);
+        return {
+            recommendedTopology: topology,
+            recommendedBatchSize: batchSize,
+            recommendedAgentCount: Math.min(estimatedAgentCount, this.getMaxAgentsForTopology(topology)),
+            expectedSpeedup,
+            confidence: 0.6, // Lower confidence without learned patterns
+            reasoning: `${reasoning} (default recommendation - no learned patterns yet)`,
+            alternatives: [
+                {
+                    topology: topology === 'mesh' ? 'hierarchical' : 'mesh',
+                    confidence: 0.5,
+                    reasoning: 'Alternative topology if default does not perform well'
+                }
+            ]
+        };
+    }
+    /**
+     * Determine optimal batch size based on complexity and learned patterns
+     */
+    determineOptimalBatchSize(taskComplexity, estimatedAgentCount, learnedPatterns) {
+        // Analyze learned patterns for optimal batch size
+        if (learnedPatterns.length > 0) {
+            const batchSizes = learnedPatterns
+                .map(p => {
+                try {
+                    const metrics = JSON.parse(p.output);
+                    return { batchSize: metrics.batchSize, reward: p.reward };
+                }
+                catch (e) {
+                    return null;
+                }
+            })
+                .filter(x => x !== null);
+            if (batchSizes.length > 0) {
+                // Find batch size with highest average reward
+                const batchMap = new Map();
+                for (const { batchSize, reward } of batchSizes) {
+                    if (!batchMap.has(batchSize)) {
+                        batchMap.set(batchSize, { totalReward: 0, count: 0 });
+                    }
+                    const entry = batchMap.get(batchSize);
+                    entry.totalReward += reward;
+                    entry.count += 1;
+                }
+                let bestBatchSize = 3;
+                let bestAvgReward = 0;
+                for (const [batchSize, { totalReward, count }] of batchMap.entries()) {
+                    const avgReward = totalReward / count;
+                    if (avgReward > bestAvgReward) {
+                        bestAvgReward = avgReward;
+                        bestBatchSize = batchSize;
+                    }
+                }
+                return bestBatchSize;
+            }
+        }
+        // Default batch size based on complexity
+        switch (taskComplexity) {
+            case 'low':
+                return Math.min(3, estimatedAgentCount);
+            case 'medium':
+                return Math.min(5, estimatedAgentCount);
+            case 'high':
+                return Math.min(7, estimatedAgentCount);
+            case 'critical':
+                return Math.min(10, estimatedAgentCount);
+        }
+    }
+    /**
+     * Get maximum agents for topology (to avoid coordination overhead)
+     */
+    getMaxAgentsForTopology(topology) {
+        switch (topology) {
+            case 'mesh':
+                return 10; // O(n²) coordination overhead beyond this
+            case 'hierarchical':
+                return 50; // Scales well with delegation
+            case 'ring':
+                return 20; // Sequential token passing limits scale
+            case 'star':
+                return 30; // Central coordinator bottleneck
+            default:
+                return 10;
+        }
+    }
+    /**
+     * Generate statistics report on learned patterns
+     */
+    async getOptimizationStats() {
+        const allPatterns = await this.reasoningBank.searchPatterns(this.NAMESPACE, {
+            k: 1000,
+            onlySuccesses: true
+        });
+        const stats = {
+            totalPatterns: allPatterns.length,
+            topologiesUsed: {},
+            speedupByTopology: {},
+            successRates: [],
+            avgSpeedupByTopology: {},
+            avgSuccessRate: 0,
+            bestPerformingTopology: 'hierarchical'
+        };
+        for (const pattern of allPatterns) {
+            try {
+                const metrics = JSON.parse(pattern.output);
+                // Count topology usage
+                stats.topologiesUsed[metrics.topology] = (stats.topologiesUsed[metrics.topology] || 0) + 1;
+                // Track speedup
+                if (!stats.speedupByTopology[metrics.topology]) {
+                    stats.speedupByTopology[metrics.topology] = [];
+                }
+                if (metrics.speedup) {
+                    stats.speedupByTopology[metrics.topology].push(metrics.speedup);
+                }
+                // Track success rate
+                stats.successRates.push(metrics.successRate);
+            }
+            catch (e) {
+                continue;
+            }
+        }
+        // Calculate averages
+        for (const [topology, speedups] of Object.entries(stats.speedupByTopology)) {
+            if (speedups.length > 0) {
+                stats.avgSpeedupByTopology[topology] = speedups.reduce((a, b) => a + b, 0) / speedups.length;
+            }
+        }
+        stats.avgSuccessRate = stats.successRates.length > 0
+            ? stats.successRates.reduce((a, b) => a + b, 0) / stats.successRates.length
+            : 0;
+        // Find best performing topology
+        let bestSpeedup = 0;
+        for (const [topology, avgSpeedup] of Object.entries(stats.avgSpeedupByTopology)) {
+            if (avgSpeedup > bestSpeedup) {
+                bestSpeedup = avgSpeedup;
+                stats.bestPerformingTopology = topology;
+            }
+        }
+        return {
+            totalPatterns: stats.totalPatterns,
+            topologiesUsed: stats.topologiesUsed,
+            avgSpeedupByTopology: stats.avgSpeedupByTopology,
+            avgSuccessRate: Math.round(stats.avgSuccessRate * 10) / 10,
+            bestPerformingTopology: stats.bestPerformingTopology
+        };
+    }
+}
+/**
+ * Auto-select optimal swarm configuration
+ */
+export async function autoSelectSwarmConfig(reasoningBank, taskDescription, options = {}) {
+    const optimizer = new SwarmLearningOptimizer(reasoningBank);
+    const complexity = options.taskComplexity || 'medium';
+    const agentCount = options.estimatedAgentCount || 5;
+    return await optimizer.getOptimization(taskDescription, complexity, agentCount);
+}