claude-flow-novice 2.0.3 → 2.0.4

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

@@ -1,1031 +1,959 @@
 /**
  * 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 {
-  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();
-  }
-
-  /**
+ */ export class HiveMindCore extends EventEmitter {
+    /**
    * 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);
+   */ _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})`);
         }
-      }, 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, // +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;
+   */ 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;
+        }
     }
-  }
-
-  /**
+    /**
    * 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
+   */ _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
     }
-
-    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;
-  }
-
-  /**
-   * 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,
-          },
+   */ 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
         };
-
-        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;
+        // 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;
+        }
     }
-  }
-
-  /**
+    /**
    * 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));
+   */ 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;
     }
-
-    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;
+   */ _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
     }
-
-    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;
-      }
+   */ _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';
     }
-
-    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',
-        );
-      });
+   */ 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];
     }
-
-    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;
-      }
+   */ _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];
     }
-
-    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);
-  }
-
-  /**
+   */ 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(),
-    };
-
-    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,
+   */ 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()
         };
-
-      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),
+        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 '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,
-          };
+        // 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
+                };
         }
-
-      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`);
+        }
+        // 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
-  }
-
-  /**
+   */ _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();
-  }
+   */ 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();
+    }
 }