agentic-flow 3.0.0-alpha.2 → 3.1.0

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

@@ -1,167 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,89 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,351 +0,0 @@
-/**
- * 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