claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.62

package/src/hive-mind/integration/SwarmOrchestrator.ts

@@ -1,7 +1,7 @@
 /**
  * SwarmOrchestrator Class
- * 
- * Orchestrates task distribution, agent coordination, and 
+ *
+ * Orchestrates task distribution, agent coordination, and
  * execution strategies within the Hive Mind swarm.
  */
 
@@ -15,7 +15,7 @@ import {
   TaskStrategy,
   ExecutionPlan,
   OrchestrationResult,
-  TaskAssignment
+  TaskAssignment,
 } from '../types.js';
 
 export class SwarmOrchestrator extends EventEmitter {
@@ -42,12 +42,12 @@ export class SwarmOrchestrator extends EventEmitter {
     this.db = await DatabaseManager.getInstance();
     this.mcpWrapper = new MCPToolWrapper();
     await this.mcpWrapper.initialize();
-    
+
     // Start orchestration loops
     this.startTaskDistributor();
     this.startProgressMonitor();
     this.startLoadBalancer();
-    
+
     this.isActive = true;
     this.emit('initialized');
   }
@@ -59,15 +59,15 @@ export class SwarmOrchestrator extends EventEmitter {
     // Create execution plan based on strategy
     const plan = await this.createExecutionPlan(task);
     this.executionPlans.set(task.id, plan);
-    
+
     // Orchestrate task using MCP tools
     const orchestrationResult = await this.mcpWrapper.orchestrateTask({
       task: task.description,
       priority: task.priority,
       strategy: task.strategy,
-      dependencies: task.dependencies
+      dependencies: task.dependencies,
     });
-    
+
     if (orchestrationResult.success) {
       // Start task execution
       await this.executeTask(task, plan);
@@ -81,18 +81,18 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   private async createExecutionPlan(task: Task): Promise<ExecutionPlan> {
     const strategy = this.getStrategyImplementation(task.strategy);
-    
+
     // Analyze task complexity
     const analysis = await this.analyzeTaskComplexity(task);
-    
+
     // Determine phases based on strategy and complexity
     const phases = strategy.determinePhases(task, analysis);
-    
+
     // Create assignments for each phase
     const phaseAssignments = await Promise.all(
-      phases.map(phase => this.createPhaseAssignments(task, phase, analysis))
+      phases.map((phase) => this.createPhaseAssignments(task, phase, analysis)),
     );
-    
+
     return {
       taskId: task.id,
       strategy: task.strategy,
@@ -102,7 +102,7 @@ export class SwarmOrchestrator extends EventEmitter {
       checkpoints: this.createCheckpoints(phases),
       parallelizable: strategy.isParallelizable(task),
       estimatedDuration: analysis.estimatedDuration,
-      resourceRequirements: analysis.resourceRequirements
+      resourceRequirements: analysis.resourceRequirements,
     };
   }
 
@@ -116,11 +116,11 @@ export class SwarmOrchestrator extends EventEmitter {
       startTime: Date.now(),
       currentPhase: 0,
       phaseResults: [],
-      status: 'executing'
+      status: 'executing',
     };
-    
+
     this.activeExecutions.set(task.id, execution);
-    
+
     try {
       // Execute phases according to strategy
       if (plan.parallelizable) {
@@ -128,11 +128,10 @@ export class SwarmOrchestrator extends EventEmitter {
       } else {
         await this.executeSequential(task, plan, execution);
       }
-      
+
       // Mark task as completed
       execution.status = 'completed';
       await this.completeTask(task, execution);
-      
     } catch (error) {
       execution.status = 'failed';
       execution.error = error;
@@ -146,16 +145,14 @@ export class SwarmOrchestrator extends EventEmitter {
    * Execute phases in parallel
    */
   private async executeParallel(task: Task, plan: ExecutionPlan, execution: any): Promise<void> {
-    const parallelPhases = plan.phases.filter((_, index) => 
-      plan.phaseAssignments[index].some(a => a.canRunParallel)
+    const parallelPhases = plan.phases.filter((_, index) =>
+      plan.phaseAssignments[index].some((a) => a.canRunParallel),
     );
-    
+
     const results = await Promise.all(
-      parallelPhases.map(phase => 
-        this.executePhase(task, phase, plan, execution)
-      )
+      parallelPhases.map((phase) => this.executePhase(task, phase, plan, execution)),
     );
-    
+
     execution.phaseResults = results;
   }
 
@@ -166,10 +163,10 @@ export class SwarmOrchestrator extends EventEmitter {
     for (let i = 0; i < plan.phases.length; i++) {
       const phase = plan.phases[i];
       execution.currentPhase = i;
-      
+
       const result = await this.executePhase(task, phase, plan, execution);
       execution.phaseResults.push(result);
-      
+
       // Check checkpoint
       if (plan.checkpoints[i]) {
         await this.evaluateCheckpoint(task, plan.checkpoints[i], execution);
@@ -181,24 +178,22 @@ export class SwarmOrchestrator extends EventEmitter {
    * Execute a single phase
    */
   private async executePhase(
-    task: Task, 
-    phase: string, 
-    plan: ExecutionPlan, 
-    execution: any
+    task: Task,
+    phase: string,
+    plan: ExecutionPlan,
+    execution: any,
   ): Promise<any> {
     const phaseIndex = plan.phases.indexOf(phase);
     const assignments = plan.phaseAssignments[phaseIndex];
-    
+
     // Assign agents to phase tasks
     const agentAssignments = await this.assignAgentsToPhase(task, phase, assignments);
-    
+
     // Execute phase tasks
     const phaseResults = await Promise.all(
-      agentAssignments.map(assignment => 
-        this.executeAssignment(task, phase, assignment)
-      )
+      agentAssignments.map((assignment) => this.executeAssignment(task, phase, assignment)),
     );
-    
+
     // Aggregate phase results
     return this.aggregatePhaseResults(phase, phaseResults);
   }
@@ -209,48 +204,44 @@ export class SwarmOrchestrator extends EventEmitter {
   private async assignAgentsToPhase(
     task: Task,
     phase: string,
-    assignments: TaskAssignment[]
+    assignments: TaskAssignment[],
   ): Promise<any[]> {
     const agentAssignments = [];
-    
+
     for (const assignment of assignments) {
       // Find suitable agent
       const agent = await this.findSuitableAgent(assignment.requiredCapabilities);
-      
+
       if (agent) {
         await this.assignTaskToAgent(task.id, agent.id);
         agentAssignments.push({
           agent,
           assignment,
-          phase
+          phase,
         });
       } else {
         // Queue for later assignment
         this.queueAssignment(task.id, assignment);
       }
     }
-    
+
     return agentAssignments;
   }
 
   /**
    * Execute a specific assignment
    */
-  private async executeAssignment(
-    task: Task,
-    phase: string,
-    assignment: any
-  ): Promise<any> {
+  private async executeAssignment(task: Task, phase: string, assignment: any): Promise<any> {
     const { agent, assignment: taskAssignment } = assignment;
-    
+
     // Send execution command to agent
     await agent.assignTask(task.id, {
       phase,
       role: taskAssignment.role,
       responsibilities: taskAssignment.responsibilities,
-      expectedOutput: taskAssignment.expectedOutput
+      expectedOutput: taskAssignment.expectedOutput,
     });
-    
+
     // Wait for completion or timeout
     return this.waitForAgentCompletion(agent, task.id, taskAssignment.timeout);
   }
@@ -262,21 +253,21 @@ export class SwarmOrchestrator extends EventEmitter {
     // Update database
     const task = await this.db.getTask(taskId);
     const assignedAgents = JSON.parse(task.assigned_agents || '[]');
-    
+
     if (!assignedAgents.includes(agentId)) {
       assignedAgents.push(agentId);
       await this.db.updateTask(taskId, {
         assigned_agents: JSON.stringify(assignedAgents),
-        status: 'assigned'
+        status: 'assigned',
       });
     }
-    
+
     // Update agent
     await this.db.updateAgent(agentId, {
       current_task_id: taskId,
-      status: 'busy'
+      status: 'busy',
     });
-    
+
     this.emit('taskAssigned', { taskId, agentId });
   }
 
@@ -285,22 +276,22 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   async cancelTask(taskId: string): Promise<void> {
     const execution = this.activeExecutions.get(taskId);
-    
+
     if (execution) {
       execution.status = 'cancelled';
-      
+
       // Notify assigned agents
       const task = await this.db.getTask(taskId);
       const assignedAgents = JSON.parse(task.assigned_agents || '[]');
-      
+
       for (const agentId of assignedAgents) {
         await this.notifyAgentTaskCancelled(agentId, taskId);
       }
     }
-    
+
     this.activeExecutions.delete(taskId);
     this.executionPlans.delete(taskId);
-    
+
     this.emit('taskCancelled', { taskId });
   }
 
@@ -310,16 +301,16 @@ export class SwarmOrchestrator extends EventEmitter {
   async rebalance(): Promise<void> {
     // Get current load distribution
     const loadDistribution = await this.analyzeLoadDistribution();
-    
+
     // Use MCP tool for load balancing
     const balanceResult = await this.mcpWrapper.loadBalance({
-      tasks: loadDistribution.unassignedTasks
+      tasks: loadDistribution.unassignedTasks,
     });
-    
+
     if (balanceResult.success && balanceResult.data.reassignments) {
       await this.applyReassignments(balanceResult.data.reassignments);
     }
-    
+
     this.emit('rebalanced', { loadDistribution });
   }
 
@@ -331,12 +322,12 @@ export class SwarmOrchestrator extends EventEmitter {
       parallel: {
         determinePhases: (task: Task) => ['preparation', 'parallel-execution', 'aggregation'],
         isParallelizable: () => true,
-        maxConcurrency: 5
+        maxConcurrency: 5,
       },
       sequential: {
         determinePhases: (task: Task) => ['analysis', 'planning', 'execution', 'validation'],
         isParallelizable: () => false,
-        maxConcurrency: 1
+        maxConcurrency: 1,
       },
       adaptive: {
         determinePhases: (task: Task, analysis: any) => {
@@ -346,15 +337,15 @@ export class SwarmOrchestrator extends EventEmitter {
           return ['quick-analysis', 'execution', 'validation'];
         },
         isParallelizable: (task: Task) => !task.requireConsensus,
-        maxConcurrency: 3
+        maxConcurrency: 3,
       },
       consensus: {
         determinePhases: () => ['proposal', 'discussion', 'voting', 'execution', 'ratification'],
         isParallelizable: () => false,
-        maxConcurrency: 1
-      }
+        maxConcurrency: 1,
+      },
     };
-    
+
     return strategies[strategy] || strategies.adaptive;
   }
 
@@ -369,18 +360,18 @@ export class SwarmOrchestrator extends EventEmitter {
         description: task.description,
         priority: task.priority,
         dependencies: task.dependencies.length,
-        requiresConsensus: task.requireConsensus
-      }
+        requiresConsensus: task.requireConsensus,
+      },
     });
-    
+
     return {
       complexity: analysis.data?.complexity || 'medium',
       estimatedDuration: analysis.data?.estimatedDuration || 3600000,
       resourceRequirements: analysis.data?.resourceRequirements || {
         minAgents: 1,
         maxAgents: task.maxAgents,
-        capabilities: task.requiredCapabilities
-      }
+        capabilities: task.requiredCapabilities,
+      },
     };
   }
 
@@ -390,10 +381,10 @@ export class SwarmOrchestrator extends EventEmitter {
   private async createPhaseAssignments(
     task: Task,
     phase: string,
-    analysis: any
+    analysis: any,
   ): Promise<TaskAssignment[]> {
     const assignments: TaskAssignment[] = [];
-    
+
     // Define assignments based on phase
     switch (phase) {
       case 'analysis':
@@ -404,10 +395,10 @@ export class SwarmOrchestrator extends EventEmitter {
           responsibilities: ['Analyze task requirements', 'Identify patterns', 'Assess complexity'],
           expectedOutput: 'Analysis report',
           timeout: 300000, // 5 minutes
-          canRunParallel: false
+          canRunParallel: false,
         });
         break;
-        
+
       case 'planning':
         assignments.push({
           role: 'architect',
@@ -415,10 +406,10 @@ export class SwarmOrchestrator extends EventEmitter {
           responsibilities: ['Design solution', 'Create implementation plan', 'Define interfaces'],
           expectedOutput: 'Implementation plan',
           timeout: 600000, // 10 minutes
-          canRunParallel: false
+          canRunParallel: false,
         });
         break;
-        
+
       case 'execution':
       case 'parallel-execution':
         // Multiple execution assignments based on complexity
@@ -430,11 +421,11 @@ export class SwarmOrchestrator extends EventEmitter {
             responsibilities: ['Implement solution', 'Execute plan', 'Handle errors'],
             expectedOutput: 'Execution results',
             timeout: 1800000, // 30 minutes
-            canRunParallel: true
+            canRunParallel: true,
           });
         }
         break;
-        
+
       case 'validation':
         assignments.push({
           role: 'validator',
@@ -442,10 +433,10 @@ export class SwarmOrchestrator extends EventEmitter {
           responsibilities: ['Validate results', 'Run tests', 'Ensure quality'],
           expectedOutput: 'Validation report',
           timeout: 600000, // 10 minutes
-          canRunParallel: false
+          canRunParallel: false,
         });
         break;
-        
+
       case 'consensus':
       case 'voting':
         assignments.push({
@@ -454,11 +445,11 @@ export class SwarmOrchestrator extends EventEmitter {
           responsibilities: ['Coordinate voting', 'Collect opinions', 'Determine consensus'],
           expectedOutput: 'Consensus decision',
           timeout: 300000, // 5 minutes
-          canRunParallel: false
+          canRunParallel: false,
         });
         break;
     }
-    
+
     return assignments;
   }
 
@@ -469,9 +460,9 @@ export class SwarmOrchestrator extends EventEmitter {
     return phases.map((phase, index) => ({
       phase,
       index,
-      requiredProgress: Math.round((index + 1) / phases.length * 100),
+      requiredProgress: Math.round(((index + 1) / phases.length) * 100),
       validationCriteria: this.getValidationCriteria(phase),
-      failureThreshold: 0.3
+      failureThreshold: 0.3,
     }));
   }
 
@@ -482,22 +473,22 @@ export class SwarmOrchestrator extends EventEmitter {
     const criteria: Record<string, any[]> = {
       analysis: [
         { name: 'completeness', weight: 0.4 },
-        { name: 'accuracy', weight: 0.6 }
+        { name: 'accuracy', weight: 0.6 },
       ],
       planning: [
         { name: 'feasibility', weight: 0.5 },
-        { name: 'completeness', weight: 0.5 }
+        { name: 'completeness', weight: 0.5 },
       ],
       execution: [
         { name: 'correctness', weight: 0.7 },
-        { name: 'performance', weight: 0.3 }
+        { name: 'performance', weight: 0.3 },
       ],
       validation: [
         { name: 'test_coverage', weight: 0.5 },
-        { name: 'quality_score', weight: 0.5 }
-      ]
+        { name: 'quality_score', weight: 0.5 },
+      ],
     };
-    
+
     return criteria[phase] || [{ name: 'completion', weight: 1.0 }];
   }
 
@@ -506,17 +497,18 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   private async findSuitableAgent(requiredCapabilities: string[]): Promise<Agent | null> {
     const agents = await this.hiveMind.getAgents();
-    
+
     // Filter available agents with required capabilities
-    const suitableAgents = agents.filter(agent => 
-      agent.status === 'idle' &&
-      requiredCapabilities.every(cap => agent.capabilities.includes(cap))
+    const suitableAgents = agents.filter(
+      (agent) =>
+        agent.status === 'idle' &&
+        requiredCapabilities.every((cap) => agent.capabilities.includes(cap)),
     );
-    
+
     if (suitableAgents.length === 0) {
       return null;
     }
-    
+
     // Select best agent based on performance history
     return this.selectBestAgent(suitableAgents, requiredCapabilities);
   }
@@ -527,15 +519,15 @@ export class SwarmOrchestrator extends EventEmitter {
   private async selectBestAgent(agents: Agent[], capabilities: string[]): Promise<Agent> {
     // Simple selection - in production would use performance metrics
     const scores = await Promise.all(
-      agents.map(async agent => {
+      agents.map(async (agent) => {
         const performance = await this.db.getAgentPerformance(agent.id);
         return {
           agent,
-          score: performance?.successRate || 0.5
+          score: performance?.successRate || 0.5,
         };
-      })
+      }),
     );
-    
+
     scores.sort((a, b) => b.score - a.score);
     return scores[0].agent;
   }
@@ -546,26 +538,26 @@ export class SwarmOrchestrator extends EventEmitter {
   private async waitForAgentCompletion(
     agent: Agent,
     taskId: string,
-    timeout: number
+    timeout: number,
   ): Promise<any> {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`Agent ${agent.id} timeout on task ${taskId}`));
       }, timeout);
-      
+
       const checkCompletion = async () => {
         const agentState = await this.db.getAgent(agent.id);
-        
+
         if (agentState.current_task_id !== taskId) {
           clearTimeout(timer);
           clearInterval(interval);
-          
+
           // Get task result
           const task = await this.db.getTask(taskId);
           resolve(task.result ? JSON.parse(task.result) : {});
         }
       };
-      
+
       const interval = setInterval(checkCompletion, 1000);
     });
   }
@@ -578,7 +570,7 @@ export class SwarmOrchestrator extends EventEmitter {
       phase,
       results,
       summary: this.summarizeResults(results),
-      timestamp: new Date()
+      timestamp: new Date(),
     };
   }
 
@@ -586,13 +578,13 @@ export class SwarmOrchestrator extends EventEmitter {
    * Summarize phase results
    */
   private summarizeResults(results: any[]): any {
-    const successful = results.filter(r => r.success).length;
+    const successful = results.filter((r) => r.success).length;
     const total = results.length;
-    
+
     return {
       successRate: total > 0 ? successful / total : 0,
       totalExecutions: total,
-      aggregatedData: results.map(r => r.data).filter(Boolean)
+      aggregatedData: results.map((r) => r.data).filter(Boolean),
     };
   }
 
@@ -603,7 +595,7 @@ export class SwarmOrchestrator extends EventEmitter {
     if (!this.taskAssignments.has(taskId)) {
       this.taskAssignments.set(taskId, []);
     }
-    
+
     this.taskAssignments.get(taskId)!.push(assignment);
     this.emit('assignmentQueued', { taskId, assignment });
   }
@@ -613,19 +605,19 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   private async evaluateCheckpoint(task: Task, checkpoint: any, execution: any): Promise<void> {
     const phaseResult = execution.phaseResults[checkpoint.index];
-    
+
     if (!phaseResult) return;
-    
+
     let score = 0;
     for (const criterion of checkpoint.validationCriteria) {
       const criterionScore = this.evaluateCriterion(phaseResult, criterion);
       score += criterionScore * criterion.weight;
     }
-    
+
     if (score < checkpoint.failureThreshold) {
       throw new Error(`Checkpoint failed at phase ${checkpoint.phase}: score ${score}`);
     }
-    
+
     this.emit('checkpointPassed', { task, checkpoint, score });
   }
 
@@ -648,16 +640,16 @@ export class SwarmOrchestrator extends EventEmitter {
       success: true,
       executionTime: Date.now() - execution.startTime,
       phases: execution.phaseResults,
-      summary: this.createExecutionSummary(execution)
+      summary: this.createExecutionSummary(execution),
     };
-    
+
     await this.db.updateTask(task.id, {
       status: 'completed',
       result: JSON.stringify(finalResult),
       progress: 100,
-      completed_at: new Date()
+      completed_at: new Date(),
     });
-    
+
     this.emit('taskCompleted', { task, result: finalResult });
   }
 
@@ -668,9 +660,9 @@ export class SwarmOrchestrator extends EventEmitter {
     await this.db.updateTask(task.id, {
       status: 'failed',
       error: error.message,
-      completed_at: new Date()
+      completed_at: new Date(),
     });
-    
+
     this.emit('taskFailed', { task, error });
   }
 
@@ -679,13 +671,15 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   private createExecutionSummary(execution: any): any {
     const phaseCount = execution.phaseResults.length;
-    const successfulPhases = execution.phaseResults.filter(r => r.summary?.successRate > 0.5).length;
-    
+    const successfulPhases = execution.phaseResults.filter(
+      (r) => r.summary?.successRate > 0.5,
+    ).length;
+
     return {
       totalPhases: phaseCount,
       successfulPhases,
       overallSuccess: phaseCount > 0 ? successfulPhases / phaseCount : 0,
-      executionTime: Date.now() - execution.startTime
+      executionTime: Date.now() - execution.startTime,
     };
   }
 
@@ -700,7 +694,7 @@ export class SwarmOrchestrator extends EventEmitter {
       swarm_id: this.hiveMind.id,
       message_type: 'task_cancellation',
       content: JSON.stringify({ taskId, reason: 'User cancelled' }),
-      priority: 'urgent'
+      priority: 'urgent',
     });
   }
 
@@ -710,22 +704,24 @@ export class SwarmOrchestrator extends EventEmitter {
   private async analyzeLoadDistribution(): Promise<any> {
     const agents = await this.hiveMind.getAgents();
     const tasks = await this.db.getActiveTasks(this.hiveMind.id);
-    
-    const busyAgents = agents.filter(a => a.status === 'busy');
-    const idleAgents = agents.filter(a => a.status === 'idle');
-    const unassignedTasks = tasks.filter(t => !t.assigned_agents || JSON.parse(t.assigned_agents).length === 0);
-    
+
+    const busyAgents = agents.filter((a) => a.status === 'busy');
+    const idleAgents = agents.filter((a) => a.status === 'idle');
+    const unassignedTasks = tasks.filter(
+      (t) => !t.assigned_agents || JSON.parse(t.assigned_agents).length === 0,
+    );
+
     return {
       totalAgents: agents.length,
       busyAgents: busyAgents.length,
       idleAgents: idleAgents.length,
       activeTasks: tasks.length,
-      unassignedTasks: unassignedTasks.map(t => ({
+      unassignedTasks: unassignedTasks.map((t) => ({
         id: t.id,
         priority: t.priority,
-        requiredCapabilities: JSON.parse(t.required_capabilities || '[]')
+        requiredCapabilities: JSON.parse(t.required_capabilities || '[]'),
       })),
-      loadFactor: agents.length > 0 ? busyAgents.length / agents.length : 0
+      loadFactor: agents.length > 0 ? busyAgents.length / agents.length : 0,
     };
   }
 
@@ -741,21 +737,25 @@ export class SwarmOrchestrator extends EventEmitter {
   /**
    * Reassign task from one agent to another
    */
-  private async reassignTask(taskId: string, fromAgentId: string, toAgentId: string): Promise<void> {
+  private async reassignTask(
+    taskId: string,
+    fromAgentId: string,
+    toAgentId: string,
+  ): Promise<void> {
     // Update task assignment
     await this.db.reassignTask(taskId, toAgentId);
-    
+
     // Update agent states
     await this.db.updateAgent(fromAgentId, {
       current_task_id: null,
-      status: 'idle'
+      status: 'idle',
     });
-    
+
     await this.db.updateAgent(toAgentId, {
       current_task_id: taskId,
-      status: 'busy'
+      status: 'busy',
     });
-    
+
     // Notify agents
     await this.notifyAgentReassignment(fromAgentId, toAgentId, taskId);
   }
@@ -763,7 +763,11 @@ export class SwarmOrchestrator extends EventEmitter {
   /**
    * Notify agents of reassignment
    */
-  private async notifyAgentReassignment(fromAgentId: string, toAgentId: string, taskId: string): Promise<void> {
+  private async notifyAgentReassignment(
+    fromAgentId: string,
+    toAgentId: string,
+    taskId: string,
+  ): Promise<void> {
     // Notify source agent
     await this.db.createCommunication({
       from_agent_id: 'orchestrator',
@@ -771,24 +775,24 @@ export class SwarmOrchestrator extends EventEmitter {
       swarm_id: this.hiveMind.id,
       message_type: 'task_reassignment',
       content: JSON.stringify({ taskId, reassignedTo: toAgentId }),
-      priority: 'high'
+      priority: 'high',
     });
-    
+
     // Notify target agent
     const task = await this.db.getTask(taskId);
     const plan = this.executionPlans.get(taskId);
-    
+
     await this.db.createCommunication({
       from_agent_id: 'orchestrator',
       to_agent_id: toAgentId,
       swarm_id: this.hiveMind.id,
       message_type: 'task_assignment',
-      content: JSON.stringify({ 
-        taskId, 
+      content: JSON.stringify({
+        taskId,
         task: task.description,
-        executionPlan: plan 
+        executionPlan: plan,
       }),
-      priority: 'high'
+      priority: 'high',
     });
   }
 
@@ -798,7 +802,7 @@ export class SwarmOrchestrator extends EventEmitter {
   private startTaskDistributor(): void {
     setInterval(async () => {
       if (!this.isActive) return;
-      
+
       try {
         // Check for queued assignments
         for (const [taskId, assignments] of this.taskAssignments) {
@@ -807,7 +811,7 @@ export class SwarmOrchestrator extends EventEmitter {
             if (agent) {
               await this.assignTaskToAgent(taskId, agent.id);
               // Remove from queue
-              const remaining = assignments.filter(a => a !== assignment);
+              const remaining = assignments.filter((a) => a !== assignment);
               if (remaining.length === 0) {
                 this.taskAssignments.delete(taskId);
               } else {
@@ -828,15 +832,15 @@ export class SwarmOrchestrator extends EventEmitter {
   private startProgressMonitor(): void {
     setInterval(async () => {
       if (!this.isActive) return;
-      
+
       try {
         // Monitor active executions
         for (const [taskId, execution] of this.activeExecutions) {
           const task = await this.db.getTask(taskId);
-          
+
           if (task.status === 'in_progress') {
             const progress = this.calculateProgress(execution);
-            
+
             if (progress !== task.progress) {
               await this.db.updateTask(taskId, { progress });
               this.emit('progressUpdate', { taskId, progress });
@@ -855,12 +859,16 @@ export class SwarmOrchestrator extends EventEmitter {
   private startLoadBalancer(): void {
     setInterval(async () => {
       if (!this.isActive) return;
-      
+
       try {
         const load = await this.analyzeLoadDistribution();
-        
+
         // Trigger rebalancing if needed
-        if (load.loadFactor > 0.8 && load.idleAgents.length > 0 && load.unassignedTasks.length > 0) {
+        if (
+          load.loadFactor > 0.8 &&
+          load.idleAgents.length > 0 &&
+          load.unassignedTasks.length > 0
+        ) {
           await this.rebalance();
         }
       } catch (error) {
@@ -874,10 +882,10 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   private calculateProgress(execution: any): number {
     if (!execution.plan || !execution.plan.phases) return 0;
-    
+
     const totalPhases = execution.plan.phases.length;
     const completedPhases = execution.currentPhase;
-    
+
     return Math.round((completedPhases / totalPhases) * 100);
   }
 
@@ -886,12 +894,12 @@ export class SwarmOrchestrator extends EventEmitter {
    */
   async shutdown(): Promise<void> {
     this.isActive = false;
-    
+
     // Cancel all active executions
     for (const taskId of this.activeExecutions.keys()) {
       await this.cancelTask(taskId);
     }
-    
+
     this.emit('shutdown');
   }
-}
+}