agentic-flow 2.0.7 → 3.0.0-alpha.2

package/dist/agentic-flow/src/hooks/parallel-validation.js

@@ -0,0 +1,167 @@
+/**
+ * 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'
+        };
+    }
+}
+//# sourceMappingURL=parallel-validation.js.map

package/dist/agentic-flow/src/hooks/parallel-validation.js.map

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

package/dist/agentic-flow/src/hooks/swarm-learning-optimizer.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Swarm Learning Optimizer
+ *
+ * Enhances parallel execution with adaptive learning, pattern recognition,
+ * and automated topology selection using ReasoningBank intelligence.
+ */
+import { ReasoningBank } from '../reasoningbank';
+export interface SwarmMetrics {
+    topology: 'mesh' | 'hierarchical' | 'ring' | 'star';
+    agentCount: number;
+    batchSize: number;
+    totalTimeMs: number;
+    successRate: number;
+    speedup?: number;
+    taskComplexity: 'low' | 'medium' | 'high' | 'critical';
+    operations: number;
+}
+export interface LearningPattern {
+    taskType: string;
+    optimalTopology: string;
+    optimalBatchSize: number;
+    expectedSpeedup: number;
+    successRate: number;
+    timestamp: string;
+}
+export interface OptimizationRecommendation {
+    recommendedTopology: 'mesh' | 'hierarchical' | 'ring' | 'star';
+    recommendedBatchSize: number;
+    recommendedAgentCount: number;
+    expectedSpeedup: number;
+    confidence: number;
+    reasoning: string;
+    alternatives: Array<{
+        topology: string;
+        confidence: number;
+        reasoning: string;
+    }>;
+}
+export declare class SwarmLearningOptimizer {
+    private reasoningBank;
+    private readonly NAMESPACE;
+    constructor(reasoningBank: ReasoningBank);
+    /**
+     * Store swarm execution metrics for learning
+     */
+    storeExecutionPattern(taskDescription: string, metrics: SwarmMetrics, success: boolean): Promise<void>;
+    /**
+     * Calculate reward score for swarm execution (0-1)
+     */
+    private calculateReward;
+    /**
+     * Generate critique for learning
+     */
+    private generateCritique;
+    /**
+     * Get optimization recommendations based on learned patterns
+     */
+    getOptimization(taskDescription: string, taskComplexity: 'low' | 'medium' | 'high' | 'critical', estimatedAgentCount: number): Promise<OptimizationRecommendation>;
+    /**
+     * Get default recommendations when no learned patterns exist
+     */
+    private getDefaultRecommendation;
+    /**
+     * Determine optimal batch size based on complexity and learned patterns
+     */
+    private determineOptimalBatchSize;
+    /**
+     * Get maximum agents for topology (to avoid coordination overhead)
+     */
+    private getMaxAgentsForTopology;
+    /**
+     * Generate statistics report on learned patterns
+     */
+    getOptimizationStats(): Promise<{
+        totalPatterns: number;
+        topologiesUsed: Record<string, number>;
+        avgSpeedupByTopology: Record<string, number>;
+        avgSuccessRate: number;
+        bestPerformingTopology: string;
+    }>;
+}
+/**
+ * Auto-select optimal swarm configuration
+ */
+export declare function autoSelectSwarmConfig(reasoningBank: ReasoningBank, taskDescription: string, options?: {
+    taskComplexity?: 'low' | 'medium' | 'high' | 'critical';
+    estimatedAgentCount?: number;
+}): Promise<OptimizationRecommendation>;
+//# sourceMappingURL=swarm-learning-optimizer.d.ts.map

package/dist/agentic-flow/src/hooks/swarm-learning-optimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swarm-learning-optimizer.d.ts","sourceRoot":"","sources":["../../../../src/hooks/swarm-learning-optimizer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACvD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,0BAA0B;IACzC,mBAAmB,EAAE,MAAM,GAAG,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;IAC/D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,KAAK,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;CACJ;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;gBAEtC,aAAa,EAAE,aAAa;IAIxC;;OAEG;IACG,qBAAqB,CACzB,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC;IAgBhB;;OAEG;IACH,OAAO,CAAC,eAAe;IAgCvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAiCxB;;OAEG;IACG,eAAe,CACnB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,EACtD,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,0BAA0B,CAAC;IAkFtC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA+ChC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAyDjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAe/B;;OAEG;IACG,oBAAoB,IAAI,OAAO,CAAC;QACpC,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC7C,cAAc,EAAE,MAAM,CAAC;QACvB,sBAAsB,EAAE,MAAM,CAAC;KAChC,CAAC;CAkEH;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,MAAM,EACvB,OAAO,GAAE;IACP,cAAc,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACxD,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACzB,GACL,OAAO,CAAC,0BAA0B,CAAC,CAOrC"}

package/dist/agentic-flow/src/hooks/swarm-learning-optimizer.js

@@ -0,0 +1,351 @@
+/**
+ * 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);
+}
+//# sourceMappingURL=swarm-learning-optimizer.js.map