claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/hive-mind/core.js

@@ -1,959 +1,1031 @@
 /**
  * Hive Mind Core System
  * Central orchestration and coordination logic
- */ import EventEmitter from "events";
-import { MCPToolWrapper } from "./mcp-wrapper.js";
-import { PerformanceOptimizer } from "./performance-optimizer.js";
+ */
+
+import EventEmitter from 'events';
+import { MCPToolWrapper } from './mcp-wrapper.js';
+import { PerformanceOptimizer } from './performance-optimizer.js';
+
 /**
  * HiveMindCore - Main orchestration class
- */ export class HiveMindCore extends EventEmitter {
-    /**
+ */
+export class HiveMindCore extends EventEmitter {
+  constructor(config = {}) {
+    super();
+
+    this.config = {
+      objective: '',
+      name: `hive-${Date.now()}`,
+      queenType: 'strategic',
+      maxWorkers: 8,
+      consensusAlgorithm: 'majority',
+      autoScale: true,
+      encryption: false,
+      memorySize: 100, // MB
+      taskTimeout: 60, // minutes
+      ...config,
+    };
+
+    this.state = {
+      status: 'initializing',
+      swarmId: null,
+      queen: null,
+      workers: new Map(),
+      tasks: new Map(),
+      memory: new Map(),
+      decisions: new Map(),
+      metrics: {
+        tasksCreated: 0,
+        tasksCompleted: 0,
+        decisionsReached: 0,
+        memoryUsage: 0,
+      },
+    };
+
+    this.mcpWrapper = new MCPToolWrapper({
+      parallel: true,
+      timeout: this.config.taskTimeout * 60 * 1000,
+    });
+
+    // Initialize performance optimizer
+    this.performanceOptimizer = new PerformanceOptimizer({
+      enableAsyncQueue: true,
+      enableBatchProcessing: true,
+      enableAutoTuning: true,
+      asyncQueueConcurrency: Math.min(this.config.maxWorkers * 2, 20),
+      batchMaxSize: 50,
+      metricsInterval: 30000,
+    });
+
+    this._initializeEventHandlers();
+    this._initializePerformanceMonitoring();
+  }
+
+  /**
    * Initialize event handlers
-   */ _initializeEventHandlers() {
-        this.on('task:created', (task)=>{
-            this.state.metrics.tasksCreated++;
-            this._checkAutoScale();
-        });
-        this.on('task:completed', (task)=>{
-            this.state.metrics.tasksCompleted++;
-            this._updatePerformanceMetrics();
-        });
-        this.on('task:failed', (data)=>{
-            console.warn(`Task failed: ${data.task.id}`, data.error);
-            this._handleTaskFailure(data.task, data.error);
-        });
-        this.on('decision:reached', (decision)=>{
-            this.state.metrics.decisionsReached++;
-        });
-        this.on('worker:idle', (workerId)=>{
-            this._assignNextTask(workerId);
-        });
-        this.on('error', (error)=>{
-            console.error('Hive Mind Error:', error);
-            this._handleError(error);
-        });
-    }
-    /**
+   */
+  _initializeEventHandlers() {
+    this.on('task:created', (task) => {
+      this.state.metrics.tasksCreated++;
+      this._checkAutoScale();
+    });
+
+    this.on('task:completed', (task) => {
+      this.state.metrics.tasksCompleted++;
+      this._updatePerformanceMetrics();
+    });
+
+    this.on('task:failed', (data) => {
+      console.warn(`Task failed: ${data.task.id}`, data.error);
+      this._handleTaskFailure(data.task, data.error);
+    });
+
+    this.on('decision:reached', (decision) => {
+      this.state.metrics.decisionsReached++;
+    });
+
+    this.on('worker:idle', (workerId) => {
+      this._assignNextTask(workerId);
+    });
+
+    this.on('error', (error) => {
+      console.error('Hive Mind Error:', error);
+      this._handleError(error);
+    });
+  }
+
+  /**
    * Initialize performance monitoring
-   */ _initializePerformanceMonitoring() {
-        // Listen to performance optimizer events
-        this.performanceOptimizer.on('auto_tune', (data)=>{
-            console.log(`Performance auto-tuned: ${data.type} = ${data.newValue}`);
-            this.emit('performance:auto_tuned', data);
-        });
-        this.performanceOptimizer.on('error', (error)=>{
-            console.error('Performance optimizer error:', error);
-            this.emit('error', {
-                type: 'performance_optimizer_error',
-                error
-            });
-        });
-        // Periodic performance reporting
-        setInterval(()=>{
-            const stats = this.performanceOptimizer.getPerformanceStats();
-            this.emit('performance:stats', stats);
-            // Log performance warnings
-            if (parseFloat(stats.asyncQueue.utilization) > 90) {
-                console.warn('High async queue utilization:', stats.asyncQueue.utilization + '%');
-            }
-            if (parseFloat(stats.asyncQueue.successRate) < 95) {
-                console.warn('Low async operation success rate:', stats.asyncQueue.successRate + '%');
-            }
-        }, 60000); // Every minute
-    }
-    /**
+   */
+  _initializePerformanceMonitoring() {
+    // Listen to performance optimizer events
+    this.performanceOptimizer.on('auto_tune', (data) => {
+      console.log(`Performance auto-tuned: ${data.type} = ${data.newValue}`);
+      this.emit('performance:auto_tuned', data);
+    });
+
+    this.performanceOptimizer.on('error', (error) => {
+      console.error('Performance optimizer error:', error);
+      this.emit('error', { type: 'performance_optimizer_error', error });
+    });
+
+    // Periodic performance reporting
+    setInterval(() => {
+      const stats = this.performanceOptimizer.getPerformanceStats();
+      this.emit('performance:stats', stats);
+
+      // Log performance warnings
+      if (parseFloat(stats.asyncQueue.utilization) > 90) {
+        console.warn('High async queue utilization:', stats.asyncQueue.utilization + '%');
+      }
+
+      if (parseFloat(stats.asyncQueue.successRate) < 95) {
+        console.warn('Low async operation success rate:', stats.asyncQueue.successRate + '%');
+      }
+    }, 60000); // Every minute
+  }
+
+  /**
    * Handle task failure with recovery logic
-   */ _handleTaskFailure(task, error) {
-        // Update metrics
-        this.state.metrics.tasksFailed = (this.state.metrics.tasksFailed || 0) + 1;
-        // Attempt task retry for recoverable failures
-        if (task.retryCount < 2 && this._isRecoverableError(error)) {
-            task.retryCount = (task.retryCount || 0) + 1;
-            task.status = 'pending';
-            // Find another worker for retry
-            setTimeout(()=>{
-                const worker = this._findBestWorker(task);
-                if (worker) {
-                    this._assignTask(worker.id, task.id);
-                }
-            }, 5000); // Wait 5 seconds before retry
-            console.log(`Retrying task ${task.id} (attempt ${task.retryCount})`);
+   */
+  _handleTaskFailure(task, error) {
+    // Update metrics
+    this.state.metrics.tasksFailed = (this.state.metrics.tasksFailed || 0) + 1;
+
+    // Attempt task retry for recoverable failures
+    if (task.retryCount < 2 && this._isRecoverableError(error)) {
+      task.retryCount = (task.retryCount || 0) + 1;
+      task.status = 'pending';
+
+      // Find another worker for retry
+      setTimeout(() => {
+        const worker = this._findBestWorker(task);
+        if (worker) {
+          this._assignTask(worker.id, task.id);
         }
+      }, 5000); // Wait 5 seconds before retry
+
+      console.log(`Retrying task ${task.id} (attempt ${task.retryCount})`);
     }
-    /**
+  }
+
+  /**
    * Check if error is recoverable
-   */ _isRecoverableError(error) {
-        const recoverableErrors = [
-            'timeout',
-            'network',
-            'temporary',
-            'connection'
-        ];
-        return recoverableErrors.some((type)=>error.message.toLowerCase().includes(type));
-    }
-    /**
+   */
+  _isRecoverableError(error) {
+    const recoverableErrors = ['timeout', 'network', 'temporary', 'connection'];
+
+    return recoverableErrors.some((type) => error.message.toLowerCase().includes(type));
+  }
+
+  /**
    * Initialize the hive mind swarm
-   */ async initialize() {
-        try {
-            this.state.status = 'initializing';
-            // Initialize swarm with MCP tools
-            const [swarmInit, memoryInit, neuralInit] = await this.mcpWrapper.initializeSwarm({
-                topology: this._determineTopology(),
-                maxAgents: this.config.maxWorkers + 1,
-                swarmId: this.config.name
-            });
-            this.state.swarmId = swarmInit.swarmId;
-            // Store initial configuration in memory
-            await this.mcpWrapper.storeMemory(this.state.swarmId, 'config', this.config, 'system');
-            this.state.status = 'ready';
-            this.emit('initialized', {
-                swarmId: this.state.swarmId
-            });
-            return this.state.swarmId;
-        } catch (error) {
-            this.state.status = 'error';
-            this.emit('error', error);
-            throw error;
-        }
+   */
+  async initialize() {
+    try {
+      this.state.status = 'initializing';
+
+      // Initialize swarm with MCP tools
+      const [swarmInit, memoryInit, neuralInit] = await this.mcpWrapper.initializeSwarm({
+        topology: this._determineTopology(),
+        maxAgents: this.config.maxWorkers + 1, // +1 for queen
+        swarmId: this.config.name,
+      });
+
+      this.state.swarmId = swarmInit.swarmId;
+
+      // Store initial configuration in memory
+      await this.mcpWrapper.storeMemory(this.state.swarmId, 'config', this.config, 'system');
+
+      this.state.status = 'ready';
+      this.emit('initialized', { swarmId: this.state.swarmId });
+
+      return this.state.swarmId;
+    } catch (error) {
+      this.state.status = 'error';
+      this.emit('error', error);
+      throw error;
     }
-    /**
+  }
+
+  /**
    * Determine optimal topology based on objective
-   */ _determineTopology() {
-        const objective = this.config.objective.toLowerCase();
-        // Heuristic topology selection
-        if (objective.includes('research') || objective.includes('analysis')) {
-            return 'mesh'; // Peer-to-peer for collaborative research
-        } else if (objective.includes('build') || objective.includes('develop')) {
-            return 'hierarchical'; // Clear command structure for development
-        } else if (objective.includes('monitor') || objective.includes('maintain')) {
-            return 'ring'; // Circular for continuous monitoring
-        } else if (objective.includes('coordinate') || objective.includes('orchestrate')) {
-            return 'star'; // Centralized for coordination
-        }
-        return 'hierarchical'; // Default
+   */
+  _determineTopology() {
+    const objective = this.config.objective.toLowerCase();
+
+    // Heuristic topology selection
+    if (objective.includes('research') || objective.includes('analysis')) {
+      return 'mesh'; // Peer-to-peer for collaborative research
+    } else if (objective.includes('build') || objective.includes('develop')) {
+      return 'hierarchical'; // Clear command structure for development
+    } else if (objective.includes('monitor') || objective.includes('maintain')) {
+      return 'ring'; // Circular for continuous monitoring
+    } else if (objective.includes('coordinate') || objective.includes('orchestrate')) {
+      return 'star'; // Centralized for coordination
     }
-    /**
+
+    return 'hierarchical'; // Default
+  }
+
+  /**
    * Spawn the queen coordinator
-   */ async spawnQueen(queenData) {
-        const [spawnResult] = await this.mcpWrapper.spawnAgents([
-            'coordinator'
-        ], this.state.swarmId);
-        this.state.queen = {
-            id: queenData.id,
-            agentId: spawnResult.agentId,
-            type: this.config.queenType,
-            status: 'active',
-            decisions: 0,
-            tasks: 0
-        };
-        // Store queen info in memory
-        await this.mcpWrapper.storeMemory(this.state.swarmId, 'queen', this.state.queen, 'system');
-        this.emit('queen:spawned', this.state.queen);
-        return this.state.queen;
-    }
-    /**
+   */
+  async spawnQueen(queenData) {
+    const [spawnResult] = await this.mcpWrapper.spawnAgents(['coordinator'], this.state.swarmId);
+
+    this.state.queen = {
+      id: queenData.id,
+      agentId: spawnResult.agentId,
+      type: this.config.queenType,
+      status: 'active',
+      decisions: 0,
+      tasks: 0,
+    };
+
+    // Store queen info in memory
+    await this.mcpWrapper.storeMemory(this.state.swarmId, 'queen', this.state.queen, 'system');
+
+    this.emit('queen:spawned', this.state.queen);
+    return this.state.queen;
+  }
+
+  /**
    * Spawn worker agents with batch optimization
-   */ async spawnWorkers(workerTypes) {
-        const startTime = Date.now();
-        try {
-            // Batch spawn agents in parallel with optimized chunking
-            const chunkSize = Math.min(workerTypes.length, 5); // Optimal batch size
-            const chunks = [];
-            for(let i = 0; i < workerTypes.length; i += chunkSize){
-                chunks.push(workerTypes.slice(i, i + chunkSize));
-            }
-            // Process chunks in parallel with Promise.all
-            const allResults = await Promise.all(chunks.map((chunk)=>this.mcpWrapper.spawnAgents(chunk, this.state.swarmId)));
-            // Flatten results
-            const spawnResults = allResults.flat();
-            // Batch create worker objects
-            const workers = [];
-            const workerUpdates = [];
-            spawnResults.forEach((result, index)=>{
-                const worker = {
-                    id: `worker-${index}`,
-                    agentId: result.agentId,
-                    type: workerTypes[index],
-                    status: 'idle',
-                    tasksCompleted: 0,
-                    currentTask: null,
-                    spawnedAt: Date.now(),
-                    performance: {
-                        avgTaskTime: 0,
-                        successRate: 1.0
-                    }
-                };
-                workers.push(worker);
-                this.state.workers.set(worker.id, worker);
-                workerUpdates.push({
-                    type: 'worker_spawned',
-                    workerId: worker.id,
-                    workerType: worker.type,
-                    timestamp: worker.spawnedAt
-                });
-            });
-            // Batch memory operations
-            await Promise.all([
-                this.mcpWrapper.storeMemory(this.state.swarmId, 'workers', workers, 'system'),
-                this.mcpWrapper.storeMemory(this.state.swarmId, 'worker_spawn_batch', {
-                    count: workers.length,
-                    types: workerTypes,
-                    spawnTime: Date.now() - startTime,
-                    updates: workerUpdates
-                }, 'metrics')
-            ]);
-            // Emit batch completion event
-            this.emit('workers:spawned', {
-                count: this.state.workers.size,
-                batchSize: workers.length,
-                spawnTime: Date.now() - startTime,
-                workers: workers
-            });
-            return workers;
-        } catch (error) {
-            this.emit('error', {
-                type: 'spawn_batch_failed',
-                error,
-                workerTypes,
-                spawnTime: Date.now() - startTime
-            });
-            throw error;
-        }
+   */
+  async spawnWorkers(workerTypes) {
+    const startTime = Date.now();
+
+    try {
+      // Batch spawn agents in parallel with optimized chunking
+      const chunkSize = Math.min(workerTypes.length, 5); // Optimal batch size
+      const chunks = [];
+
+      for (let i = 0; i < workerTypes.length; i += chunkSize) {
+        chunks.push(workerTypes.slice(i, i + chunkSize));
+      }
+
+      // Process chunks in parallel with Promise.all
+      const allResults = await Promise.all(
+        chunks.map((chunk) => this.mcpWrapper.spawnAgents(chunk, this.state.swarmId)),
+      );
+
+      // Flatten results
+      const spawnResults = allResults.flat();
+
+      // Batch create worker objects
+      const workers = [];
+      const workerUpdates = [];
+
+      spawnResults.forEach((result, index) => {
+        const worker = {
+          id: `worker-${index}`,
+          agentId: result.agentId,
+          type: workerTypes[index],
+          status: 'idle',
+          tasksCompleted: 0,
+          currentTask: null,
+          spawnedAt: Date.now(),
+          performance: {
+            avgTaskTime: 0,
+            successRate: 1.0,
+          },
+        };
+
+        workers.push(worker);
+        this.state.workers.set(worker.id, worker);
+
+        workerUpdates.push({
+          type: 'worker_spawned',
+          workerId: worker.id,
+          workerType: worker.type,
+          timestamp: worker.spawnedAt,
+        });
+      });
+
+      // Batch memory operations
+      await Promise.all([
+        this.mcpWrapper.storeMemory(this.state.swarmId, 'workers', workers, 'system'),
+        this.mcpWrapper.storeMemory(
+          this.state.swarmId,
+          'worker_spawn_batch',
+          {
+            count: workers.length,
+            types: workerTypes,
+            spawnTime: Date.now() - startTime,
+            updates: workerUpdates,
+          },
+          'metrics',
+        ),
+      ]);
+
+      // Emit batch completion event
+      this.emit('workers:spawned', {
+        count: this.state.workers.size,
+        batchSize: workers.length,
+        spawnTime: Date.now() - startTime,
+        workers: workers,
+      });
+
+      return workers;
+    } catch (error) {
+      this.emit('error', {
+        type: 'spawn_batch_failed',
+        error,
+        workerTypes,
+        spawnTime: Date.now() - startTime,
+      });
+      throw error;
     }
-    /**
+  }
+
+  /**
    * Create and distribute task with performance optimization
-   */ async createTask(description, priority = 5, metadata = {}) {
-        const timestamp = Date.now();
-        const randomPart = Math.random().toString(36).substring(2, 11); // Use substring instead of substr
-        const taskId = `task-${timestamp}-${randomPart}`;
-        const createdAt = Date.now();
-        const task = {
-            id: taskId,
-            swarmId: this.state.swarmId,
-            description,
-            priority,
-            status: 'pending',
-            createdAt: new Date(createdAt).toISOString(),
-            assignedTo: null,
-            result: null,
-            metadata: {
-                estimatedDuration: this._estimateTaskDuration(description),
-                complexity: this._analyzeTaskComplexity(description),
-                ...metadata
-            }
-        };
-        // Parallel operations: task storage, orchestration, and worker finding
-        const [orchestrateResult, bestWorker] = await Promise.all([
-            this.mcpWrapper.orchestrateTask(description, 'adaptive'),
-            this._findBestWorkerAsync(task),
-            // Store task immediately in parallel
-            (async ()=>{
-                this.state.tasks.set(task.id, task);
-                await this.mcpWrapper.storeMemory(this.state.swarmId, `task-${task.id}`, task, 'task');
-            })()
-        ]);
-        task.orchestrationId = orchestrateResult[0].taskId;
-        this.emit('task:created', task);
-        // Assign task if worker available
-        if (bestWorker) {
-            // Use non-blocking assignment
-            setImmediate(()=>this._assignTask(bestWorker.id, task.id));
-        }
-        return task;
+   */
+  async createTask(description, priority = 5, metadata = {}) {
+    const timestamp = Date.now();
+    const randomPart = Math.random().toString(36).substring(2, 11); // Use substring instead of substr
+    const taskId = `task-${timestamp}-${randomPart}`;
+    const createdAt = Date.now();
+
+    const task = {
+      id: taskId,
+      swarmId: this.state.swarmId,
+      description,
+      priority,
+      status: 'pending',
+      createdAt: new Date(createdAt).toISOString(),
+      assignedTo: null,
+      result: null,
+      metadata: {
+        estimatedDuration: this._estimateTaskDuration(description),
+        complexity: this._analyzeTaskComplexity(description),
+        ...metadata,
+      },
+    };
+
+    // Parallel operations: task storage, orchestration, and worker finding
+    const [orchestrateResult, bestWorker] = await Promise.all([
+      this.mcpWrapper.orchestrateTask(description, 'adaptive'),
+      this._findBestWorkerAsync(task),
+      // Store task immediately in parallel
+      (async () => {
+        this.state.tasks.set(task.id, task);
+        await this.mcpWrapper.storeMemory(this.state.swarmId, `task-${task.id}`, task, 'task');
+      })(),
+    ]);
+
+    task.orchestrationId = orchestrateResult[0].taskId;
+
+    this.emit('task:created', task);
+
+    // Assign task if worker available
+    if (bestWorker) {
+      // Use non-blocking assignment
+      setImmediate(() => this._assignTask(bestWorker.id, task.id));
     }
-    /**
+
+    return task;
+  }
+
+  /**
    * Estimate task duration based on description analysis
-   */ _estimateTaskDuration(description) {
-        const words = description.toLowerCase().split(/\s+/);
-        const complexityKeywords = {
-            simple: [
-                'list',
-                'show',
-                'display',
-                'get',
-                'read'
-            ],
-            medium: [
-                'create',
-                'update',
-                'modify',
-                'change',
-                'build'
-            ],
-            complex: [
-                'analyze',
-                'optimize',
-                'refactor',
-                'implement',
-                'design'
-            ]
-        };
-        let score = 1;
-        for (const word of words){
-            if (complexityKeywords.complex.includes(word)) score += 3;
-            else if (complexityKeywords.medium.includes(word)) score += 2;
-            else if (complexityKeywords.simple.includes(word)) score += 1;
-        }
-        return Math.min(score * 5000, 60000); // Cap at 1 minute
+   */
+  _estimateTaskDuration(description) {
+    const words = description.toLowerCase().split(/\s+/);
+    const complexityKeywords = {
+      simple: ['list', 'show', 'display', 'get', 'read'],
+      medium: ['create', 'update', 'modify', 'change', 'build'],
+      complex: ['analyze', 'optimize', 'refactor', 'implement', 'design'],
+    };
+
+    let score = 1;
+    for (const word of words) {
+      if (complexityKeywords.complex.includes(word)) score += 3;
+      else if (complexityKeywords.medium.includes(word)) score += 2;
+      else if (complexityKeywords.simple.includes(word)) score += 1;
     }
-    /**
+
+    return Math.min(score * 5000, 60000); // Cap at 1 minute
+  }
+
+  /**
    * Analyze task complexity
-   */ _analyzeTaskComplexity(description) {
-        const words = description.toLowerCase().split(/\s+/);
-        const indicators = {
-            high: [
-                'optimize',
-                'refactor',
-                'architecture',
-                'design',
-                'algorithm'
-            ],
-            medium: [
-                'implement',
-                'build',
-                'create',
-                'develop',
-                'integrate'
-            ],
-            low: [
-                'list',
-                'show',
-                'get',
-                'read',
-                'display'
-            ]
-        };
-        for (const [level, keywords] of Object.entries(indicators)){
-            if (keywords.some((keyword)=>words.includes(keyword))) {
-                return level;
-            }
-        }
-        return 'medium';
+   */
+  _analyzeTaskComplexity(description) {
+    const words = description.toLowerCase().split(/\s+/);
+    const indicators = {
+      high: ['optimize', 'refactor', 'architecture', 'design', 'algorithm'],
+      medium: ['implement', 'build', 'create', 'develop', 'integrate'],
+      low: ['list', 'show', 'get', 'read', 'display'],
+    };
+
+    for (const [level, keywords] of Object.entries(indicators)) {
+      if (keywords.some((keyword) => words.includes(keyword))) {
+        return level;
+      }
     }
-    /**
+
+    return 'medium';
+  }
+
+  /**
    * Find best worker for task (optimized async version)
-   */ async _findBestWorkerAsync(task) {
-        const availableWorkers = Array.from(this.state.workers.values()).filter((w)=>w.status === 'idle');
-        if (availableWorkers.length === 0) {
-            return null;
-        }
-        // Use cached analysis if available
-        const cacheKey = `worker_match_${task.description.substring(0, 50)}`;
-        const cachedMatch = await this.mcpWrapper.retrieveMemory(this.state.swarmId, cacheKey);
-        if (cachedMatch && cachedMatch.timestamp > Date.now() - 300000) {
-            // 5 min cache
-            const cachedWorker = availableWorkers.find((w)=>w.type === cachedMatch.workerType);
-            if (cachedWorker) return cachedWorker;
-        }
-        // Enhanced matching algorithm with performance scoring
-        const taskLower = task.description.toLowerCase();
-        const taskWords = taskLower.split(/\s+/);
-        // Enhanced priority mapping with weights
-        const priorityMap = {
-            researcher: {
-                keywords: [
-                    'research',
-                    'investigate',
-                    'analyze',
-                    'study',
-                    'explore'
-                ],
-                weight: 1.2
-            },
-            coder: {
-                keywords: [
-                    'code',
-                    'implement',
-                    'build',
-                    'develop',
-                    'fix',
-                    'create',
-                    'program'
-                ],
-                weight: 1.0
-            },
-            analyst: {
-                keywords: [
-                    'analyze',
-                    'data',
-                    'metrics',
-                    'performance',
-                    'report',
-                    'statistics'
-                ],
-                weight: 1.1
-            },
-            tester: {
-                keywords: [
-                    'test',
-                    'validate',
-                    'check',
-                    'verify',
-                    'quality',
-                    'qa'
-                ],
-                weight: 1.0
-            },
-            architect: {
-                keywords: [
-                    'design',
-                    'architecture',
-                    'structure',
-                    'plan',
-                    'system'
-                ],
-                weight: 1.3
-            },
-            reviewer: {
-                keywords: [
-                    'review',
-                    'feedback',
-                    'improve',
-                    'refactor',
-                    'audit'
-                ],
-                weight: 1.0
-            },
-            optimizer: {
-                keywords: [
-                    'optimize',
-                    'performance',
-                    'speed',
-                    'efficiency',
-                    'enhance'
-                ],
-                weight: 1.4
-            },
-            documenter: {
-                keywords: [
-                    'document',
-                    'explain',
-                    'write',
-                    'describe',
-                    'manual'
-                ],
-                weight: 0.9
-            }
-        };
-        // Calculate scores for each worker
-        const workerScores = availableWorkers.map((worker)=>{
-            const typeInfo = priorityMap[worker.type] || {
-                keywords: [],
-                weight: 1.0
-            };
-            // Keyword matching score
-            const keywordScore = typeInfo.keywords.reduce((score, keyword)=>{
-                return score + (taskWords.includes(keyword) ? 1 : 0);
-            }, 0);
-            // Performance history score
-            const performanceScore = worker.performance ? worker.performance.successRate * 0.5 + 1 / (worker.performance.avgTaskTime + 1) * 0.5 : 0.5;
-            // Task completion rate
-            const completionScore = worker.tasksCompleted > 0 ? Math.min(worker.tasksCompleted / 10, 1) : 0;
-            // Combined score
-            const totalScore = (keywordScore * 2 + // Keyword relevance
-            performanceScore * 1.5 + // Historical performance
-            completionScore * 1.0) * // Experience
-            typeInfo.weight;
-            return {
-                worker,
-                score: totalScore,
-                breakdown: {
-                    keyword: keywordScore,
-                    performance: performanceScore,
-                    completion: completionScore,
-                    weight: typeInfo.weight
-                }
-            };
-        });
-        // Sort by score and select best
-        workerScores.sort((a, b)=>b.score - a.score);
-        const bestMatch = workerScores[0];
-        // Cache the result for future use
-        if (bestMatch.score > 0) {
-            setImmediate(async ()=>{
-                await this.mcpWrapper.storeMemory(this.state.swarmId, cacheKey, {
-                    workerType: bestMatch.worker.type,
-                    score: bestMatch.score,
-                    timestamp: Date.now()
-                }, 'cache');
-            });
-        }
-        return bestMatch ? bestMatch.worker : availableWorkers[0];
+   */
+  async _findBestWorkerAsync(task) {
+    const availableWorkers = Array.from(this.state.workers.values()).filter(
+      (w) => w.status === 'idle',
+    );
+
+    if (availableWorkers.length === 0) {
+      return null;
+    }
+
+    // Use cached analysis if available
+    const cacheKey = `worker_match_${task.description.substring(0, 50)}`;
+    const cachedMatch = await this.mcpWrapper.retrieveMemory(this.state.swarmId, cacheKey);
+
+    if (cachedMatch && cachedMatch.timestamp > Date.now() - 300000) {
+      // 5 min cache
+      const cachedWorker = availableWorkers.find((w) => w.type === cachedMatch.workerType);
+      if (cachedWorker) return cachedWorker;
     }
-    /**
+
+    // Enhanced matching algorithm with performance scoring
+    const taskLower = task.description.toLowerCase();
+    const taskWords = taskLower.split(/\s+/);
+
+    // Enhanced priority mapping with weights
+    const priorityMap = {
+      researcher: {
+        keywords: ['research', 'investigate', 'analyze', 'study', 'explore'],
+        weight: 1.2,
+      },
+      coder: {
+        keywords: ['code', 'implement', 'build', 'develop', 'fix', 'create', 'program'],
+        weight: 1.0,
+      },
+      analyst: {
+        keywords: ['analyze', 'data', 'metrics', 'performance', 'report', 'statistics'],
+        weight: 1.1,
+      },
+      tester: { keywords: ['test', 'validate', 'check', 'verify', 'quality', 'qa'], weight: 1.0 },
+      architect: {
+        keywords: ['design', 'architecture', 'structure', 'plan', 'system'],
+        weight: 1.3,
+      },
+      reviewer: { keywords: ['review', 'feedback', 'improve', 'refactor', 'audit'], weight: 1.0 },
+      optimizer: {
+        keywords: ['optimize', 'performance', 'speed', 'efficiency', 'enhance'],
+        weight: 1.4,
+      },
+      documenter: { keywords: ['document', 'explain', 'write', 'describe', 'manual'], weight: 0.9 },
+    };
+
+    // Calculate scores for each worker
+    const workerScores = availableWorkers.map((worker) => {
+      const typeInfo = priorityMap[worker.type] || { keywords: [], weight: 1.0 };
+
+      // Keyword matching score
+      const keywordScore = typeInfo.keywords.reduce((score, keyword) => {
+        return score + (taskWords.includes(keyword) ? 1 : 0);
+      }, 0);
+
+      // Performance history score
+      const performanceScore = worker.performance
+        ? worker.performance.successRate * 0.5 + (1 / (worker.performance.avgTaskTime + 1)) * 0.5
+        : 0.5;
+
+      // Task completion rate
+      const completionScore =
+        worker.tasksCompleted > 0 ? Math.min(worker.tasksCompleted / 10, 1) : 0;
+
+      // Combined score
+      const totalScore =
+        (keywordScore * 2 + // Keyword relevance
+          performanceScore * 1.5 + // Historical performance
+          completionScore * 1.0) * // Experience
+        typeInfo.weight;
+
+      return {
+        worker,
+        score: totalScore,
+        breakdown: {
+          keyword: keywordScore,
+          performance: performanceScore,
+          completion: completionScore,
+          weight: typeInfo.weight,
+        },
+      };
+    });
+
+    // Sort by score and select best
+    workerScores.sort((a, b) => b.score - a.score);
+    const bestMatch = workerScores[0];
+
+    // Cache the result for future use
+    if (bestMatch.score > 0) {
+      setImmediate(async () => {
+        await this.mcpWrapper.storeMemory(
+          this.state.swarmId,
+          cacheKey,
+          {
+            workerType: bestMatch.worker.type,
+            score: bestMatch.score,
+            timestamp: Date.now(),
+          },
+          'cache',
+        );
+      });
+    }
+
+    return bestMatch ? bestMatch.worker : availableWorkers[0];
+  }
+
+  /**
    * Synchronous version for backward compatibility
-   */ _findBestWorker(task) {
-        const availableWorkers = Array.from(this.state.workers.values()).filter((w)=>w.status === 'idle');
-        if (availableWorkers.length === 0) {
-            return null;
-        }
-        // Simplified scoring for sync version
-        const taskLower = task.description.toLowerCase();
-        const priorityMap = {
-            researcher: [
-                'research',
-                'investigate',
-                'analyze',
-                'study'
-            ],
-            coder: [
-                'code',
-                'implement',
-                'build',
-                'develop',
-                'fix',
-                'create'
-            ],
-            analyst: [
-                'analyze',
-                'data',
-                'metrics',
-                'performance',
-                'report'
-            ],
-            tester: [
-                'test',
-                'validate',
-                'check',
-                'verify',
-                'quality'
-            ],
-            architect: [
-                'design',
-                'architecture',
-                'structure',
-                'plan'
-            ],
-            reviewer: [
-                'review',
-                'feedback',
-                'improve',
-                'refactor'
-            ],
-            optimizer: [
-                'optimize',
-                'performance',
-                'speed',
-                'efficiency'
-            ],
-            documenter: [
-                'document',
-                'explain',
-                'write',
-                'describe'
-            ]
-        };
-        let bestWorker = null;
-        let bestScore = 0;
-        for (const worker of availableWorkers){
-            const keywords = priorityMap[worker.type] || [];
-            const keywordScore = keywords.filter((k)=>taskLower.includes(k)).length;
-            const performanceBonus = worker.performance ? worker.performance.successRate * 0.5 : 0;
-            const totalScore = keywordScore + performanceBonus;
-            if (totalScore > bestScore) {
-                bestScore = totalScore;
-                bestWorker = worker;
-            }
-        }
-        return bestWorker || availableWorkers[0];
+   */
+  _findBestWorker(task) {
+    const availableWorkers = Array.from(this.state.workers.values()).filter(
+      (w) => w.status === 'idle',
+    );
+
+    if (availableWorkers.length === 0) {
+      return null;
     }
-    /**
-   * Assign task to worker
-   */ async _assignTask(workerId, taskId) {
-        const worker = this.state.workers.get(workerId);
-        const task = this.state.tasks.get(taskId);
-        if (!worker || !task) return;
-        worker.status = 'busy';
-        worker.currentTask = taskId;
-        task.status = 'in_progress';
-        task.assignedTo = workerId;
-        // Store assignment in memory
-        await this.mcpWrapper.storeMemory(this.state.swarmId, `assignment-${taskId}`, {
-            workerId,
-            taskId,
-            timestamp: Date.now()
-        }, 'task');
-        this.emit('task:assigned', {
-            workerId,
-            taskId
-        });
-        // Simulate task execution
-        this._executeTask(workerId, taskId);
+
+    // Simplified scoring for sync version
+    const taskLower = task.description.toLowerCase();
+    const priorityMap = {
+      researcher: ['research', 'investigate', 'analyze', 'study'],
+      coder: ['code', 'implement', 'build', 'develop', 'fix', 'create'],
+      analyst: ['analyze', 'data', 'metrics', 'performance', 'report'],
+      tester: ['test', 'validate', 'check', 'verify', 'quality'],
+      architect: ['design', 'architecture', 'structure', 'plan'],
+      reviewer: ['review', 'feedback', 'improve', 'refactor'],
+      optimizer: ['optimize', 'performance', 'speed', 'efficiency'],
+      documenter: ['document', 'explain', 'write', 'describe'],
+    };
+
+    let bestWorker = null;
+    let bestScore = 0;
+
+    for (const worker of availableWorkers) {
+      const keywords = priorityMap[worker.type] || [];
+      const keywordScore = keywords.filter((k) => taskLower.includes(k)).length;
+      const performanceBonus = worker.performance ? worker.performance.successRate * 0.5 : 0;
+      const totalScore = keywordScore + performanceBonus;
+
+      if (totalScore > bestScore) {
+        bestScore = totalScore;
+        bestWorker = worker;
+      }
     }
-    /**
+
+    return bestWorker || availableWorkers[0];
+  }
+
+  /**
+   * Assign task to worker
+   */
+  async _assignTask(workerId, taskId) {
+    const worker = this.state.workers.get(workerId);
+    const task = this.state.tasks.get(taskId);
+
+    if (!worker || !task) return;
+
+    worker.status = 'busy';
+    worker.currentTask = taskId;
+    task.status = 'in_progress';
+    task.assignedTo = workerId;
+
+    // Store assignment in memory
+    await this.mcpWrapper.storeMemory(
+      this.state.swarmId,
+      `assignment-${taskId}`,
+      { workerId, taskId, timestamp: Date.now() },
+      'task',
+    );
+
+    this.emit('task:assigned', { workerId, taskId });
+
+    // Simulate task execution
+    this._executeTask(workerId, taskId);
+  }
+
+  /**
    * Execute task with performance optimization
-   */ async _executeTask(workerId, taskId) {
-        const worker = this.state.workers.get(workerId);
-        const task = this.state.tasks.get(taskId);
-        const startTime = Date.now();
-        try {
-            // Use performance optimizer for async execution
-            const result = await this.performanceOptimizer.optimizeAsyncOperation(async ()=>{
-                // Simulate task execution based on complexity
-                const baseDuration = {
-                    low: 5000,
-                    medium: 15000,
-                    high: 30000
-                }[task.metadata?.complexity || 'medium'];
-                const duration = baseDuration + Math.random() * baseDuration * 0.5;
-                return new Promise((resolve)=>{
-                    setTimeout(()=>{
-                        resolve({
-                            status: 'completed',
-                            result: `Task completed by ${worker.type} worker`,
-                            processingTime: Date.now() - startTime,
-                            complexity: task.metadata?.complexity || 'medium'
-                        });
-                    }, duration);
-                });
-            }, {
-                priority: task.priority
-            });
-            // Update task and worker
-            task.status = 'completed';
-            task.completedAt = new Date().toISOString();
-            task.result = result.result;
-            task.actualDuration = result.processingTime;
-            worker.status = 'idle';
-            worker.currentTask = null;
-            worker.tasksCompleted++;
-            // Update worker performance metrics
-            if (!worker.performance.avgTaskTime) {
-                worker.performance.avgTaskTime = result.processingTime;
-            } else {
-                worker.performance.avgTaskTime = (worker.performance.avgTaskTime * (worker.tasksCompleted - 1) + result.processingTime) / worker.tasksCompleted;
-            }
-            // Batch store results for better performance
-            await this.performanceOptimizer.optimizeBatchOperation('task_results', {
-                key: `result-${taskId}`,
-                value: task,
-                type: 'result'
-            }, async (items)=>{
-                // Batch store all results
-                await Promise.all(items.map((item)=>this.mcpWrapper.storeMemory(this.state.swarmId, item.key, item.value, item.type)));
-                return items.map(()=>({
-                        success: true
-                    }));
-            });
-            this.emit('task:completed', task);
-            this.emit('worker:idle', workerId);
-        } catch (error) {
-            // Handle task failure
-            task.status = 'failed';
-            task.error = error.message;
-            task.failedAt = new Date().toISOString();
-            worker.status = 'idle';
-            worker.currentTask = null;
-            worker.performance.successRate = worker.performance.successRate * worker.tasksCompleted / (worker.tasksCompleted + 1);
-            this.emit('task:failed', {
-                task,
-                error
-            });
-            this.emit('worker:idle', workerId);
-        }
+   */
+  async _executeTask(workerId, taskId) {
+    const worker = this.state.workers.get(workerId);
+    const task = this.state.tasks.get(taskId);
+    const startTime = Date.now();
+
+    try {
+      // Use performance optimizer for async execution
+      const result = await this.performanceOptimizer.optimizeAsyncOperation(
+        async () => {
+          // Simulate task execution based on complexity
+          const baseDuration = {
+            low: 5000,
+            medium: 15000,
+            high: 30000,
+          }[task.metadata?.complexity || 'medium'];
+
+          const duration = baseDuration + Math.random() * baseDuration * 0.5;
+
+          return new Promise((resolve) => {
+            setTimeout(() => {
+              resolve({
+                status: 'completed',
+                result: `Task completed by ${worker.type} worker`,
+                processingTime: Date.now() - startTime,
+                complexity: task.metadata?.complexity || 'medium',
+              });
+            }, duration);
+          });
+        },
+        { priority: task.priority },
+      );
+
+      // Update task and worker
+      task.status = 'completed';
+      task.completedAt = new Date().toISOString();
+      task.result = result.result;
+      task.actualDuration = result.processingTime;
+
+      worker.status = 'idle';
+      worker.currentTask = null;
+      worker.tasksCompleted++;
+
+      // Update worker performance metrics
+      if (!worker.performance.avgTaskTime) {
+        worker.performance.avgTaskTime = result.processingTime;
+      } else {
+        worker.performance.avgTaskTime =
+          (worker.performance.avgTaskTime * (worker.tasksCompleted - 1) + result.processingTime) /
+          worker.tasksCompleted;
+      }
+
+      // Batch store results for better performance
+      await this.performanceOptimizer.optimizeBatchOperation(
+        'task_results',
+        {
+          key: `result-${taskId}`,
+          value: task,
+          type: 'result',
+        },
+        async (items) => {
+          // Batch store all results
+          await Promise.all(
+            items.map((item) =>
+              this.mcpWrapper.storeMemory(this.state.swarmId, item.key, item.value, item.type),
+            ),
+          );
+          return items.map(() => ({ success: true }));
+        },
+      );
+
+      this.emit('task:completed', task);
+      this.emit('worker:idle', workerId);
+    } catch (error) {
+      // Handle task failure
+      task.status = 'failed';
+      task.error = error.message;
+      task.failedAt = new Date().toISOString();
+
+      worker.status = 'idle';
+      worker.currentTask = null;
+      worker.performance.successRate =
+        (worker.performance.successRate * worker.tasksCompleted) / (worker.tasksCompleted + 1);
+
+      this.emit('task:failed', { task, error });
+      this.emit('worker:idle', workerId);
     }
-    /**
+  }
+
+  /**
    * Assign next task to idle worker
-   */ _assignNextTask(workerId) {
-        const pendingTasks = Array.from(this.state.tasks.values()).filter((t)=>t.status === 'pending').sort((a, b)=>b.priority - a.priority);
-        if (pendingTasks.length > 0) {
-            this._assignTask(workerId, pendingTasks[0].id);
-        }
+   */
+  _assignNextTask(workerId) {
+    const pendingTasks = Array.from(this.state.tasks.values())
+      .filter((t) => t.status === 'pending')
+      .sort((a, b) => b.priority - a.priority);
+
+    if (pendingTasks.length > 0) {
+      this._assignTask(workerId, pendingTasks[0].id);
     }
-    /**
+  }
+
+  /**
    * Build consensus for decision
-   */ async buildConsensus(topic, options) {
-        const decision = {
-            id: `decision-${Date.now()}`,
-            swarmId: this.state.swarmId,
-            topic,
-            options,
-            votes: new Map(),
-            algorithm: this.config.consensusAlgorithm,
-            status: 'voting',
-            createdAt: new Date().toISOString()
+   */
+  async buildConsensus(topic, options) {
+    const decision = {
+      id: `decision-${Date.now()}`,
+      swarmId: this.state.swarmId,
+      topic,
+      options,
+      votes: new Map(),
+      algorithm: this.config.consensusAlgorithm,
+      status: 'voting',
+      createdAt: new Date().toISOString(),
+    };
+
+    this.state.decisions.set(decision.id, decision);
+
+    // Simulate voting process
+    const workers = Array.from(this.state.workers.values());
+    const votes = {};
+
+    // Each worker votes
+    workers.forEach((worker) => {
+      const vote = options[Math.floor(Math.random() * options.length)];
+      votes[worker.id] = vote;
+      decision.votes.set(worker.id, vote);
+    });
+
+    // Queen gets weighted vote
+    const queenVote = options[Math.floor(Math.random() * options.length)];
+    votes['queen'] = queenVote;
+    decision.votes.set('queen', queenVote);
+
+    // Calculate consensus
+    const result = this._calculateConsensus(decision);
+    decision.result = result.decision;
+    decision.confidence = result.confidence;
+    decision.status = 'completed';
+
+    // Convert Map to plain object for proper JSON serialization
+    const decisionForStorage = {
+      ...decision,
+      votes: decision.votes instanceof Map ? Object.fromEntries(decision.votes) : decision.votes,
+    };
+
+    // Store decision in memory
+    await this.mcpWrapper.storeMemory(
+      this.state.swarmId,
+      `decision-${decision.id}`,
+      decisionForStorage,
+      'consensus',
+    );
+
+    this.emit('decision:reached', decision);
+    return decision;
+  }
+
+  /**
+   * Calculate consensus based on algorithm
+   */
+  _calculateConsensus(decision) {
+    const votes = Array.from(decision.votes.values());
+    const voteCount = {};
+
+    // Count votes
+    votes.forEach((vote) => {
+      voteCount[vote] = (voteCount[vote] || 0) + 1;
+    });
+
+    switch (decision.algorithm) {
+      case 'majority':
+        // Simple majority
+        const sorted = Object.entries(voteCount).sort((a, b) => b[1] - a[1]);
+        const winner = sorted[0];
+        return {
+          decision: winner[0],
+          confidence: winner[1] / votes.length,
         };
-        this.state.decisions.set(decision.id, decision);
-        // Simulate voting process
-        const workers = Array.from(this.state.workers.values());
-        const votes = {};
-        // Each worker votes
-        workers.forEach((worker)=>{
-            const vote = options[Math.floor(Math.random() * options.length)];
-            votes[worker.id] = vote;
-            decision.votes.set(worker.id, vote);
-        });
-        // Queen gets weighted vote
-        const queenVote = options[Math.floor(Math.random() * options.length)];
-        votes['queen'] = queenVote;
-        decision.votes.set('queen', queenVote);
-        // Calculate consensus
-        const result = this._calculateConsensus(decision);
-        decision.result = result.decision;
-        decision.confidence = result.confidence;
-        decision.status = 'completed';
-        // Convert Map to plain object for proper JSON serialization
-        const decisionForStorage = {
-            ...decision,
-            votes: decision.votes instanceof Map ? Object.fromEntries(decision.votes) : decision.votes
+
+      case 'weighted':
+        // Weight queen vote more heavily
+        const queenVote = decision.votes.get('queen');
+        voteCount[queenVote] = (voteCount[queenVote] || 0) + 2; // Queen counts as 3 votes
+
+        const weightedSorted = Object.entries(voteCount).sort((a, b) => b[1] - a[1]);
+        const weightedWinner = weightedSorted[0];
+        return {
+          decision: weightedWinner[0],
+          confidence: weightedWinner[1] / (votes.length + 2),
         };
-        // Store decision in memory
-        await this.mcpWrapper.storeMemory(this.state.swarmId, `decision-${decision.id}`, decisionForStorage, 'consensus');
-        this.emit('decision:reached', decision);
-        return decision;
-    }
-    /**
-   * Calculate consensus based on algorithm
-   */ _calculateConsensus(decision) {
-        const votes = Array.from(decision.votes.values());
-        const voteCount = {};
-        // Count votes
-        votes.forEach((vote)=>{
-            voteCount[vote] = (voteCount[vote] || 0) + 1;
-        });
-        switch(decision.algorithm){
-            case 'majority':
-                // Simple majority
-                const sorted = Object.entries(voteCount).sort((a, b)=>b[1] - a[1]);
-                const winner = sorted[0];
-                return {
-                    decision: winner[0],
-                    confidence: winner[1] / votes.length
-                };
-            case 'weighted':
-                // Weight queen vote more heavily
-                const queenVote = decision.votes.get('queen');
-                voteCount[queenVote] = (voteCount[queenVote] || 0) + 2; // Queen counts as 3 votes
-                const weightedSorted = Object.entries(voteCount).sort((a, b)=>b[1] - a[1]);
-                const weightedWinner = weightedSorted[0];
-                return {
-                    decision: weightedWinner[0],
-                    confidence: weightedWinner[1] / (votes.length + 2)
-                };
-            case 'byzantine':
-                // Requires 2/3 majority
-                const byzantineSorted = Object.entries(voteCount).sort((a, b)=>b[1] - a[1]);
-                const byzantineWinner = byzantineSorted[0];
-                const byzantineConfidence = byzantineWinner[1] / votes.length;
-                if (byzantineConfidence >= 0.67) {
-                    return {
-                        decision: byzantineWinner[0],
-                        confidence: byzantineConfidence
-                    };
-                } else {
-                    return {
-                        decision: 'no_consensus',
-                        confidence: 0
-                    };
-                }
-            default:
-                return {
-                    decision: 'unknown',
-                    confidence: 0
-                };
+
+      case 'byzantine':
+        // Requires 2/3 majority
+        const byzantineSorted = Object.entries(voteCount).sort((a, b) => b[1] - a[1]);
+        const byzantineWinner = byzantineSorted[0];
+        const byzantineConfidence = byzantineWinner[1] / votes.length;
+
+        if (byzantineConfidence >= 0.67) {
+          return {
+            decision: byzantineWinner[0],
+            confidence: byzantineConfidence,
+          };
+        } else {
+          return {
+            decision: 'no_consensus',
+            confidence: 0,
+          };
         }
+
+      default:
+        return {
+          decision: 'unknown',
+          confidence: 0,
+        };
     }
-    /**
+  }
+
+  /**
    * Check if auto-scaling is needed
-   */ async _checkAutoScale() {
-        if (!this.config.autoScale) return;
-        const pendingTasks = Array.from(this.state.tasks.values()).filter((t)=>t.status === 'pending').length;
-        const idleWorkers = Array.from(this.state.workers.values()).filter((w)=>w.status === 'idle').length;
-        // Scale up if too many pending tasks
-        if (pendingTasks > idleWorkers * 2 && this.state.workers.size < this.config.maxWorkers) {
-            const newWorkerType = this._determineWorkerType();
-            await this.spawnWorkers([
-                newWorkerType
-            ]);
-            console.log(`Auto-scaled: Added ${newWorkerType} worker`);
-        }
-        // Scale down if too many idle workers
-        if (idleWorkers > pendingTasks + 2 && this.state.workers.size > 2) {
-        // TODO: Implement worker removal
-        }
+   */
+  async _checkAutoScale() {
+    if (!this.config.autoScale) return;
+
+    const pendingTasks = Array.from(this.state.tasks.values()).filter(
+      (t) => t.status === 'pending',
+    ).length;
+
+    const idleWorkers = Array.from(this.state.workers.values()).filter(
+      (w) => w.status === 'idle',
+    ).length;
+
+    // Scale up if too many pending tasks
+    if (pendingTasks > idleWorkers * 2 && this.state.workers.size < this.config.maxWorkers) {
+      const newWorkerType = this._determineWorkerType();
+      await this.spawnWorkers([newWorkerType]);
+      console.log(`Auto-scaled: Added ${newWorkerType} worker`);
     }
-    /**
-   * Determine worker type for auto-scaling
-   */ _determineWorkerType() {
-        // Analyze pending tasks to determine needed worker type
-        const pendingTasks = Array.from(this.state.tasks.values()).filter((t)=>t.status === 'pending');
-        // Simple heuristic based on task descriptions
-        const typeScores = {};
-        pendingTasks.forEach((task)=>{
-            const taskLower = task.description.toLowerCase();
-            if (taskLower.includes('code') || taskLower.includes('implement')) {
-                typeScores.coder = (typeScores.coder || 0) + 1;
-            }
-            if (taskLower.includes('test') || taskLower.includes('validate')) {
-                typeScores.tester = (typeScores.tester || 0) + 1;
-            }
-            if (taskLower.includes('analyze') || taskLower.includes('data')) {
-                typeScores.analyst = (typeScores.analyst || 0) + 1;
-            }
-            if (taskLower.includes('research') || taskLower.includes('investigate')) {
-                typeScores.researcher = (typeScores.researcher || 0) + 1;
-            }
-        });
-        // Return type with highest score
-        const sorted = Object.entries(typeScores).sort((a, b)=>b[1] - a[1]);
-        return sorted.length > 0 ? sorted[0][0] : 'coder'; // Default to coder
+
+    // Scale down if too many idle workers
+    if (idleWorkers > pendingTasks + 2 && this.state.workers.size > 2) {
+      // TODO: Implement worker removal
     }
-    /**
+  }
+
+  /**
+   * Determine worker type for auto-scaling
+   */
+  _determineWorkerType() {
+    // Analyze pending tasks to determine needed worker type
+    const pendingTasks = Array.from(this.state.tasks.values()).filter(
+      (t) => t.status === 'pending',
+    );
+
+    // Simple heuristic based on task descriptions
+    const typeScores = {};
+
+    pendingTasks.forEach((task) => {
+      const taskLower = task.description.toLowerCase();
+
+      if (taskLower.includes('code') || taskLower.includes('implement')) {
+        typeScores.coder = (typeScores.coder || 0) + 1;
+      }
+      if (taskLower.includes('test') || taskLower.includes('validate')) {
+        typeScores.tester = (typeScores.tester || 0) + 1;
+      }
+      if (taskLower.includes('analyze') || taskLower.includes('data')) {
+        typeScores.analyst = (typeScores.analyst || 0) + 1;
+      }
+      if (taskLower.includes('research') || taskLower.includes('investigate')) {
+        typeScores.researcher = (typeScores.researcher || 0) + 1;
+      }
+    });
+
+    // Return type with highest score
+    const sorted = Object.entries(typeScores).sort((a, b) => b[1] - a[1]);
+    return sorted.length > 0 ? sorted[0][0] : 'coder'; // Default to coder
+  }
+
+  /**
    * Update performance metrics
-   */ async _updatePerformanceMetrics() {
-        // Calculate performance metrics
-        const completionRate = this.state.metrics.tasksCompleted / this.state.metrics.tasksCreated;
-        const avgTasksPerWorker = this.state.metrics.tasksCompleted / this.state.workers.size;
-        // Store metrics in memory
-        await this.mcpWrapper.storeMemory(this.state.swarmId, 'metrics', {
-            ...this.state.metrics,
-            completionRate,
-            avgTasksPerWorker,
-            timestamp: Date.now()
-        }, 'metrics');
-        // Analyze performance if needed
-        if (this.state.metrics.tasksCompleted % 10 === 0) {
-            await this.mcpWrapper.analyzePerformance(this.state.swarmId);
-        }
+   */
+  async _updatePerformanceMetrics() {
+    // Calculate performance metrics
+    const completionRate = this.state.metrics.tasksCompleted / this.state.metrics.tasksCreated;
+    const avgTasksPerWorker = this.state.metrics.tasksCompleted / this.state.workers.size;
+
+    // Store metrics in memory
+    await this.mcpWrapper.storeMemory(
+      this.state.swarmId,
+      'metrics',
+      {
+        ...this.state.metrics,
+        completionRate,
+        avgTasksPerWorker,
+        timestamp: Date.now(),
+      },
+      'metrics',
+    );
+
+    // Analyze performance if needed
+    if (this.state.metrics.tasksCompleted % 10 === 0) {
+      await this.mcpWrapper.analyzePerformance(this.state.swarmId);
     }
-    /**
+  }
+
+  /**
    * Handle errors
-   */ _handleError(error) {
-        // Log error to memory
-        this.mcpWrapper.storeMemory(this.state.swarmId, `error-${Date.now()}`, {
-            message: error.message,
-            stack: error.stack,
-            timestamp: Date.now()
-        }, 'error').catch(console.error);
-    }
-    /**
+   */
+  _handleError(error) {
+    // Log error to memory
+    this.mcpWrapper
+      .storeMemory(
+        this.state.swarmId,
+        `error-${Date.now()}`,
+        {
+          message: error.message,
+          stack: error.stack,
+          timestamp: Date.now(),
+        },
+        'error',
+      )
+      .catch(console.error);
+  }
+
+  /**
    * Get current status with performance metrics
-   */ getStatus() {
-        const tasks = Array.from(this.state.tasks.values());
-        const workers = Array.from(this.state.workers.values());
-        return {
-            swarmId: this.state.swarmId,
-            status: this.state.status,
-            queen: this.state.queen,
-            workers: workers,
-            tasks: {
-                total: this.state.tasks.size,
-                pending: tasks.filter((t)=>t.status === 'pending').length,
-                inProgress: tasks.filter((t)=>t.status === 'in_progress').length,
-                completed: tasks.filter((t)=>t.status === 'completed').length,
-                failed: tasks.filter((t)=>t.status === 'failed').length
-            },
-            metrics: {
-                ...this.state.metrics,
-                averageTaskTime: this._calculateAverageTaskTime(tasks),
-                workerEfficiency: this._calculateWorkerEfficiency(workers),
-                throughput: this._calculateThroughput(tasks)
-            },
-            decisions: this.state.decisions.size,
-            performance: this.performanceOptimizer.getPerformanceStats()
-        };
-    }
-    /**
+   */
+  getStatus() {
+    const tasks = Array.from(this.state.tasks.values());
+    const workers = Array.from(this.state.workers.values());
+
+    return {
+      swarmId: this.state.swarmId,
+      status: this.state.status,
+      queen: this.state.queen,
+      workers: workers,
+      tasks: {
+        total: this.state.tasks.size,
+        pending: tasks.filter((t) => t.status === 'pending').length,
+        inProgress: tasks.filter((t) => t.status === 'in_progress').length,
+        completed: tasks.filter((t) => t.status === 'completed').length,
+        failed: tasks.filter((t) => t.status === 'failed').length,
+      },
+      metrics: {
+        ...this.state.metrics,
+        averageTaskTime: this._calculateAverageTaskTime(tasks),
+        workerEfficiency: this._calculateWorkerEfficiency(workers),
+        throughput: this._calculateThroughput(tasks),
+      },
+      decisions: this.state.decisions.size,
+      performance: this.performanceOptimizer.getPerformanceStats(),
+    };
+  }
+
+  /**
    * Calculate average task completion time
-   */ _calculateAverageTaskTime(tasks) {
-        const completedTasks = tasks.filter((t)=>t.status === 'completed' && t.actualDuration);
-        if (completedTasks.length === 0) return 0;
-        const totalTime = completedTasks.reduce((sum, task)=>sum + task.actualDuration, 0);
-        return Math.round(totalTime / completedTasks.length);
-    }
-    /**
+   */
+  _calculateAverageTaskTime(tasks) {
+    const completedTasks = tasks.filter((t) => t.status === 'completed' && t.actualDuration);
+    if (completedTasks.length === 0) return 0;
+
+    const totalTime = completedTasks.reduce((sum, task) => sum + task.actualDuration, 0);
+    return Math.round(totalTime / completedTasks.length);
+  }
+
+  /**
    * Calculate worker efficiency
-   */ _calculateWorkerEfficiency(workers) {
-        if (workers.length === 0) return 0;
-        const efficiencies = workers.map((worker)=>worker.performance?.successRate || 1.0);
-        return (efficiencies.reduce((sum, eff)=>sum + eff, 0) / workers.length * 100).toFixed(2);
-    }
-    /**
+   */
+  _calculateWorkerEfficiency(workers) {
+    if (workers.length === 0) return 0;
+
+    const efficiencies = workers.map((worker) => worker.performance?.successRate || 1.0);
+    return ((efficiencies.reduce((sum, eff) => sum + eff, 0) / workers.length) * 100).toFixed(2);
+  }
+
+  /**
    * Calculate system throughput (tasks per minute)
-   */ _calculateThroughput(tasks) {
-        const completedTasks = tasks.filter((t)=>t.status === 'completed' && t.completedAt);
-        if (completedTasks.length < 2) return 0;
-        const firstCompleted = new Date(completedTasks[0].completedAt).getTime();
-        const lastCompleted = new Date(completedTasks[completedTasks.length - 1].completedAt).getTime();
-        const timeSpanMinutes = (lastCompleted - firstCompleted) / (1000 * 60);
-        return timeSpanMinutes > 0 ? (completedTasks.length / timeSpanMinutes).toFixed(2) : 0;
-    }
-    /**
+   */
+  _calculateThroughput(tasks) {
+    const completedTasks = tasks.filter((t) => t.status === 'completed' && t.completedAt);
+    if (completedTasks.length < 2) return 0;
+
+    const firstCompleted = new Date(completedTasks[0].completedAt).getTime();
+    const lastCompleted = new Date(completedTasks[completedTasks.length - 1].completedAt).getTime();
+    const timeSpanMinutes = (lastCompleted - firstCompleted) / (1000 * 60);
+
+    return timeSpanMinutes > 0 ? (completedTasks.length / timeSpanMinutes).toFixed(2) : 0;
+  }
+
+  /**
    * Shutdown hive mind with cleanup
-   */ async shutdown() {
-        this.state.status = 'shutting_down';
-        try {
-            // Generate final performance report
-            const performanceReport = this.performanceOptimizer.generatePerformanceReport();
-            // Save final state and performance report
-            await Promise.all([
-                this.mcpWrapper.storeMemory(this.state.swarmId, 'final_state', this.getStatus(), 'system'),
-                this.mcpWrapper.storeMemory(this.state.swarmId, 'final_performance_report', performanceReport, 'metrics')
-            ]);
-            // Close performance optimizer
-            await this.performanceOptimizer.close();
-            // Destroy swarm
-            await this.mcpWrapper.destroySwarm(this.state.swarmId);
-            this.state.status = 'shutdown';
-            this.emit('shutdown', {
-                performanceReport
-            });
-        } catch (error) {
-            this.emit('error', {
-                type: 'shutdown_failed',
-                error
-            });
-            throw error;
-        }
+   */
+  async shutdown() {
+    this.state.status = 'shutting_down';
+
+    try {
+      // Generate final performance report
+      const performanceReport = this.performanceOptimizer.generatePerformanceReport();
+
+      // Save final state and performance report
+      await Promise.all([
+        this.mcpWrapper.storeMemory(this.state.swarmId, 'final_state', this.getStatus(), 'system'),
+        this.mcpWrapper.storeMemory(
+          this.state.swarmId,
+          'final_performance_report',
+          performanceReport,
+          'metrics',
+        ),
+      ]);
+
+      // Close performance optimizer
+      await this.performanceOptimizer.close();
+
+      // Destroy swarm
+      await this.mcpWrapper.destroySwarm(this.state.swarmId);
+
+      this.state.status = 'shutdown';
+      this.emit('shutdown', { performanceReport });
+    } catch (error) {
+      this.emit('error', { type: 'shutdown_failed', error });
+      throw error;
     }
-    /**
+  }
+
+  /**
    * Get performance insights and recommendations
-   */ getPerformanceInsights() {
-        return this.performanceOptimizer.generatePerformanceReport();
-    }
-    constructor(config = {}){
-        super();
-        this.config = {
-            objective: '',
-            name: `hive-${Date.now()}`,
-            queenType: 'strategic',
-            maxWorkers: 8,
-            consensusAlgorithm: 'majority',
-            autoScale: true,
-            encryption: false,
-            memorySize: 100,
-            taskTimeout: 60,
-            ...config
-        };
-        this.state = {
-            status: 'initializing',
-            swarmId: null,
-            queen: null,
-            workers: new Map(),
-            tasks: new Map(),
-            memory: new Map(),
-            decisions: new Map(),
-            metrics: {
-                tasksCreated: 0,
-                tasksCompleted: 0,
-                decisionsReached: 0,
-                memoryUsage: 0
-            }
-        };
-        this.mcpWrapper = new MCPToolWrapper({
-            parallel: true,
-            timeout: this.config.taskTimeout * 60 * 1000
-        });
-        // Initialize performance optimizer
-        this.performanceOptimizer = new PerformanceOptimizer({
-            enableAsyncQueue: true,
-            enableBatchProcessing: true,
-            enableAutoTuning: true,
-            asyncQueueConcurrency: Math.min(this.config.maxWorkers * 2, 20),
-            batchMaxSize: 50,
-            metricsInterval: 30000
-        });
-        this._initializeEventHandlers();
-        this._initializePerformanceMonitoring();
-    }
+   */
+  getPerformanceInsights() {
+    return this.performanceOptimizer.generatePerformanceReport();
+  }
 }