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

package/src/agents/agent-manager.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Comprehensive agent management system
  */
@@ -7,18 +6,16 @@ import { EventEmitter } from 'node:events';
 import { spawn, ChildProcess } from 'node:child_process';
 import type { ILogger } from '../core/logger.js';
 import type { IEventBus } from '../core/event-bus.js';
-import type { 
-  AgentId, 
-  AgentType, 
-  AgentStatus, 
-  AgentState, 
-  AgentCapabilities, 
-  AgentConfig, 
-  AgentEnvironment, 
+import type {
+  AgentId,
+  AgentType,
+  AgentStatus,
+  AgentState,
+  AgentCapabilities,
+  AgentConfig,
+  AgentEnvironment,
   AgentMetrics,
   AgentError,
-  TaskId,
-  TaskDefinition
 } from '../swarm/types.js';
 import type { DistributedMemorySystem } from '../memory/distributed-memory.js';
 import { generateId } from '../utils/helpers.js';
@@ -155,7 +152,7 @@ export class AgentManager extends EventEmitter {
     config: Partial<AgentManagerConfig>,
     logger: ILogger,
     eventBus: IEventBus,
-    memory: DistributedMemorySystem
+    memory: DistributedMemorySystem,
   ) {
     super();
     this.logger = logger;
@@ -171,20 +168,20 @@ export class AgentManager extends EventEmitter {
       resourceLimits: {
         memory: 512 * 1024 * 1024, // 512MB
         cpu: 1.0,
-        disk: 1024 * 1024 * 1024 // 1GB
+        disk: 1024 * 1024 * 1024, // 1GB
       },
       agentDefaults: {
         autonomyLevel: 0.7,
         learningEnabled: true,
-        adaptationEnabled: true
+        adaptationEnabled: true,
       },
       environmentDefaults: {
         runtime: 'deno',
         workingDirectory: './agents',
         tempDirectory: './tmp',
-        logDirectory: './logs'
+        logDirectory: './logs',
       },
-      ...config
+      ...config,
     };
 
     this.setupEventHandlers();
@@ -216,7 +213,10 @@ export class AgentManager extends EventEmitter {
     });
 
     this.eventBus.on('resource:usage', (data: unknown) => {
-      const resourceData = data as { agentId: string; usage: { cpu: number; memory: number; disk: number } };
+      const resourceData = data as {
+        agentId: string;
+        usage: { cpu: number; memory: number; disk: number };
+      };
       this.updateResourceUsage(resourceData.agentId, resourceData.usage);
     });
   }
@@ -246,7 +246,7 @@ export class AgentManager extends EventEmitter {
         maxExecutionTime: 600000,
         reliability: 0.9,
         speed: 0.8,
-        quality: 0.9
+        quality: 0.9,
       },
       config: {
         autonomyLevel: 0.8,
@@ -260,7 +260,7 @@ export class AgentManager extends EventEmitter {
         permissions: ['web-access', 'file-read'],
         trustedAgents: [],
         expertise: { research: 0.9, analysis: 0.8, documentation: 0.7 },
-        preferences: { verbose: true, detailed: true }
+        preferences: { verbose: true, detailed: true },
       },
       environment: {
         runtime: 'deno',
@@ -271,9 +271,9 @@ export class AgentManager extends EventEmitter {
         apiEndpoints: {},
         credentials: {},
         availableTools: ['web-search', 'document-reader', 'data-extractor'],
-        toolConfigs: {}
+        toolConfigs: {},
       },
-      startupScript: './scripts/start-researcher.ts'
+      startupScript: './scripts/start-researcher.ts',
     });
 
     // Developer agent template
@@ -300,7 +300,7 @@ export class AgentManager extends EventEmitter {
         maxExecutionTime: 1200000,
         reliability: 0.95,
         speed: 0.7,
-        quality: 0.95
+        quality: 0.95,
       },
       config: {
         autonomyLevel: 0.6,
@@ -314,7 +314,7 @@ export class AgentManager extends EventEmitter {
         permissions: ['file-read', 'file-write', 'terminal-access', 'git-access'],
         trustedAgents: [],
         expertise: { coding: 0.95, testing: 0.8, debugging: 0.9 },
-        preferences: { codeStyle: 'functional', testFramework: 'deno-test' }
+        preferences: { codeStyle: 'functional', testFramework: 'deno-test' },
       },
       environment: {
         runtime: 'deno',
@@ -325,9 +325,9 @@ export class AgentManager extends EventEmitter {
         apiEndpoints: {},
         credentials: {},
         availableTools: ['git', 'deno', 'editor', 'debugger'],
-        toolConfigs: {}
+        toolConfigs: {},
       },
-      startupScript: './scripts/start-developer.ts'
+      startupScript: './scripts/start-developer.ts',
     });
 
     // Add more templates...
@@ -359,7 +359,7 @@ export class AgentManager extends EventEmitter {
         maxExecutionTime: 900000,
         reliability: 0.9,
         speed: 0.75,
-        quality: 0.9
+        quality: 0.9,
       },
       config: {
         autonomyLevel: 0.7,
@@ -373,7 +373,7 @@ export class AgentManager extends EventEmitter {
         permissions: ['file-read', 'data-access'],
         trustedAgents: [],
         expertise: { analysis: 0.95, visualization: 0.8, statistics: 0.85 },
-        preferences: { outputFormat: 'detailed', includeCharts: true }
+        preferences: { outputFormat: 'detailed', includeCharts: true },
       },
       environment: {
         runtime: 'deno',
@@ -384,16 +384,16 @@ export class AgentManager extends EventEmitter {
         apiEndpoints: {},
         credentials: {},
         availableTools: ['data-processor', 'chart-gen', 'stats-calc'],
-        toolConfigs: {}
+        toolConfigs: {},
       },
-      startupScript: './scripts/start-analyzer.ts'
+      startupScript: './scripts/start-analyzer.ts',
     });
   }
 
   async initialize(): Promise<void> {
     this.logger.info('Initializing agent manager', {
       maxAgents: this.config.maxAgents,
-      templates: this.templates.size
+      templates: this.templates.size,
     });
 
     // Start health monitoring
@@ -416,8 +416,8 @@ export class AgentManager extends EventEmitter {
     if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
 
     // Gracefully shutdown all agents
-    const shutdownPromises = Array.from(this.agents.keys()).map(agentId =>
-      this.stopAgent(agentId, 'shutdown')
+    const shutdownPromises = Array.from(this.agents.keys()).map((agentId) =>
+      this.stopAgent(agentId, 'shutdown'),
     );
 
     await Promise.all(shutdownPromises);
@@ -433,7 +433,7 @@ export class AgentManager extends EventEmitter {
       name?: string;
       config?: Partial<AgentConfig>;
       environment?: Partial<AgentEnvironment>;
-    } = {}
+    } = {},
   ): Promise<string> {
     if (this.agents.size >= this.config.maxAgents) {
       throw new Error('Maximum agent limit reached');
@@ -458,8 +458,10 @@ export class AgentManager extends EventEmitter {
       health: 1.0,
       config: {
         autonomyLevel: template.config.autonomyLevel ?? this.config.agentDefaults.autonomyLevel,
-        learningEnabled: template.config.learningEnabled ?? this.config.agentDefaults.learningEnabled,
-        adaptationEnabled: template.config.adaptationEnabled ?? this.config.agentDefaults.adaptationEnabled,
+        learningEnabled:
+          template.config.learningEnabled ?? this.config.agentDefaults.learningEnabled,
+        adaptationEnabled:
+          template.config.adaptationEnabled ?? this.config.agentDefaults.adaptationEnabled,
         maxTasksPerHour: template.config.maxTasksPerHour ?? 10,
         maxConcurrentTasks: template.config.maxConcurrentTasks ?? 3,
         timeoutThreshold: template.config.timeoutThreshold ?? 300000,
@@ -469,26 +471,29 @@ export class AgentManager extends EventEmitter {
         trustedAgents: template.config.trustedAgents ?? [],
         expertise: template.config.expertise ?? {},
         preferences: template.config.preferences ?? {},
-        ...overrides.config
+        ...overrides.config,
       },
       environment: {
         runtime: template.environment.runtime ?? this.config.environmentDefaults.runtime,
         version: template.environment.version ?? '1.40.0',
-        workingDirectory: template.environment.workingDirectory ?? this.config.environmentDefaults.workingDirectory,
-        tempDirectory: template.environment.tempDirectory ?? this.config.environmentDefaults.tempDirectory,
-        logDirectory: template.environment.logDirectory ?? this.config.environmentDefaults.logDirectory,
+        workingDirectory:
+          template.environment.workingDirectory ?? this.config.environmentDefaults.workingDirectory,
+        tempDirectory:
+          template.environment.tempDirectory ?? this.config.environmentDefaults.tempDirectory,
+        logDirectory:
+          template.environment.logDirectory ?? this.config.environmentDefaults.logDirectory,
         apiEndpoints: template.environment.apiEndpoints ?? {},
         credentials: template.environment.credentials ?? {},
         availableTools: template.environment.availableTools ?? [],
         toolConfigs: template.environment.toolConfigs ?? {},
-        ...overrides.environment
+        ...overrides.environment,
       },
       endpoints: [],
       lastHeartbeat: new Date(),
       taskHistory: [],
       errorHistory: [],
       childAgents: [],
-      collaborators: []
+      collaborators: [],
     };
 
     this.agents.set(agentId, agent);
@@ -498,7 +503,7 @@ export class AgentManager extends EventEmitter {
       agentId,
       name: agent.name,
       type: agent.type,
-      template: templateName
+      template: templateName,
     });
 
     this.emit('agent:created', { agent });
@@ -507,7 +512,7 @@ export class AgentManager extends EventEmitter {
     await this.memory.store(`agent:${agentId}`, agent, {
       type: 'agent-state',
       tags: [agent.type, 'active'],
-      partition: 'state'
+      partition: 'state',
     });
 
     return agentId;
@@ -539,7 +544,6 @@ export class AgentManager extends EventEmitter {
 
       this.logger.info('Started agent', { agentId, name: agent.name });
       this.emit('agent:started', { agent });
-
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       agent.status = 'error';
@@ -549,7 +553,7 @@ export class AgentManager extends EventEmitter {
         message: errorMessage,
         context: { agentId },
         severity: 'critical',
-        resolved: false
+        resolved: false,
       });
 
       this.logger.error('Failed to start agent', { agentId, error });
@@ -595,7 +599,6 @@ export class AgentManager extends EventEmitter {
 
       this.logger.info('Stopped agent', { agentId, reason });
       this.emit('agent:stopped', { agent, reason });
-
     } catch (error) {
       this.logger.error('Failed to stop agent gracefully', { agentId, error });
       // Force cleanup
@@ -651,7 +654,7 @@ export class AgentManager extends EventEmitter {
       autoScale?: boolean;
       scaleUpThreshold?: number;
       scaleDownThreshold?: number;
-    }
+    },
   ): Promise<string> {
     const template = this.templates.get(templateName);
     if (!template) {
@@ -671,7 +674,7 @@ export class AgentManager extends EventEmitter {
       template,
       autoScale: config.autoScale || false,
       scaleUpThreshold: config.scaleUpThreshold || 0.8,
-      scaleDownThreshold: config.scaleDownThreshold || 0.3
+      scaleDownThreshold: config.scaleDownThreshold || 0.3,
     };
 
     this.pools.set(poolId, pool);
@@ -679,10 +682,15 @@ export class AgentManager extends EventEmitter {
     // Create minimum agents
     for (let i = 0; i < config.minSize; i++) {
       const agentId = await this.createAgent(templateName, {
-        name: `${name}-${i + 1}`
+        name: `${name}-${i + 1}`,
       });
       await this.startAgent(agentId);
-      pool.availableAgents.push({ id: agentId, swarmId: 'default', type: template.type, instance: i + 1 });
+      pool.availableAgents.push({
+        id: agentId,
+        swarmId: 'default',
+        type: template.type,
+        instance: i + 1,
+      });
       pool.currentSize++;
     }
 
@@ -699,7 +707,9 @@ export class AgentManager extends EventEmitter {
     }
 
     if (targetSize < pool.minSize || targetSize > pool.maxSize) {
-      throw new Error(`Target size ${targetSize} outside pool limits [${pool.minSize}, ${pool.maxSize}]`);
+      throw new Error(
+        `Target size ${targetSize} outside pool limits [${pool.minSize}, ${pool.maxSize}]`,
+      );
     }
 
     const currentSize = pool.currentSize;
@@ -709,14 +719,14 @@ export class AgentManager extends EventEmitter {
       // Scale up
       for (let i = 0; i < delta; i++) {
         const agentId = await this.createAgent(pool.template.name, {
-          name: `${pool.name}-${currentSize + i + 1}`
+          name: `${pool.name}-${currentSize + i + 1}`,
         });
         await this.startAgent(agentId);
-        pool.availableAgents.push({ 
-          id: agentId, 
-          swarmId: 'default', 
-          type: pool.type, 
-          instance: currentSize + i + 1 
+        pool.availableAgents.push({
+          id: agentId,
+          swarmId: 'default',
+          type: pool.type,
+          instance: currentSize + i + 1,
         });
       }
     } else if (delta < 0) {
@@ -724,7 +734,7 @@ export class AgentManager extends EventEmitter {
       const agentsToRemove = pool.availableAgents.slice(0, Math.abs(delta));
       for (const agentId of agentsToRemove) {
         await this.removeAgent(agentId.id);
-        pool.availableAgents = pool.availableAgents.filter(a => a.id !== agentId.id);
+        pool.availableAgents = pool.availableAgents.filter((a) => a.id !== agentId.id);
       }
     }
 
@@ -741,8 +751,8 @@ export class AgentManager extends EventEmitter {
       this.performHealthChecks();
     }, this.config.healthCheckInterval);
 
-    this.logger.info('Started health monitoring', { 
-      interval: this.config.healthCheckInterval 
+    this.logger.info('Started health monitoring', {
+      interval: this.config.healthCheckInterval,
     });
   }
 
@@ -751,14 +761,14 @@ export class AgentManager extends EventEmitter {
       this.checkHeartbeats();
     }, this.config.heartbeatInterval);
 
-    this.logger.info('Started heartbeat monitoring', { 
-      interval: this.config.heartbeatInterval 
+    this.logger.info('Started heartbeat monitoring', {
+      interval: this.config.heartbeatInterval,
     });
   }
 
   private async performHealthChecks(): Promise<void> {
-    const healthPromises = Array.from(this.agents.keys()).map(agentId =>
-      this.checkAgentHealth(agentId)
+    const healthPromises = Array.from(this.agents.keys()).map((agentId) =>
+      this.checkAgentHealth(agentId),
     );
 
     await Promise.allSettled(healthPromises);
@@ -768,7 +778,8 @@ export class AgentManager extends EventEmitter {
     const agent = this.agents.get(agentId);
     if (!agent) return;
 
-    const health = this.healthChecks.get(agentId)!;
+    const health = this.healthChecks.get(agentId);
+    if (!health) return;
     const now = new Date();
 
     try {
@@ -804,7 +815,6 @@ export class AgentManager extends EventEmitter {
         this.logger.warn('Agent critically unhealthy, restarting', { agentId, health: overall });
         await this.restartAgent(agentId, 'health_critical');
       }
-
     } catch (error) {
       this.logger.error('Health check failed', { agentId, error });
       health.overall = 0;
@@ -814,14 +824,14 @@ export class AgentManager extends EventEmitter {
 
   private async checkResponsiveness(agentId: string): Promise<number> {
     // Send ping and measure response time
-    const startTime = Date.now();
-    
+
     try {
       // This would send an actual ping to the agent
       // For now, simulate based on last heartbeat
-      const agent = this.agents.get(agentId)!;
+      const agent = this.agents.get(agentId);
+      if (!agent) return 0;
       const timeSinceHeartbeat = Date.now() - agent.lastHeartbeat.getTime();
-      
+
       if (timeSinceHeartbeat > this.config.heartbeatInterval * 3) {
         return 0; // Unresponsive
       } else if (timeSinceHeartbeat > this.config.heartbeatInterval * 2) {
@@ -829,7 +839,6 @@ export class AgentManager extends EventEmitter {
       } else {
         return 1.0; // Responsive
       }
-      
     } catch (error) {
       return 0; // Failed to respond
     }
@@ -841,19 +850,21 @@ export class AgentManager extends EventEmitter {
 
     // Calculate average task completion time vs expected
     const recent = history.slice(-10); // Last 10 entries
-    const avgTime = recent.reduce((sum, entry) => sum + entry.metrics.averageExecutionTime, 0) / recent.length;
-    
+    const avgTime =
+      recent.reduce((sum, entry) => sum + entry.metrics.averageExecutionTime, 0) / recent.length;
+
     // Normalize based on expected performance (simplified)
     const expectedTime = 60000; // 1 minute baseline
     return Math.max(0, Math.min(1, expectedTime / avgTime));
   }
 
   private calculateReliabilityScore(agentId: string): number {
-    const agent = this.agents.get(agentId)!;
+    const agent = this.agents.get(agentId);
+    if (!agent) return 0;
     const totalTasks = agent.metrics.tasksCompleted + agent.metrics.tasksFailed;
-    
+
     if (totalTasks === 0) return 1.0;
-    
+
     return agent.metrics.tasksCompleted / totalTasks;
   }
 
@@ -862,9 +873,9 @@ export class AgentManager extends EventEmitter {
     if (!usage) return 1.0;
 
     const limits = this.config.resourceLimits;
-    const memoryScore = 1 - (usage.memory / limits.memory);
-    const cpuScore = 1 - (usage.cpu / limits.cpu);
-    const diskScore = 1 - (usage.disk / limits.disk);
+    const memoryScore = 1 - usage.memory / limits.memory;
+    const cpuScore = 1 - usage.cpu / limits.cpu;
+    const diskScore = 1 - usage.disk / limits.disk;
 
     return Math.max(0, (memoryScore + cpuScore + diskScore) / 3);
   }
@@ -879,7 +890,7 @@ export class AgentManager extends EventEmitter {
         message: 'Agent is not responding to heartbeats',
         timestamp: new Date(),
         resolved: false,
-        recommendedAction: 'Restart agent or check network connectivity'
+        recommendedAction: 'Restart agent or check network connectivity',
       });
     }
 
@@ -890,7 +901,7 @@ export class AgentManager extends EventEmitter {
         message: 'Agent performance is below expected levels',
         timestamp: new Date(),
         resolved: false,
-        recommendedAction: 'Check resource allocation or agent configuration'
+        recommendedAction: 'Check resource allocation or agent configuration',
       });
     }
 
@@ -901,7 +912,7 @@ export class AgentManager extends EventEmitter {
         message: 'Agent resource usage is critically high',
         timestamp: new Date(),
         resolved: false,
-        recommendedAction: 'Increase resource limits or reduce workload'
+        recommendedAction: 'Increase resource limits or reduce workload',
       });
     }
 
@@ -914,10 +925,14 @@ export class AgentManager extends EventEmitter {
 
     for (const [agentId, agent] of Array.from(this.agents.entries())) {
       const timeSinceHeartbeat = now - agent.lastHeartbeat.getTime();
-      
-      if (timeSinceHeartbeat > timeout && agent.status !== 'offline' && agent.status !== 'terminated') {
+
+      if (
+        timeSinceHeartbeat > timeout &&
+        agent.status !== 'offline' &&
+        agent.status !== 'terminated'
+      ) {
         this.logger.warn('Agent heartbeat timeout', { agentId, timeSinceHeartbeat });
-        
+
         agent.status = 'error';
         this.addAgentError(agentId, {
           timestamp: new Date(),
@@ -925,14 +940,14 @@ export class AgentManager extends EventEmitter {
           message: 'Agent failed to send heartbeat within timeout period',
           context: { timeout, timeSinceHeartbeat },
           severity: 'high',
-          resolved: false
+          resolved: false,
         });
 
         this.emit('agent:heartbeat-timeout', { agentId, timeSinceHeartbeat });
 
         // Auto-restart if enabled
         if (this.config.autoRestart) {
-          this.restartAgent(agentId, 'heartbeat_timeout').catch(error => {
+          this.restartAgent(agentId, 'heartbeat_timeout').catch((error) => {
             this.logger.error('Failed to auto-restart agent', { agentId, error });
           });
         }
@@ -949,7 +964,7 @@ export class AgentManager extends EventEmitter {
       AGENT_TYPE: agent.type,
       AGENT_NAME: agent.name,
       WORKING_DIR: agent.environment.workingDirectory,
-      LOG_DIR: agent.environment.logDirectory
+      LOG_DIR: agent.environment.logDirectory,
     };
 
     const args = [
@@ -957,13 +972,13 @@ export class AgentManager extends EventEmitter {
       '--allow-all',
       agent.environment.availableTools[0] || './agents/generic-agent.ts',
       '--config',
-      JSON.stringify(agent.config)
+      JSON.stringify(agent.config),
     ];
 
     const childProcess = spawn(agent.environment.runtime, args, {
       env,
       stdio: ['pipe', 'pipe', 'pipe'],
-      cwd: agent.environment.workingDirectory
+      cwd: agent.environment.workingDirectory,
     });
 
     // Handle process events
@@ -1029,7 +1044,7 @@ export class AgentManager extends EventEmitter {
         message: `Agent process exited with code ${code}`,
         context: { exitCode: code },
         severity: 'high',
-        resolved: false
+        resolved: false,
       });
     }
 
@@ -1039,25 +1054,29 @@ export class AgentManager extends EventEmitter {
 
   private handleProcessError(agentId: string, error: Error): void {
     this.logger.error('Agent process error', { agentId, error });
-    
+
     this.addAgentError(agentId, {
       timestamp: new Date(),
       type: 'process_error',
-      message: (error instanceof Error ? error.message : String(error)),
+      message: error instanceof Error ? error.message : String(error),
       context: { error: error.toString() },
       severity: 'critical',
-      resolved: false
+      resolved: false,
     });
 
     this.emit('agent:process-error', { agentId, error });
   }
 
-  private handleHeartbeat(data: { agentId: string; timestamp: Date; metrics?: AgentMetrics }): void {
+  private handleHeartbeat(data: {
+    agentId: string;
+    timestamp: Date;
+    metrics?: AgentMetrics;
+  }): void {
     const agent = this.agents.get(data.agentId);
     if (!agent) return;
 
     agent.lastHeartbeat = data.timestamp;
-    
+
     if (data.metrics) {
       this.updateAgentMetrics(data.agentId, data.metrics);
     }
@@ -1071,7 +1090,7 @@ export class AgentManager extends EventEmitter {
 
   private handleAgentError(data: { agentId: string; error: AgentError }): void {
     this.addAgentError(data.agentId, data.error);
-    
+
     const agent = this.agents.get(data.agentId);
     if (agent && data.error.severity === 'critical') {
       agent.status = 'error';
@@ -1105,16 +1124,19 @@ export class AgentManager extends EventEmitter {
     // Store performance history
     const history = this.performanceHistory.get(agentId) || [];
     history.push({ timestamp: new Date(), metrics: { ...metrics } });
-    
+
     // Keep only last 100 entries
     if (history.length > 100) {
       history.shift();
     }
-    
+
     this.performanceHistory.set(agentId, history);
   }
 
-  private updateResourceUsage(agentId: string, usage: { cpu: number; memory: number; disk: number }): void {
+  private updateResourceUsage(
+    agentId: string,
+    usage: { cpu: number; memory: number; disk: number },
+  ): void {
     this.resourceUsage.set(agentId, usage);
   }
 
@@ -1146,7 +1168,7 @@ export class AgentManager extends EventEmitter {
       userSatisfaction: 0.8,
       totalUptime: 0,
       lastActivity: new Date(),
-      responseTime: 0
+      responseTime: 0,
     };
   }
 
@@ -1158,25 +1180,25 @@ export class AgentManager extends EventEmitter {
         responsiveness: 1.0,
         performance: 1.0,
         reliability: 1.0,
-        resourceUsage: 1.0
+        resourceUsage: 1.0,
       },
       issues: [],
       lastCheck: new Date(),
-      trend: 'stable'
+      trend: 'stable',
     };
   }
 
   private removeAgentFromPoolsAndClusters(agentId: string): void {
     // Remove from pools
     for (const pool of Array.from(this.pools.values())) {
-      pool.availableAgents = pool.availableAgents.filter(a => a.id !== agentId);
-      pool.busyAgents = pool.busyAgents.filter(a => a.id !== agentId);
+      pool.availableAgents = pool.availableAgents.filter((a) => a.id !== agentId);
+      pool.busyAgents = pool.busyAgents.filter((a) => a.id !== agentId);
       pool.currentSize = pool.availableAgents.length + pool.busyAgents.length;
     }
 
     // Remove from clusters
     for (const cluster of Array.from(this.clusters.values())) {
-      cluster.agents = cluster.agents.filter(a => a.id !== agentId);
+      cluster.agents = cluster.agents.filter((a) => a.id !== agentId);
     }
   }
 
@@ -1193,16 +1215,16 @@ export class AgentManager extends EventEmitter {
           threshold: 0.8,
           comparison: 'gt',
           action: 'scale-up',
-          amount: 1
+          amount: 1,
         },
         {
           metric: 'pool-utilization',
           threshold: 0.3,
           comparison: 'lt',
           action: 'scale-down',
-          amount: 1
-        }
-      ]
+          amount: 1,
+        },
+      ],
     };
 
     this.scalingPolicies.set('default', defaultPolicy);
@@ -1219,11 +1241,11 @@ export class AgentManager extends EventEmitter {
   }
 
   getAgentsByType(type: AgentType): AgentState[] {
-    return Array.from(this.agents.values()).filter(agent => agent.type === type);
+    return Array.from(this.agents.values()).filter((agent) => agent.type === type);
   }
 
   getAgentsByStatus(status: AgentStatus): AgentState[] {
-    return Array.from(this.agents.values()).filter(agent => agent.status === status);
+    return Array.from(this.agents.values()).filter((agent) => agent.status === status);
   }
 
   getAgentHealth(agentId: string): AgentHealth | undefined {
@@ -1253,18 +1275,20 @@ export class AgentManager extends EventEmitter {
   } {
     const agents = Array.from(this.agents.values());
     const healthChecks = Array.from(this.healthChecks.values());
-    
-    const healthyAgents = healthChecks.filter(h => h.overall > 0.7).length;
-    const averageHealth = healthChecks.reduce((sum, h) => sum + h.overall, 0) / healthChecks.length || 1;
-    
+
+    const healthyAgents = healthChecks.filter((h) => h.overall > 0.7).length;
+    const averageHealth =
+      healthChecks.reduce((sum, h) => sum + h.overall, 0) / healthChecks.length || 1;
+
     const resourceUsages = Array.from(this.resourceUsage.values());
     const avgCpu = resourceUsages.reduce((sum, r) => sum + r.cpu, 0) / resourceUsages.length || 0;
-    const avgMemory = resourceUsages.reduce((sum, r) => sum + r.memory, 0) / resourceUsages.length || 0;
+    const avgMemory =
+      resourceUsages.reduce((sum, r) => sum + r.memory, 0) / resourceUsages.length || 0;
     const avgDisk = resourceUsages.reduce((sum, r) => sum + r.disk, 0) / resourceUsages.length || 0;
 
     return {
       totalAgents: agents.length,
-      activeAgents: agents.filter(a => a.status === 'idle' || a.status === 'busy').length,
+      activeAgents: agents.filter((a) => a.status === 'idle' || a.status === 'busy').length,
       healthyAgents,
       pools: this.pools.size,
       clusters: this.clusters.size,
@@ -1272,8 +1296,8 @@ export class AgentManager extends EventEmitter {
       resourceUtilization: {
         cpu: avgCpu,
         memory: avgMemory,
-        disk: avgDisk
-      }
+        disk: avgDisk,
+      },
     };
   }
-}
+}