claude-flow 2.0.0-alpha.7 → 2.0.0-alpha.70

package/src/swarm/coordinator.ts

@@ -1,78 +1,98 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 import { EventEmitter } from 'events';
 import { promises as fs } from 'node:fs';
 import { Logger } from '../core/logger.js';
 import { generateId } from '../utils/helpers.js';
 import {
-  SwarmId, AgentId, TaskId, AgentState, TaskDefinition, SwarmObjective,
-  SwarmConfig, SwarmStatus, SwarmProgress, SwarmResults, SwarmMetrics,
-  SwarmMode, SwarmStrategy, AgentType, TaskType, TaskStatus, TaskPriority,
-  SwarmEvent, EventType, SwarmEventEmitter, ValidationResult,
-  SWARM_CONSTANTS
+  SwarmId,
+  AgentId,
+  TaskId,
+  AgentState,
+  TaskDefinition,
+  SwarmObjective,
+  SwarmConfig,
+  SwarmStatus,
+  SwarmProgress,
+  SwarmResults,
+  SwarmMetrics,
+  SwarmMode,
+  SwarmStrategy,
+  AgentType,
+  TaskType,
+  TaskStatus,
+  TaskPriority,
+  SwarmEvent,
+  EventType,
+  SwarmEventEmitter,
+  ValidationResult,
+  SWARM_CONSTANTS,
 } from './types.js';
 import { AutoStrategy } from './strategies/auto.js';
 import { getClaudeFlowRoot, getClaudeFlowBin } from '../utils/paths.js';
+import { SwarmJsonOutputAggregator } from './json-output-aggregator.js';
 
 export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter {
   private logger: Logger;
   private config: SwarmConfig;
   private swarmId: SwarmId;
-  
+
   // Core state management
   private agents: Map<string, AgentState> = new Map();
   private tasks: Map<string, TaskDefinition> = new Map();
   private objectives: Map<string, SwarmObjective> = new Map();
-  
+
   // Execution state
   private _isRunning: boolean = false;
   private status: SwarmStatus = 'planning';
   private startTime?: Date;
   private endTime?: Date;
-  
+
   // Performance tracking
   private metrics: SwarmMetrics;
   private events: SwarmEvent[] = [];
   private lastHeartbeat: Date = new Date();
-  
+
+  // JSON output aggregation (optional)
+  private jsonOutputAggregator?: SwarmJsonOutputAggregator;
+
   // Background processes
   private heartbeatTimer?: NodeJS.Timeout;
   private monitoringTimer?: NodeJS.Timeout;
   private cleanupTimer?: NodeJS.Timeout;
   private executionIntervals?: Map<string, NodeJS.Timeout>;
-  
+
   // Strategy instances
   private autoStrategy: AutoStrategy;
-  
+
   constructor(config: Partial<SwarmConfig> = {}) {
     super();
-    
+
     // Configure logger based on config or default to quiet mode
     const logLevel = (config as any).logging?.level || 'error';
     const logFormat = (config as any).logging?.format || 'text';
     const logDestination = (config as any).logging?.destination || 'console';
-    
+
     this.logger = new Logger(
       { level: logLevel, format: logFormat, destination: logDestination },
-      { component: 'SwarmCoordinator' }
+      { component: 'SwarmCoordinator' },
     );
     this.swarmId = this.generateSwarmId();
-    
+
     // Initialize configuration with defaults
     this.config = this.mergeWithDefaults(config);
-    
+
     // Initialize metrics
     this.metrics = this.initializeMetrics();
-    
+
     // Initialize strategy instances
     this.autoStrategy = new AutoStrategy(config);
-    
+
     // Setup event handlers
     this.setupEventHandlers();
-    
-    this.logger.info('SwarmCoordinator initialized', { 
+
+    this.logger.info('SwarmCoordinator initialized', {
       swarmId: this.swarmId.id,
       mode: this.config.mode,
-      strategy: this.config.strategy 
+      strategy: this.config.strategy,
     });
   }
 
@@ -85,24 +105,26 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
     this.logger.info('Initializing swarm coordinator...');
     this.status = 'initializing';
-    
+
     try {
       // Validate configuration
       const validation = await this.validateConfiguration();
       if (!validation.valid) {
-        throw new Error(`Configuration validation failed: ${validation.errors.map(e => e.message).join(', ')}`);
+        throw new Error(
+          `Configuration validation failed: ${validation.errors.map((e) => e.message).join(', ')}`,
+        );
       }
 
       // Initialize subsystems
       await this.initializeSubsystems();
-      
+
       // Start background processes
       this.startBackgroundProcesses();
-      
+
       this._isRunning = true;
       this.startTime = new Date();
       this.status = 'executing';
-      
+
       this.emitSwarmEvent({
         id: generateId('event'),
         timestamp: new Date(),
@@ -110,11 +132,10 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         source: this.swarmId.id,
         data: { swarmId: this.swarmId },
         broadcast: true,
-        processed: false
+        processed: false,
       });
-      
+
       this.logger.info('Swarm coordinator initialized successfully');
-      
     } catch (error) {
       this.status = 'failed';
       this.logger.error('Failed to initialize swarm coordinator', { error });
@@ -129,40 +150,39 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
     this.logger.info('Shutting down swarm coordinator...');
     this.status = 'paused';
-    
+
     try {
       // Stop background processes
       this.stopBackgroundProcesses();
-      
+
       // Gracefully stop all agents
       await this.stopAllAgents();
-      
+
       // Complete any running tasks
       await this.completeRunningTasks();
-      
+
       // Save final state
       await this.saveState();
-      
+
       this._isRunning = false;
       this.endTime = new Date();
       this.status = 'completed';
-      
+
       this.emitSwarmEvent({
         id: generateId('event'),
         timestamp: new Date(),
         type: 'swarm.completed',
         source: this.swarmId.id,
-        data: { 
+        data: {
           swarmId: this.swarmId,
           metrics: this.metrics,
-          duration: this.endTime.getTime() - (this.startTime?.getTime() || 0)
+          duration: this.endTime.getTime() - (this.startTime?.getTime() || 0),
         },
         broadcast: true,
-        processed: false
+        processed: false,
       });
-      
+
       this.logger.info('Swarm coordinator shut down successfully');
-      
     } catch (error) {
       this.logger.error('Error during swarm coordinator shutdown', { error });
       throw error;
@@ -176,14 +196,14 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
     this.logger.info('Pausing swarm coordinator...');
     this.status = 'paused';
-    
+
     // Pause all agents
     for (const agent of this.agents.values()) {
       if (agent.status === 'busy') {
         await this.pauseAgent(agent.id);
       }
     }
-    
+
     this.emitSwarmEvent({
       id: generateId('event'),
       timestamp: new Date(),
@@ -191,7 +211,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: this.swarmId.id,
       data: { swarmId: this.swarmId },
       broadcast: true,
-      processed: false
+      processed: false,
     });
   }
 
@@ -202,14 +222,14 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
     this.logger.info('Resuming swarm coordinator...');
     this.status = 'executing';
-    
+
     // Resume all paused agents
     for (const agent of this.agents.values()) {
       if (agent.status === 'paused') {
         await this.resumeAgent(agent.id);
       }
     }
-    
+
     this.emitSwarmEvent({
       id: generateId('event'),
       timestamp: new Date(),
@@ -217,7 +237,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: this.swarmId.id,
       data: { swarmId: this.swarmId },
       broadcast: true,
-      processed: false
+      processed: false,
     });
   }
 
@@ -227,10 +247,10 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     name: string,
     description: string,
     strategy: SwarmStrategy = 'auto',
-    requirements: Partial<SwarmObjective['requirements']> = {}
+    requirements: Partial<SwarmObjective['requirements']> = {},
   ): Promise<string> {
     const objectiveId = generateId('objective');
-    
+
     const objective: SwarmObjective = {
       id: objectiveId,
       name,
@@ -242,45 +262,47 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         maxAgents: this.config.maxAgents,
         agentTypes: this.determineRequiredAgentTypes(strategy),
         estimatedDuration: 60 * 60 * 1000, // 1 hour default
-        maxDuration: 4 * 60 * 60 * 1000,   // 4 hours default
+        maxDuration: 4 * 60 * 60 * 1000, // 4 hours default
         qualityThreshold: this.config.qualityThreshold,
         reviewCoverage: 0.8,
         testCoverage: 0.7,
         reliabilityTarget: 0.95,
-        ...requirements
+        ...requirements,
       },
       constraints: {
         minQuality: this.config.qualityThreshold,
         requiredApprovals: [],
         allowedFailures: Math.floor(this.config.maxAgents * 0.1),
         recoveryTime: 5 * 60 * 1000, // 5 minutes
-        milestones: []
+        milestones: [],
       },
       tasks: [],
       dependencies: [],
       status: 'planning',
       progress: this.initializeProgress(),
       createdAt: new Date(),
-      metrics: this.initializeMetrics()
+      metrics: this.initializeMetrics(),
     };
 
     // Decompose objective into tasks using optimized AUTO strategy
     if (objective.strategy === 'auto') {
       const decompositionResult = await this.autoStrategy.decomposeObjective(objective);
       objective.tasks = decompositionResult.tasks;
-      objective.dependencies = this.convertDependenciesToTaskDependencies(decompositionResult.dependencies);
+      objective.dependencies = this.convertDependenciesToTaskDependencies(
+        decompositionResult.dependencies,
+      );
     } else {
       objective.tasks = await this.decomposeObjective(objective);
       objective.dependencies = this.analyzeDependencies(objective.tasks);
     }
-    
+
     this.objectives.set(objectiveId, objective);
-    
-    this.logger.info('Created objective', { 
-      objectiveId, 
-      name, 
-      strategy, 
-      taskCount: objective.tasks.length 
+
+    this.logger.info('Created objective', {
+      objectiveId,
+      name,
+      strategy,
+      taskCount: objective.tasks.length,
     });
 
     return objectiveId;
@@ -303,13 +325,12 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     try {
       // Ensure we have required agents
       await this.ensureRequiredAgents(objective);
-      
+
       // Schedule initial tasks
       await this.scheduleInitialTasks(objective);
-      
+
       // Start task execution loop
       this.startTaskExecutionLoop(objective);
-      
     } catch (error) {
       objective.status = 'failed';
       this.logger.error('Failed to execute objective', { objectiveId, error });
@@ -322,13 +343,13 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
   async registerAgent(
     name: string,
     type: AgentType,
-    capabilities: Partial<AgentState['capabilities']> = {}
+    capabilities: Partial<AgentState['capabilities']> = {},
   ): Promise<string> {
     const agentId: AgentId = {
       id: generateId('agent'),
       swarmId: this.swarmId.id,
       type,
-      instance: this.getNextInstanceNumber(type)
+      instance: this.getNextInstanceNumber(type),
     };
 
     const agentState: AgentState = {
@@ -358,7 +379,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         reliability: 0.8,
         speed: 1.0,
         quality: 0.8,
-        ...capabilities
+        ...capabilities,
       },
       metrics: {
         tasksCompleted: 0,
@@ -375,7 +396,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         userSatisfaction: 0,
         totalUptime: 0,
         lastActivity: new Date(),
-        responseTime: 0
+        responseTime: 0,
       },
       workload: 0,
       health: 1.0,
@@ -391,7 +412,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         permissions: this.getDefaultPermissions(type),
         trustedAgents: [],
         expertise: {},
-        preferences: {}
+        preferences: {},
       },
       environment: {
         runtime: 'deno',
@@ -402,29 +423,32 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         apiEndpoints: {},
         credentials: {},
         availableTools: [],
-        toolConfigs: {}
+        toolConfigs: {},
       },
       endpoints: [],
       lastHeartbeat: new Date(),
       taskHistory: [],
       errorHistory: [],
       childAgents: [],
-      collaborators: []
+      collaborators: [],
     };
 
     this.agents.set(agentId.id, agentState);
-    
+
+    // Track agent in JSON output if enabled
+    this.trackAgentInJsonOutput(agentState);
+
     // Initialize agent capabilities based on type
     await this.initializeAgentCapabilities(agentState);
-    
+
     // Start agent
     await this.startAgent(agentId.id);
-    
-    this.logger.info('Registered agent', { 
-      agentId: agentId.id, 
-      name, 
+
+    this.logger.info('Registered agent', {
+      agentId: agentId.id,
+      name,
       type,
-      capabilities: Object.keys(capabilities)
+      capabilities: Object.keys(capabilities),
     });
 
     this.emitSwarmEvent({
@@ -434,7 +458,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: agentId.id,
       data: { agent: agentState },
       broadcast: false,
-      processed: false
+      processed: false,
     });
 
     return agentId.id;
@@ -447,18 +471,18 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     }
 
     this.logger.info('Unregistering agent', { agentId, name: agent.name });
-    
+
     // Stop agent gracefully
     await this.stopAgent(agentId);
-    
+
     // Reassign any active tasks
     if (agent.currentTask) {
       await this.reassignTask(agent.currentTask.id);
     }
-    
+
     // Remove from agents map
     this.agents.delete(agentId);
-    
+
     this.emitSwarmEvent({
       id: generateId('event'),
       timestamp: new Date(),
@@ -466,7 +490,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: agentId,
       data: { agentId },
       broadcast: false,
-      processed: false
+      processed: false,
     });
   }
 
@@ -481,17 +505,17 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     }
 
     this.logger.info('Starting agent', { agentId, name: agent.name });
-    
+
     try {
       // Initialize agent environment
       await this.initializeAgentEnvironment(agent);
-      
+
       // Start agent heartbeat
       this.startAgentHeartbeat(agent);
-      
+
       agent.status = 'idle';
       agent.lastHeartbeat = new Date();
-      
+
       this.emitSwarmEvent({
         id: generateId('event'),
         timestamp: new Date(),
@@ -499,21 +523,20 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         source: agentId,
         data: { agent },
         broadcast: false,
-        processed: false
+        processed: false,
       });
-      
     } catch (error) {
       agent.status = 'error';
       agent.errorHistory.push({
         timestamp: new Date(),
         type: 'startup_error',
-        message: (error instanceof Error ? error.message : String(error)),
+        message: error instanceof Error ? error.message : String(error),
         stack: error.stack,
         context: { agentId },
         severity: 'high',
-        resolved: false
+        resolved: false,
       });
-      
+
       this.logger.error('Failed to start agent', { agentId, error });
       throw error;
     }
@@ -530,23 +553,22 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     }
 
     this.logger.info('Stopping agent', { agentId, name: agent.name });
-    
+
     agent.status = 'terminating';
-    
+
     try {
       // Cancel current task if any
       if (agent.currentTask) {
         await this.cancelTask(agent.currentTask.id, 'Agent stopping');
       }
-      
+
       // Stop heartbeat
       this.stopAgentHeartbeat(agent);
-      
+
       // Cleanup agent environment
       await this.cleanupAgentEnvironment(agent);
-      
+
       agent.status = 'terminated';
-      
     } catch (error) {
       agent.status = 'error';
       this.logger.error('Error stopping agent', { agentId, error });
@@ -580,13 +602,13 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     name: string,
     description: string,
     instructions: string,
-    options: Partial<TaskDefinition> = {}
+    options: Partial<TaskDefinition> = {},
   ): Promise<string> {
     const taskId: TaskId = {
       id: generateId('task'),
       swarmId: this.swarmId.id,
       sequence: this.tasks.size + 1,
-      priority: 1
+      priority: 1,
     };
 
     const task: TaskDefinition = {
@@ -599,7 +621,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         capabilities: this.getRequiredCapabilities(type),
         tools: this.getRequiredTools(type),
         permissions: this.getRequiredPermissions(type),
-        ...options.requirements
+        ...options.requirements,
       },
       constraints: {
         dependencies: [],
@@ -607,7 +629,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         conflicts: [],
         maxRetries: SWARM_CONSTANTS.MAX_RETRIES,
         timeoutAfter: SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT,
-        ...options.constraints
+        ...options.constraints,
       },
       priority: 'normal',
       input: options.input || {},
@@ -617,23 +639,28 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       createdAt: new Date(),
       updatedAt: new Date(),
       attempts: [],
-      statusHistory: [{
-        timestamp: new Date(),
-        from: 'created' as TaskStatus,
-        to: 'created' as TaskStatus,
-        reason: 'Task created',
-        triggeredBy: 'system'
-      }],
-      ...options
+      statusHistory: [
+        {
+          timestamp: new Date(),
+          from: 'created' as TaskStatus,
+          to: 'created' as TaskStatus,
+          reason: 'Task created',
+          triggeredBy: 'system',
+        },
+      ],
+      ...options,
     };
 
     this.tasks.set(taskId.id, task);
-    
-    this.logger.info('Created task', { 
-      taskId: taskId.id, 
-      type, 
+
+    // Track task in JSON output if enabled
+    this.trackTaskInJsonOutput(task);
+
+    this.logger.info('Created task', {
+      taskId: taskId.id,
+      type,
       name,
-      priority: task.priority 
+      priority: task.priority,
     });
 
     this.emitSwarmEvent({
@@ -643,7 +670,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: this.swarmId.id,
       data: { task },
       broadcast: false,
-      processed: false
+      processed: false,
     });
 
     return taskId.id;
@@ -680,23 +707,23 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     task.assignedTo = agent.id;
     task.assignedAt = new Date();
     task.status = 'assigned';
-    
+
     agent.currentTask = task.id;
     agent.status = 'busy';
-    
+
     // Update status history
     task.statusHistory.push({
       timestamp: new Date(),
       from: task.statusHistory[task.statusHistory.length - 1].to,
       to: 'assigned',
       reason: `Assigned to agent ${agent.name}`,
-      triggeredBy: 'system'
+      triggeredBy: 'system',
     });
 
-    this.logger.info('Assigned task', { 
-      taskId, 
-      agentId, 
-      agentName: agent.name 
+    this.logger.info('Assigned task', {
+      taskId,
+      agentId,
+      agentName: agent.name,
     });
 
     this.emitSwarmEvent({
@@ -706,7 +733,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: agentId,
       data: { task, agent },
       broadcast: false,
-      processed: false
+      processed: false,
     });
 
     // Start task execution
@@ -723,31 +750,31 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       throw new Error(`Agent not found: ${task.assignedTo.id}`);
     }
 
-    this.logger.info('Starting task execution', { 
-      taskId: task.id.id, 
-      agentId: agent.id.id 
+    this.logger.info('Starting task execution', {
+      taskId: task.id.id,
+      agentId: agent.id.id,
     });
 
     task.status = 'running';
     task.startedAt = new Date();
-    
+
     // Create attempt record
     const attempt = {
       attemptNumber: task.attempts.length + 1,
       agent: agent.id,
       startedAt: new Date(),
       status: 'running' as TaskStatus,
-      resourcesUsed: {}
+      resourcesUsed: {},
     };
     task.attempts.push(attempt);
-    
+
     // Update status history
     task.statusHistory.push({
       timestamp: new Date(),
       from: 'assigned',
       to: 'running',
       reason: 'Task execution started',
-      triggeredBy: agent.id
+      triggeredBy: agent.id,
     });
 
     this.emitSwarmEvent({
@@ -757,14 +784,13 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: agent.id.id,
       data: { task, agent, attempt },
       broadcast: false,
-      processed: false
+      processed: false,
     });
 
     try {
       // Execute task (this would spawn actual Claude process)
       const result = await this.executeTaskWithAgent(task, agent);
       await this.completeTask(task.id.id, result);
-      
     } catch (error) {
       await this.failTask(task.id.id, error);
     }
@@ -794,7 +820,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       accuracy: 1.0,
       executionTime: task.completedAt.getTime() - (task.startedAt?.getTime() || 0),
       resourcesUsed: {},
-      validated: false
+      validated: false,
     };
 
     // Update attempt
@@ -811,7 +837,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     agent.metrics.tasksCompleted++;
     agent.metrics.lastActivity = new Date();
     agent.taskHistory.push(task.id);
-    
+
     // Update agent metrics
     this.updateAgentMetrics(agent, task);
 
@@ -821,7 +847,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       from: 'running',
       to: 'completed',
       reason: 'Task completed successfully',
-      triggeredBy: agent.id
+      triggeredBy: agent.id,
     });
 
     this.emitSwarmEvent({
@@ -831,7 +857,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: agent.id.id,
       data: { task, agent, result: task.result },
       broadcast: false,
-      processed: false
+      processed: false,
     });
 
     // Check for dependent tasks
@@ -849,16 +875,20 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       throw new Error('Task not assigned to any agent');
     }
 
-    this.logger.warn('Task failed', { taskId, agentId: agent.id.id, error: (error instanceof Error ? error.message : String(error)) });
+    this.logger.warn('Task failed', {
+      taskId,
+      agentId: agent.id.id,
+      error: error instanceof Error ? error.message : String(error),
+    });
 
     task.error = {
       type: error.constructor.name,
-      message: (error instanceof Error ? error.message : String(error)),
+      message: error instanceof Error ? error.message : String(error),
       code: error.code,
       stack: error.stack,
       context: { taskId, agentId: agent.id.id },
       recoverable: this.isRecoverableError(error),
-      retryable: this.isRetryableError(error)
+      retryable: this.isRetryableError(error),
     };
 
     // Update attempt
@@ -874,33 +904,34 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     agent.currentTask = undefined;
     agent.metrics.tasksFailed++;
     agent.metrics.lastActivity = new Date();
-    
+
     // Add to error history
     agent.errorHistory.push({
       timestamp: new Date(),
       type: 'task_failure',
-      message: (error instanceof Error ? error.message : String(error)),
+      message: error instanceof Error ? error.message : String(error),
       stack: error.stack,
       context: { taskId },
       severity: 'medium',
-      resolved: false
+      resolved: false,
     });
 
     // Determine if we should retry
-    const shouldRetry = task.error.retryable && 
-                       task.attempts.length < (task.constraints.maxRetries || SWARM_CONSTANTS.MAX_RETRIES);
+    const shouldRetry =
+      task.error.retryable &&
+      task.attempts.length < (task.constraints.maxRetries || SWARM_CONSTANTS.MAX_RETRIES);
 
     if (shouldRetry) {
       task.status = 'retrying';
       task.assignedTo = undefined;
-      
+
       // Update status history
       task.statusHistory.push({
         timestamp: new Date(),
         from: 'running',
         to: 'retrying',
-        reason: `Task failed, will retry: ${(error instanceof Error ? error.message : String(error))}`,
-        triggeredBy: agent.id
+        reason: `Task failed, will retry: ${error instanceof Error ? error.message : String(error)}`,
+        triggeredBy: agent.id,
       });
 
       this.emitSwarmEvent({
@@ -910,28 +941,27 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         source: agent.id.id,
         data: { task, error: task.error, attempt: task.attempts.length },
         broadcast: false,
-        processed: false
+        processed: false,
       });
 
       // Schedule retry with exponential backoff
       const retryDelay = Math.pow(2, task.attempts.length) * 1000;
       setTimeout(() => {
-        this.assignTask(taskId).catch(retryError => {
+        this.assignTask(taskId).catch((retryError) => {
           this.logger.error('Failed to retry task', { taskId, retryError });
         });
       }, retryDelay);
-
     } else {
       task.status = 'failed';
       task.completedAt = new Date();
-      
+
       // Update status history
       task.statusHistory.push({
         timestamp: new Date(),
         from: 'running',
         to: 'failed',
-        reason: `Task failed permanently: ${(error instanceof Error ? error.message : String(error))}`,
-        triggeredBy: agent.id
+        reason: `Task failed permanently: ${error instanceof Error ? error.message : String(error)}`,
+        triggeredBy: agent.id,
       });
 
       this.emitSwarmEvent({
@@ -941,7 +971,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         source: agent.id.id,
         data: { task, error: task.error },
         broadcast: false,
-        processed: false
+        processed: false,
       });
 
       // Handle failure cascade
@@ -973,7 +1003,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       from: task.statusHistory[task.statusHistory.length - 1].to,
       to: 'cancelled',
       reason: `Task cancelled: ${reason}`,
-      triggeredBy: 'system'
+      triggeredBy: 'system',
     });
 
     this.emitSwarmEvent({
@@ -983,27 +1013,25 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       source: this.swarmId.id,
       data: { task, reason },
       broadcast: false,
-      processed: false
+      processed: false,
     });
   }
 
   // ===== ADVANCED FEATURES =====
 
   async selectAgentForTask(task: TaskDefinition): Promise<string | null> {
-    const availableAgents = Array.from(this.agents.values())
-      .filter(agent => 
-        agent.status === 'idle' &&
-        this.agentCanHandleTask(agent, task)
-      );
+    const availableAgents = Array.from(this.agents.values()).filter(
+      (agent) => agent.status === 'idle' && this.agentCanHandleTask(agent, task),
+    );
 
     if (availableAgents.length === 0) {
       return null;
     }
 
     // Score agents based on multiple criteria
-    const scoredAgents = availableAgents.map(agent => ({
+    const scoredAgents = availableAgents.map((agent) => ({
       agent,
-      score: this.calculateAgentScore(agent, task)
+      score: this.calculateAgentScore(agent, task),
     }));
 
     // Sort by score (highest first)
@@ -1049,24 +1077,37 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
   private agentHasCapability(agent: AgentState, capability: string): boolean {
     const caps = agent.capabilities;
-    
+
     switch (capability) {
-      case 'code-generation': return caps.codeGeneration;
-      case 'code-review': return caps.codeReview;
-      case 'testing': return caps.testing;
-      case 'documentation': return caps.documentation;
-      case 'research': return caps.research;
-      case 'analysis': return caps.analysis;
-      case 'web-search': return caps.webSearch;
-      case 'api-integration': return caps.apiIntegration;
-      case 'file-system': return caps.fileSystem;
-      case 'terminal-access': return caps.terminalAccess;
-      case 'validation': return caps.testing; // Validation is part of testing capability
-      default: 
-        return caps.domains.includes(capability) ||
-               caps.languages.includes(capability) ||
-               caps.frameworks.includes(capability) ||
-               caps.tools.includes(capability);
+      case 'code-generation':
+        return caps.codeGeneration;
+      case 'code-review':
+        return caps.codeReview;
+      case 'testing':
+        return caps.testing;
+      case 'documentation':
+        return caps.documentation;
+      case 'research':
+        return caps.research;
+      case 'analysis':
+        return caps.analysis;
+      case 'web-search':
+        return caps.webSearch;
+      case 'api-integration':
+        return caps.apiIntegration;
+      case 'file-system':
+        return caps.fileSystem;
+      case 'terminal-access':
+        return caps.terminalAccess;
+      case 'validation':
+        return caps.testing; // Validation is part of testing capability
+      default:
+        return (
+          caps.domains.includes(capability) ||
+          caps.languages.includes(capability) ||
+          caps.frameworks.includes(capability) ||
+          caps.tools.includes(capability)
+        );
     }
   }
 
@@ -1084,8 +1125,10 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     }
 
     // Check reliability requirement
-    if (task.requirements.minReliability && 
-        agent.capabilities.reliability < task.requirements.minReliability) {
+    if (
+      task.requirements.minReliability &&
+      agent.capabilities.reliability < task.requirements.minReliability
+    ) {
       return false;
     }
 
@@ -1103,7 +1146,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     return {
       id: generateId('swarm'),
       timestamp: Date.now(),
-      namespace: 'default'
+      namespace: 'default',
     };
   }
 
@@ -1121,7 +1164,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         taskScheduling: 'priority',
         loadBalancing: 'work-stealing',
         faultTolerance: 'retry',
-        communication: 'event-driven'
+        communication: 'event-driven',
       },
       maxAgents: 10,
       maxTasks: 100,
@@ -1129,7 +1172,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       resourceLimits: {
         memory: SWARM_CONSTANTS.DEFAULT_MEMORY_LIMIT,
         cpu: SWARM_CONSTANTS.DEFAULT_CPU_LIMIT,
-        disk: SWARM_CONSTANTS.DEFAULT_DISK_LIMIT
+        disk: SWARM_CONSTANTS.DEFAULT_DISK_LIMIT,
       },
       qualityThreshold: SWARM_CONSTANTS.DEFAULT_QUALITY_THRESHOLD,
       reviewRequired: true,
@@ -1149,11 +1192,11 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
           errorRate: 0.1,
           responseTime: 5000,
           memoryUsage: 0.8,
-          cpuUsage: 0.8
+          cpuUsage: 0.8,
         },
         exportEnabled: false,
         exportFormat: 'json',
-        exportDestination: '/tmp/swarm-metrics'
+        exportDestination: '/tmp/swarm-metrics',
       },
       memory: {
         namespace: 'default',
@@ -1162,14 +1205,14 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
           read: 'swarm',
           write: 'team',
           delete: 'private',
-          share: 'team'
+          share: 'team',
         },
         persistent: true,
         backupEnabled: true,
         distributed: false,
         consistency: 'eventual',
         cacheEnabled: true,
-        compressionEnabled: false
+        compressionEnabled: false,
       },
       security: {
         authenticationRequired: false,
@@ -1180,7 +1223,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         auditEnabled: true,
         auditLevel: 'info',
         inputValidation: true,
-        outputSanitization: true
+        outputSanitization: true,
       },
       performance: {
         maxConcurrency: 10,
@@ -1193,9 +1236,9 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
         predictiveLoading: false,
         resourcePooling: true,
         connectionPooling: true,
-        memoryPooling: false
+        memoryPooling: false,
       },
-      ...config
+      ...config,
     };
   }
 
@@ -1214,7 +1257,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       agentSatisfaction: 0,
       collaborationEffectiveness: 0,
       scheduleVariance: 0,
-      deadlineAdherence: 0
+      deadlineAdherence: 0,
     };
   }
 
@@ -1234,7 +1277,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
       costSpent: 0,
       activeAgents: 0,
       idleAgents: 0,
-      busyAgents: 0
+      busyAgents: 0,
     };
   }
 
@@ -1273,12 +1316,12 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
   emitSwarmEvent(event: SwarmEvent): boolean {
     this.events.push(event);
-    
+
     // Limit event history
     if (this.events.length > 1000) {
       this.events = this.events.slice(-500);
     }
-    
+
     return this.emit(event.type, event);
   }
 
@@ -1305,7 +1348,7 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
   }
 
   correlateEvents(correlationId: string): SwarmEvent[] {
-    return this.events.filter(event => event.correlationId === correlationId);
+    return this.events.filter((event) => event.correlationId === correlationId);
   }
 
   // ===== PUBLIC API METHODS =====
@@ -1360,22 +1403,27 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
     return endTime.getTime() - this.startTime.getTime();
   }
 
-  getSwarmStatus(): { status: SwarmStatus; objectives: number; tasks: { completed: number; failed: number; total: number }; agents: { total: number } } {
+  getSwarmStatus(): {
+    status: SwarmStatus;
+    objectives: number;
+    tasks: { completed: number; failed: number; total: number };
+    agents: { total: number };
+  } {
     const tasks = Array.from(this.tasks.values());
-    const completedTasks = tasks.filter(t => t.status === 'completed').length;
-    const failedTasks = tasks.filter(t => t.status === 'failed').length;
-    
+    const completedTasks = tasks.filter((t) => t.status === 'completed').length;
+    const failedTasks = tasks.filter((t) => t.status === 'failed').length;
+
     return {
       status: this.status,
       objectives: this.objectives.size,
       tasks: {
         completed: completedTasks,
         failed: failedTasks,
-        total: tasks.length
+        total: tasks.length,
       },
       agents: {
-        total: this.agents.size
-      }
+        total: this.agents.size,
+      },
     };
   }
 
@@ -1383,7 +1431,14 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
   private async validateConfiguration(): Promise<ValidationResult> {
     // Implementation needed
-    return { valid: true, errors: [], warnings: [], validatedAt: new Date(), validator: 'SwarmCoordinator', context: {} };
+    return {
+      valid: true,
+      errors: [],
+      warnings: [],
+      validatedAt: new Date(),
+      validator: 'SwarmCoordinator',
+      context: {},
+    };
   }
 
   private async initializeSubsystems(): Promise<void> {
@@ -1430,24 +1485,23 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
   }
 
   private async stopAllAgents(): Promise<void> {
-    const stopPromises = Array.from(this.agents.keys()).map(agentId => 
-      this.stopAgent(agentId)
-    );
+    const stopPromises = Array.from(this.agents.keys()).map((agentId) => this.stopAgent(agentId));
     await Promise.allSettled(stopPromises);
   }
 
   private async completeRunningTasks(): Promise<void> {
-    const runningTasks = Array.from(this.tasks.values())
-      .filter(task => task.status === 'running');
-    
+    const runningTasks = Array.from(this.tasks.values()).filter(
+      (task) => task.status === 'running',
+    );
+
     // Wait for tasks to complete or timeout
     const timeout = 30000; // 30 seconds
     const deadline = Date.now() + timeout;
-    
-    while (runningTasks.some(task => task.status === 'running') && Date.now() < deadline) {
-      await new Promise(resolve => setTimeout(resolve, 1000));
+
+    while (runningTasks.some((task) => task.status === 'running') && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-    
+
     // Cancel any remaining running tasks
     for (const task of runningTasks) {
       if (task.status === 'running') {
@@ -1462,13 +1516,20 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
   private determineRequiredAgentTypes(strategy: SwarmStrategy): AgentType[] {
     switch (strategy) {
-      case 'research': return ['researcher', 'analyst'];
-      case 'development': return ['coder', 'tester', 'reviewer'];
-      case 'analysis': return ['analyst', 'researcher'];
-      case 'testing': return ['tester', 'coder'];
-      case 'optimization': return ['analyst', 'coder'];
-      case 'maintenance': return ['coder', 'monitor'];
-      default: return ['coordinator', 'coder', 'analyst'];
+      case 'research':
+        return ['researcher', 'analyst'];
+      case 'development':
+        return ['coder', 'tester', 'reviewer'];
+      case 'analysis':
+        return ['analyst', 'researcher'];
+      case 'testing':
+        return ['tester', 'coder'];
+      case 'optimization':
+        return ['analyst', 'coder'];
+      case 'maintenance':
+        return ['coder', 'monitor'];
+      default:
+        return ['coordinator', 'coder', 'analyst'];
     }
   }
 
@@ -1516,31 +1577,37 @@ export class SwarmCoordinator extends EventEmitter implements SwarmEventEmitter
 
   private async decomposeObjective(objective: SwarmObjective): Promise<TaskDefinition[]> {
     // Decompose objective into tasks with clear instructions for Claude
-    this.logger.info('Decomposing objective', { 
-      objectiveId: objective.id, 
-      description: objective.description 
+    this.logger.info('Decomposing objective', {
+      objectiveId: objective.id,
+      description: objective.description,
     });
-    
+
     const tasks: TaskDefinition[] = [];
-    
+
     // Extract target directory from objective
-    const targetDirMatch = objective.description.match(/(?:in|to|at)\s+([^\s]+\/[^\s]+)|([^\s]+\/[^\s]+)$/);
+    const targetDirMatch = objective.description.match(
+      /(?:in|to|at)\s+([^\s]+\/[^\s]+)|([^\s]+\/[^\s]+)$/,
+    );
     const targetDir = targetDirMatch ? targetDirMatch[1] || targetDirMatch[2] : null;
-    const targetPath = targetDir ? (targetDir.startsWith('/') ? targetDir : `${getClaudeFlowRoot()}/${targetDir}`) : null;
-    
+    const targetPath = targetDir
+      ? targetDir.startsWith('/')
+        ? targetDir
+        : `${getClaudeFlowRoot()}/${targetDir}`
+      : null;
+
     // Check if objective requests "each agent" or "each agent type" for parallel execution
     const eachAgentPattern = /\beach\s+agent(?:\s+type)?\b/i;
     const requestsParallelAgents = eachAgentPattern.test(objective.description);
-    
+
     // Create tasks with specific prompts for Claude
     if (requestsParallelAgents && this.config.mode === 'parallel') {
       // Create parallel tasks for each agent type
       const agentTypes = this.determineRequiredAgentTypes(objective.strategy);
-      this.logger.info('Creating parallel tasks for each agent type', { 
+      this.logger.info('Creating parallel tasks for each agent type', {
         agentTypes,
-        mode: this.config.mode 
+        mode: this.config.mode,
       });
-      
+
       for (const agentType of agentTypes) {
         const taskId = this.createTaskForObjective(`${agentType}-task`, agentType as TaskType, {
           title: `${agentType.charAt(0).toUpperCase() + agentType.slice(1)} Agent Task`,
@@ -1557,7 +1624,7 @@ ${this.getAgentTypeInstructions(agentType)}
 Work independently but be aware that other agents are working on this same objective from their perspectives.`,
           priority: 'high' as TaskPriority,
           estimatedDuration: 10 * 60 * 1000,
-          requiredCapabilities: this.getAgentCapabilities(agentType)
+          requiredCapabilities: this.getAgentCapabilities(agentType),
         });
         tasks.push(taskId);
       }
@@ -1582,10 +1649,10 @@ Your analysis should include:
 Please provide a clear, structured plan that the next tasks can follow.`,
         priority: 'high' as TaskPriority,
         estimatedDuration: 5 * 60 * 1000,
-        requiredCapabilities: ['analysis', 'documentation']
+        requiredCapabilities: ['analysis', 'documentation'],
       });
       tasks.push(task1);
-      
+
       // Task 2: Implementation
       const task2 = this.createTaskForObjective('create-implementation', 'coding', {
         title: 'Implement the Solution',
@@ -1607,10 +1674,10 @@ Focus on creating a working implementation that matches the user's request exact
         priority: 'high' as TaskPriority,
         estimatedDuration: 10 * 60 * 1000,
         requiredCapabilities: ['code-generation', 'file-system'],
-        dependencies: [task1.id.id]
+        dependencies: [task1.id.id],
       });
       tasks.push(task2);
-      
+
       // Task 3: Testing
       const task3 = this.createTaskForObjective('write-tests', 'testing', {
         title: 'Create Tests',
@@ -1628,10 +1695,10 @@ Create appropriate test files that:
         priority: 'medium' as TaskPriority,
         estimatedDuration: 5 * 60 * 1000,
         requiredCapabilities: ['testing', 'code-generation'],
-        dependencies: [task2.id.id]
+        dependencies: [task2.id.id],
       });
       tasks.push(task3);
-      
+
       // Task 4: Documentation
       const task4 = this.createTaskForObjective('create-documentation', 'documentation', {
         title: 'Create Documentation',
@@ -1652,15 +1719,16 @@ Make sure the documentation is clear, complete, and helps users understand and u
         priority: 'medium' as TaskPriority,
         estimatedDuration: 5 * 60 * 1000,
         requiredCapabilities: ['documentation'],
-        dependencies: [task2.id.id]
+        dependencies: [task2.id.id],
       });
       tasks.push(task4);
     } else {
       // For other strategies, create a comprehensive single task
-      tasks.push(this.createTaskForObjective('execute-objective', 'generic', {
-        title: 'Execute Objective',
-        description: objective.description,
-        instructions: `Please complete the following request:
+      tasks.push(
+        this.createTaskForObjective('execute-objective', 'generic', {
+          title: 'Execute Objective',
+          description: objective.description,
+          instructions: `Please complete the following request:
 
 ${objective.description}
 
@@ -1674,28 +1742,29 @@ Please analyze what is being requested and implement it appropriately. This may
 - Any other tasks necessary to fulfill the request
 
 Ensure your implementation is complete, well-structured, and follows best practices.`,
-        priority: 'high' as TaskPriority,
-        estimatedDuration: 15 * 60 * 1000,
-        requiredCapabilities: ['code-generation', 'file-system', 'documentation']
-      }));
-    }
-    
-    this.logger.info('Objective decomposed', { 
-      objectiveId: objective.id, 
-      taskCount: tasks.length 
+          priority: 'high' as TaskPriority,
+          estimatedDuration: 15 * 60 * 1000,
+          requiredCapabilities: ['code-generation', 'file-system', 'documentation'],
+        }),
+      );
+    }
+
+    this.logger.info('Objective decomposed', {
+      objectiveId: objective.id,
+      taskCount: tasks.length,
     });
-    
+
     return tasks;
   }
-  
+
   private createTaskForObjective(id: string, type: TaskType, params: any): TaskDefinition {
     const taskId: TaskId = {
       id: generateId('task'),
       swarmId: this.swarmId.id,
       sequence: this.tasks.size + 1,
-      priority: 1
+      priority: 1,
     };
-    
+
     return {
       id: taskId,
       type,
@@ -1705,36 +1774,38 @@ Ensure your implementation is complete, well-structured, and follows best practi
       requirements: {
         capabilities: params.requiredCapabilities || [],
         tools: this.getRequiredTools(type),
-        permissions: this.getRequiredPermissions(type)
+        permissions: this.getRequiredPermissions(type),
       },
       constraints: {
         dependencies: params.dependencies || [],
         dependents: [],
         conflicts: [],
         maxRetries: SWARM_CONSTANTS.MAX_RETRIES,
-        timeoutAfter: params.estimatedDuration || SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT
+        timeoutAfter: params.estimatedDuration || SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT,
       },
       priority: params.priority || 'medium',
       input: {
         description: params.description,
-        objective: params.description
+        objective: params.description,
       },
       context: {
         objectiveId: id,
-        targetDir: params.targetDir
+        targetDir: params.targetDir,
       },
       examples: [],
       status: 'created',
       createdAt: new Date(),
       updatedAt: new Date(),
       attempts: [],
-      statusHistory: [{
-        timestamp: new Date(),
-        from: 'created' as TaskStatus,
-        to: 'created' as TaskStatus,
-        reason: 'Task created',
-        triggeredBy: 'system'
-      }]
+      statusHistory: [
+        {
+          timestamp: new Date(),
+          from: 'created' as TaskStatus,
+          to: 'created' as TaskStatus,
+          reason: 'Task created',
+          triggeredBy: 'system',
+        },
+      ],
     };
   }
 
@@ -1742,16 +1813,16 @@ Ensure your implementation is complete, well-structured, and follows best practi
     // Implementation needed - analyze task dependencies
     return [];
   }
-  
+
   private convertDependenciesToTaskDependencies(dependencies: Map<string, string[]>): any[] {
     // Convert decomposition dependencies to task dependencies format
     const result: any[] = [];
     dependencies.forEach((deps, taskId) => {
-      deps.forEach(dependsOn => {
+      deps.forEach((dependsOn) => {
         result.push({
           taskId,
           dependsOn,
-          type: 'sequential'
+          type: 'sequential',
         });
       });
     });
@@ -1763,19 +1834,19 @@ Ensure your implementation is complete, well-structured, and follows best practi
   }
 
   private async scheduleInitialTasks(objective: SwarmObjective): Promise<void> {
-    this.logger.info('Scheduling initial tasks for objective', { 
-      objectiveId: objective.id, 
-      taskCount: objective.tasks.length 
+    this.logger.info('Scheduling initial tasks for objective', {
+      objectiveId: objective.id,
+      taskCount: objective.tasks.length,
     });
-    
+
     // Extract target directory from objective description
     const targetDirPatterns = [
       /in\s+([^\s]+\/?)$/i,
       /(?:in|to|at)\s+([^\s]+\/[^\s]+)/i,
       /([^\s]+\/[^\s]+)$/,
-      /examples\/[^\s]+/i
+      /examples\/[^\s]+/i,
     ];
-    
+
     let objectiveTargetDir = null;
     for (const pattern of targetDirPatterns) {
       const match = objective.description.match(pattern);
@@ -1784,7 +1855,7 @@ Ensure your implementation is complete, well-structured, and follows best practi
         break;
       }
     }
-    
+
     // Add all tasks to the tasks map
     for (const task of objective.tasks) {
       task.context.objectiveId = objective.id;
@@ -1793,32 +1864,35 @@ Ensure your implementation is complete, well-structured, and follows best practi
         task.context.targetDir = objectiveTargetDir;
       }
       this.tasks.set(task.id.id, task);
+
+      // Track task in JSON output if enabled
+      this.trackTaskInJsonOutput(task);
     }
-    
+
     // Find tasks with no dependencies and queue them
-    const initialTasks = objective.tasks.filter(task => 
-      !task.constraints.dependencies || task.constraints.dependencies.length === 0
+    const initialTasks = objective.tasks.filter(
+      (task) => !task.constraints.dependencies || task.constraints.dependencies.length === 0,
     );
-    
-    this.logger.info('Found initial tasks without dependencies', { 
+
+    this.logger.info('Found initial tasks without dependencies', {
       count: initialTasks.length,
-      tasks: initialTasks.map(t => ({ id: t.id.id, name: t.name }))
+      tasks: initialTasks.map((t) => ({ id: t.id.id, name: t.name })),
     });
-    
+
     // Queue initial tasks for execution
     for (const task of initialTasks) {
       task.status = 'queued';
       task.updatedAt = new Date();
-      
+
       // Update status history
       task.statusHistory.push({
         timestamp: new Date(),
         from: 'created' as TaskStatus,
         to: 'queued' as TaskStatus,
         reason: 'Task queued for execution',
-        triggeredBy: 'system'
+        triggeredBy: 'system',
       });
-      
+
       // Emit task queued event
       this.emitSwarmEvent({
         id: generateId('event'),
@@ -1827,10 +1901,10 @@ Ensure your implementation is complete, well-structured, and follows best practi
         source: this.swarmId.id,
         data: { task },
         broadcast: false,
-        processed: false
+        processed: false,
       });
     }
-    
+
     // Update objective progress
     objective.progress.totalTasks = objective.tasks.length;
     objective.progress.runningTasks = 0;
@@ -1839,10 +1913,10 @@ Ensure your implementation is complete, well-structured, and follows best practi
   }
 
   private startTaskExecutionLoop(objective: SwarmObjective): void {
-    this.logger.info('Starting task execution loop for objective', { 
-      objectiveId: objective.id 
+    this.logger.info('Starting task execution loop for objective', {
+      objectiveId: objective.id,
     });
-    
+
     // Create an interval to process queued tasks
     const executionInterval = setInterval(async () => {
       try {
@@ -1851,74 +1925,69 @@ Ensure your implementation is complete, well-structured, and follows best practi
           clearInterval(executionInterval);
           return;
         }
-        
+
         // Find queued tasks
-        const queuedTasks = Array.from(this.tasks.values())
-          .filter(task => 
-            task.context?.objectiveId === objective.id && 
-            task.status === 'queued'
-          );
-        
+        const queuedTasks = Array.from(this.tasks.values()).filter(
+          (task) => task.context?.objectiveId === objective.id && task.status === 'queued',
+        );
+
         // Find idle agents
-        const idleAgents = Array.from(this.agents.values())
-          .filter(agent => agent.status === 'idle');
-        
+        const idleAgents = Array.from(this.agents.values()).filter(
+          (agent) => agent.status === 'idle',
+        );
+
         if (queuedTasks.length > 0 && idleAgents.length > 0) {
-          this.logger.debug('Processing queued tasks', { 
-            queuedTasks: queuedTasks.length, 
-            idleAgents: idleAgents.length 
+          this.logger.debug('Processing queued tasks', {
+            queuedTasks: queuedTasks.length,
+            idleAgents: idleAgents.length,
           });
         }
-        
+
         // Assign tasks to idle agents
         for (const task of queuedTasks) {
           if (idleAgents.length === 0) break;
-          
+
           // Find suitable agent
-          const suitableAgents = idleAgents.filter(agent => 
-            this.agentCanHandleTask(agent, task)
-          );
-          
+          const suitableAgents = idleAgents.filter((agent) => this.agentCanHandleTask(agent, task));
+
           if (suitableAgents.length > 0) {
             // Assign to first suitable agent
             await this.assignTask(task.id.id, suitableAgents[0].id.id);
-            
+
             // Remove agent from idle list
-            const agentIndex = idleAgents.findIndex(a => a.id.id === suitableAgents[0].id.id);
+            const agentIndex = idleAgents.findIndex((a) => a.id.id === suitableAgents[0].id.id);
             if (agentIndex >= 0) {
               idleAgents.splice(agentIndex, 1);
             }
           }
         }
-        
+
         // Check for completed tasks and process dependencies
-        const completedTasks = Array.from(this.tasks.values())
-          .filter(task => 
-            task.context?.objectiveId === objective.id && 
-            task.status === 'completed'
-          );
-        
+        const completedTasks = Array.from(this.tasks.values()).filter(
+          (task) => task.context?.objectiveId === objective.id && task.status === 'completed',
+        );
+
         // Find tasks that can now be queued (dependencies met)
-        const pendingTasks = Array.from(this.tasks.values())
-          .filter(task => 
-            task.context?.objectiveId === objective.id && 
+        const pendingTasks = Array.from(this.tasks.values()).filter(
+          (task) =>
+            task.context?.objectiveId === objective.id &&
             task.status === 'created' &&
-            this.taskDependenciesMet(task, completedTasks)
-          );
-        
+            this.taskDependenciesMet(task, completedTasks),
+        );
+
         // Queue tasks with met dependencies
         for (const task of pendingTasks) {
           task.status = 'queued';
           task.updatedAt = new Date();
-          
+
           task.statusHistory.push({
             timestamp: new Date(),
             from: 'created' as TaskStatus,
             to: 'queued' as TaskStatus,
             reason: 'Dependencies met, task queued',
-            triggeredBy: 'system'
+            triggeredBy: 'system',
           });
-          
+
           this.emitSwarmEvent({
             id: generateId('event'),
             timestamp: new Date(),
@@ -1926,30 +1995,28 @@ Ensure your implementation is complete, well-structured, and follows best practi
             source: this.swarmId.id,
             data: { task },
             broadcast: false,
-            processed: false
+            processed: false,
           });
         }
-        
+
         // Check for stuck/timed out tasks
-        const runningTasks = Array.from(this.tasks.values())
-          .filter(task => 
-            task.context?.objectiveId === objective.id && 
-            task.status === 'running'
-          );
-        
+        const runningTasks = Array.from(this.tasks.values()).filter(
+          (task) => task.context?.objectiveId === objective.id && task.status === 'running',
+        );
+
         const now = Date.now();
         for (const task of runningTasks) {
           if (task.startedAt) {
             const runtime = now - task.startedAt.getTime();
             const timeout = task.constraints?.timeoutAfter || SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT;
-            
+
             if (runtime > timeout) {
-              this.logger.warn('Task timed out', { 
-                taskId: task.id.id, 
+              this.logger.warn('Task timed out', {
+                taskId: task.id.id,
                 runtime: Math.round(runtime / 1000),
-                timeout: Math.round(timeout / 1000)
+                timeout: Math.round(timeout / 1000),
               });
-              
+
               // Mark task as failed due to timeout
               task.status = 'failed';
               task.completedAt = new Date();
@@ -1959,9 +2026,9 @@ Ensure your implementation is complete, well-structured, and follows best practi
                 code: 'TASK_TIMEOUT',
                 context: { taskId: task.id.id, runtime },
                 recoverable: true,
-                retryable: true
+                retryable: true,
               };
-              
+
               // Update agent state if assigned
               if (task.assignedTo) {
                 const agent = this.agents.get(task.assignedTo.id);
@@ -1971,7 +2038,7 @@ Ensure your implementation is complete, well-structured, and follows best practi
                   agent.metrics.tasksFailed++;
                 }
               }
-              
+
               // Emit timeout event
               this.emitSwarmEvent({
                 id: generateId('event'),
@@ -1980,37 +2047,42 @@ Ensure your implementation is complete, well-structured, and follows best practi
                 source: this.swarmId.id,
                 data: { task, reason: 'timeout' },
                 broadcast: false,
-                processed: false
+                processed: false,
               });
             }
           }
         }
-        
+
         // Update objective progress
-        const allTasks = Array.from(this.tasks.values())
-          .filter(task => task.context?.objectiveId === objective.id);
-        
+        const allTasks = Array.from(this.tasks.values()).filter(
+          (task) => task.context?.objectiveId === objective.id,
+        );
+
         objective.progress.totalTasks = allTasks.length;
-        objective.progress.completedTasks = allTasks.filter(t => t.status === 'completed').length;
-        objective.progress.failedTasks = allTasks.filter(t => t.status === 'failed').length;
-        objective.progress.runningTasks = allTasks.filter(t => t.status === 'running').length;
-        objective.progress.percentComplete = objective.progress.totalTasks > 0 
-          ? (objective.progress.completedTasks / objective.progress.totalTasks) * 100 
-          : 0;
-        
+        objective.progress.completedTasks = allTasks.filter((t) => t.status === 'completed').length;
+        objective.progress.failedTasks = allTasks.filter((t) => t.status === 'failed').length;
+        objective.progress.runningTasks = allTasks.filter((t) => t.status === 'running').length;
+        objective.progress.percentComplete =
+          objective.progress.totalTasks > 0
+            ? (objective.progress.completedTasks / objective.progress.totalTasks) * 100
+            : 0;
+
         // Check if objective is complete
-        if (objective.progress.completedTasks + objective.progress.failedTasks === objective.progress.totalTasks) {
+        if (
+          objective.progress.completedTasks + objective.progress.failedTasks ===
+          objective.progress.totalTasks
+        ) {
           objective.status = objective.progress.failedTasks === 0 ? 'completed' : 'failed';
           objective.completedAt = new Date();
           clearInterval(executionInterval);
-          
-          this.logger.info('Objective completed', { 
+
+          this.logger.info('Objective completed', {
             objectiveId: objective.id,
             status: objective.status,
             completedTasks: objective.progress.completedTasks,
-            failedTasks: objective.progress.failedTasks
+            failedTasks: objective.progress.failedTasks,
           });
-          
+
           this.emitSwarmEvent({
             id: generateId('event'),
             timestamp: new Date(),
@@ -2018,29 +2090,28 @@ Ensure your implementation is complete, well-structured, and follows best practi
             source: this.swarmId.id,
             data: { objective },
             broadcast: true,
-            processed: false
+            processed: false,
           });
         }
-        
       } catch (error) {
         this.logger.error('Error in task execution loop', { error });
       }
     }, 2000); // Check every 2 seconds
-    
+
     // Store interval reference for cleanup
     if (!this.executionIntervals) {
       this.executionIntervals = new Map();
     }
     this.executionIntervals.set(objective.id, executionInterval);
   }
-  
+
   private taskDependenciesMet(task: TaskDefinition, completedTasks: TaskDefinition[]): boolean {
     if (!task.constraints.dependencies || task.constraints.dependencies.length === 0) {
       return true;
     }
-    
-    const completedTaskIds = completedTasks.map(t => t.id.id);
-    return task.constraints.dependencies.every(dep => {
+
+    const completedTaskIds = completedTasks.map((t) => t.id.id);
+    return task.constraints.dependencies.every((dep) => {
       // Handle both string and TaskId object dependencies
       const depId = typeof dep === 'string' ? dep : dep.id;
       return completedTaskIds.includes(depId);
@@ -2048,18 +2119,22 @@ Ensure your implementation is complete, well-structured, and follows best practi
   }
 
   private getNextInstanceNumber(type: AgentType): number {
-    const agentsOfType = Array.from(this.agents.values())
-      .filter(agent => agent.type === type);
+    const agentsOfType = Array.from(this.agents.values()).filter((agent) => agent.type === type);
     return agentsOfType.length + 1;
   }
 
   private getDefaultPermissions(type: AgentType): string[] {
     switch (type) {
-      case 'coordinator': return ['read', 'write', 'execute', 'admin'];
-      case 'coder': return ['read', 'write', 'execute'];
-      case 'tester': return ['read', 'execute'];
-      case 'reviewer': return ['read', 'write'];
-      default: return ['read'];
+      case 'coordinator':
+        return ['read', 'write', 'execute', 'admin'];
+      case 'coder':
+        return ['read', 'write', 'execute'];
+      case 'tester':
+        return ['read', 'execute'];
+      case 'reviewer':
+        return ['read', 'write'];
+      default:
+        return ['read'];
     }
   }
 
@@ -2121,120 +2196,135 @@ Ensure your implementation is complete, well-structured, and follows best practi
 
   private getRequiredCapabilities(type: TaskType): string[] {
     switch (type) {
-      case 'coding': return ['code-generation', 'file-system'];
-      case 'testing': return ['testing', 'code-review'];
-      case 'research': return ['research', 'web-search'];
-      case 'analysis': return ['analysis', 'documentation'];
-      case 'review': return ['code-review', 'documentation'];
-      case 'documentation': return ['documentation'];
-      default: return [];
+      case 'coding':
+        return ['code-generation', 'file-system'];
+      case 'testing':
+        return ['testing', 'code-review'];
+      case 'research':
+        return ['research', 'web-search'];
+      case 'analysis':
+        return ['analysis', 'documentation'];
+      case 'review':
+        return ['code-review', 'documentation'];
+      case 'documentation':
+        return ['documentation'];
+      default:
+        return [];
     }
   }
 
   private getRequiredTools(type: TaskType): string[] {
     switch (type) {
-      case 'coding': return ['editor', 'compiler', 'debugger'];
-      case 'testing': return ['test-runner', 'coverage-tool'];
-      case 'research': return ['web-browser', 'search-engine'];
-      case 'analysis': return ['data-tools', 'visualization'];
-      default: return [];
+      case 'coding':
+        return ['editor', 'compiler', 'debugger'];
+      case 'testing':
+        return ['test-runner', 'coverage-tool'];
+      case 'research':
+        return ['web-browser', 'search-engine'];
+      case 'analysis':
+        return ['data-tools', 'visualization'];
+      default:
+        return [];
     }
   }
 
   private getRequiredPermissions(type: TaskType): string[] {
     switch (type) {
-      case 'coding': return ['read', 'write', 'execute'];
-      case 'testing': return ['read', 'execute'];
-      case 'research': return ['read', 'network'];
-      default: return ['read'];
+      case 'coding':
+        return ['read', 'write', 'execute'];
+      case 'testing':
+        return ['read', 'execute'];
+      case 'research':
+        return ['read', 'network'];
+      default:
+        return ['read'];
     }
   }
 
   private async executeTaskWithAgent(task: TaskDefinition, agent: AgentState): Promise<any> {
-    this.logger.info('Executing task with agent', { 
-      taskId: task.id.id, 
+    this.logger.info('Executing task with agent', {
+      taskId: task.id.id,
       taskName: task.name,
       agentId: agent.id.id,
-      agentName: agent.name
+      agentName: agent.name,
     });
-    
+
     // Extract target directory from task
     const targetDir = this.extractTargetDirectory(task);
-    
+
     try {
       // Use Claude Flow executor for full SPARC system in non-interactive mode
       const { ClaudeFlowExecutor } = await import('./claude-flow-executor.ts');
-      const executor = new ClaudeFlowExecutor({ 
+      const executor = new ClaudeFlowExecutor({
         logger: this.logger,
         claudeFlowPath: getClaudeFlowBin(),
         enableSparc: true,
         verbose: this.config.logging?.level === 'debug',
-        timeoutMinutes: this.config.taskTimeoutMinutes
+        timeoutMinutes: this.config.taskTimeoutMinutes,
       });
-      
+
       const result = await executor.executeTask(task, agent, targetDir);
-      
-      this.logger.info('Task execution completed', { 
+
+      this.logger.info('Task execution completed', {
         taskId: task.id.id,
         success: true,
-        outputLength: JSON.stringify(result).length
+        outputLength: JSON.stringify(result).length,
       });
-      
+
       return result;
-      
     } catch (error) {
-      this.logger.error('Task execution failed', { 
+      this.logger.error('Task execution failed', {
         taskId: task.id.id,
-        error: (error instanceof Error ? error.message : String(error))
+        error: error instanceof Error ? error.message : String(error),
       });
       throw error;
     }
   }
-  
+
   private createExecutionPrompt(task: TaskDefinition): string {
     // Create a prompt that Claude will understand
     let prompt = `# Swarm Task Execution\n\n`;
     prompt += `## Task: ${task.name}\n\n`;
     prompt += `${task.instructions || task.description}\n\n`;
-    
+
     // Add working directory information if available
     const targetDir = this.extractTargetDirectory(task);
     if (targetDir) {
       prompt += `## Working Directory\n`;
       prompt += `Please create all files in: ${targetDir}\n\n`;
     }
-    
+
     if (task.input && Object.keys(task.input).length > 0) {
       prompt += `## Additional Input\n`;
       prompt += `${JSON.stringify(task.input, null, 2)}\n\n`;
     }
-    
+
     if (task.context && Object.keys(task.context).length > 0) {
       prompt += `## Context\n`;
       prompt += `${JSON.stringify(task.context, null, 2)}\n\n`;
     }
-    
+
     // Add execution guidelines
     prompt += `## Guidelines\n`;
     prompt += `- Focus on completing this specific task\n`;
     prompt += `- Create all necessary files and directories\n`;
     prompt += `- Follow best practices for the technology being used\n`;
     prompt += `- Ensure the implementation is complete and functional\n`;
-    
+
     return prompt;
   }
-  
+
   private extractTargetDirectory(task: TaskDefinition): string | null {
     // Try multiple patterns to find the target directory
     const patterns = [
-      /in\s+([^\s]+\/?)$/i,              // "in examples/dir" at end
+      /in\s+([^\s]+\/?)$/i, // "in examples/dir" at end
       /(?:in|to|at)\s+([^\s]+\/[^\s]+)/i, // "in examples/gradio" anywhere
-      /([^\s]+\/[^\s]+)$/,               // "examples/gradio" at end
-      /examples\/[^\s]+/i                // specifically match examples/ paths
+      /([^\s]+\/[^\s]+)$/, // "examples/gradio" at end
+      /examples\/[^\s]+/i, // specifically match examples/ paths
     ];
-    
+
     let targetDir = null;
-    
+
     // First check task description and input
     for (const pattern of patterns) {
       const descMatch = task.description.match(pattern);
@@ -2244,12 +2334,12 @@ Ensure your implementation is complete, well-structured, and follows best practi
         break;
       }
     }
-    
+
     // If not found and task has context with targetDir, use that
     if (!targetDir && task.context?.targetDir) {
       targetDir = task.context.targetDir;
     }
-    
+
     // If still not found, check objective description from context
     if (!targetDir && task.context?.objectiveId) {
       const objective = this.objectives.get(task.context.objectiveId);
@@ -2263,7 +2353,7 @@ Ensure your implementation is complete, well-structured, and follows best practi
         }
       }
     }
-    
+
     if (targetDir) {
       // Clean up the target directory
       targetDir = targetDir.replace(/\s+.*$/, '');
@@ -2272,40 +2362,40 @@ Ensure your implementation is complete, well-structured, and follows best practi
         targetDir = `${getClaudeFlowRoot()}/${targetDir}`;
       }
     }
-    
+
     return targetDir;
   }
-  
+
   private async executeClaudeTask(
     task: TaskDefinition,
     agent: AgentState,
     prompt: string,
-    targetDir: string | null
+    targetDir: string | null,
   ): Promise<any> {
     // Create unique instance ID for this execution
     const instanceId = `swarm-${this.swarmId.id}-${task.id.id}-${Date.now()}`;
-    
+
     // Build Claude arguments for non-interactive execution
     const claudeArgs = [prompt];
-    
+
     // Always skip permissions for swarm automation
-    claudeArgs.push("--dangerously-skip-permissions");
-    
+    claudeArgs.push('--dangerously-skip-permissions');
+
     // Add non-interactive flags for automation
-    claudeArgs.push("-p"); // Print mode
-    claudeArgs.push("--output-format", "stream-json");
-    claudeArgs.push("--verbose"); // Required when using stream-json with -p
-    
+    claudeArgs.push('-p'); // Print mode
+    claudeArgs.push('--output-format', 'stream-json');
+    claudeArgs.push('--verbose'); // Required when using stream-json with -p
+
     // Set working directory if specified
     if (targetDir) {
       // Ensure directory exists
       await Deno.mkdir(targetDir, { recursive: true });
-      
+
       // Add directory context to prompt
       const enhancedPrompt = `${prompt}\n\n## Important: Working Directory\nPlease ensure all files are created in: ${targetDir}`;
       claudeArgs[0] = enhancedPrompt;
     }
-    
+
     try {
       // Check if claude command exists
       const checkCommand = new Deno.Command('which', {
@@ -2317,137 +2407,136 @@ Ensure your implementation is complete, well-structured, and follows best practi
       if (!checkResult.success) {
         throw new Error('Claude CLI not found. Please ensure claude is installed and in PATH.');
       }
-      
+
       // Execute Claude with the prompt
-      const command = new Deno.Command("claude", {
+      const command = new Deno.Command('claude', {
         args: claudeArgs,
         cwd: targetDir || process.cwd(),
         env: {
           ...Deno.env.toObject(),
           CLAUDE_INSTANCE_ID: instanceId,
-          CLAUDE_SWARM_MODE: "true",
+          CLAUDE_SWARM_MODE: 'true',
           CLAUDE_SWARM_ID: this.swarmId.id,
           CLAUDE_TASK_ID: task.id.id,
           CLAUDE_AGENT_ID: agent.id.id,
           CLAUDE_WORKING_DIRECTORY: targetDir || process.cwd(),
-          CLAUDE_FLOW_MEMORY_ENABLED: "true",
+          CLAUDE_FLOW_MEMORY_ENABLED: 'true',
           CLAUDE_FLOW_MEMORY_NAMESPACE: `swarm-${this.swarmId.id}`,
         },
-        stdin: "null",
-        stdout: "piped",
-        stderr: "piped",
+        stdin: 'null',
+        stdout: 'piped',
+        stderr: 'piped',
       });
-      
-      this.logger.info('Spawning Claude agent for task', { 
+
+      this.logger.info('Spawning Claude agent for task', {
         taskId: task.id.id,
         agentId: agent.id.id,
         instanceId,
-        targetDir 
+        targetDir,
       });
-      
+
       const child = command.spawn();
       const { code, stdout, stderr } = await child.output();
-      
+
       if (code === 0) {
         const output = new TextDecoder().decode(stdout);
         this.logger.info('Claude agent completed task successfully', {
           taskId: task.id.id,
-          outputLength: output.length
+          outputLength: output.length,
         });
-        
+
         return {
           success: true,
           output,
           instanceId,
-          targetDir
+          targetDir,
         };
       } else {
         const errorOutput = new TextDecoder().decode(stderr);
-        this.logger.error(`Claude agent failed with code ${code}`, { 
+        this.logger.error(`Claude agent failed with code ${code}`, {
           taskId: task.id.id,
-          error: errorOutput 
+          error: errorOutput,
         });
         throw new Error(`Claude execution failed: ${errorOutput}`);
       }
-      
     } catch (error) {
-      this.logger.error('Failed to execute Claude agent', { 
+      this.logger.error('Failed to execute Claude agent', {
         taskId: task.id.id,
-        error: (error instanceof Error ? error.message : String(error)) 
+        error: error instanceof Error ? error.message : String(error),
       });
       throw error;
     }
   }
-  
+
   private determineToolsForTask(task: TaskDefinition, agent: AgentState): string[] {
     const tools = new Set<string>();
-    
+
     // Basic tools for all tasks
-    tools.add("View");
-    tools.add("Edit");
-    tools.add("Bash");
-    
+    tools.add('View');
+    tools.add('Edit');
+    tools.add('Bash');
+
     // Add tools based on task type
     switch (task.type) {
       case 'coding':
-        tools.add("Create");
-        tools.add("Write");
-        tools.add("MultiEdit");
-        tools.add("Test");
+        tools.add('Create');
+        tools.add('Write');
+        tools.add('MultiEdit');
+        tools.add('Test');
         break;
       case 'testing':
-        tools.add("Test");
-        tools.add("View");
+        tools.add('Test');
+        tools.add('View');
         break;
       case 'documentation':
-        tools.add("Write");
-        tools.add("Create");
+        tools.add('Write');
+        tools.add('Create');
         break;
       case 'analysis':
-        tools.add("Analyze");
-        tools.add("Search");
+        tools.add('Analyze');
+        tools.add('Search');
         break;
       case 'research':
-        tools.add("WebSearch");
-        tools.add("Search");
+        tools.add('WebSearch');
+        tools.add('Search');
         break;
     }
-    
+
     // Add tools based on agent capabilities
     if (agent.capabilities.fileSystem) {
-      tools.add("FileSystem");
+      tools.add('FileSystem');
     }
     if (agent.capabilities.terminalAccess) {
-      tools.add("Terminal");
+      tools.add('Terminal');
     }
     if (agent.capabilities.webSearch) {
-      tools.add("WebSearch");
+      tools.add('WebSearch');
     }
     if (agent.capabilities.apiIntegration) {
-      tools.add("API");
+      tools.add('API');
     }
-    
+
     return Array.from(tools);
   }
-  
+
   private async simulateTaskExecution(
     task: TaskDefinition,
     agent: AgentState,
-    prompt: string
+    prompt: string,
   ): Promise<any> {
     // Simulate different task types with actual file operations
     // Check if task has a target directory in the description or context
     let workDir = `/tmp/swarm/${this.swarmId.id}/work`;
-    
+
     // Extract target directory from task description or input
     // Try multiple patterns to find the target directory
     const patterns = [
-      /in\s+([^\s]+\/?)$/i,              // "in examples/dir" at end
+      /in\s+([^\s]+\/?)$/i, // "in examples/dir" at end
       /(?:in|to|at)\s+([^\s]+\/[^\s]+)/i, // "in examples/gradio" anywhere
-      /([^\s]+\/[^\s]+)$/,               // "examples/gradio" at end
-      /examples\/[^\s]+/i                // specifically match examples/ paths
+      /([^\s]+\/[^\s]+)$/, // "examples/gradio" at end
+      /examples\/[^\s]+/i, // specifically match examples/ paths
     ];
-    
+
     let targetDir = null;
     for (const pattern of patterns) {
       const descMatch = task.description.match(pattern);
@@ -2457,55 +2546,65 @@ Ensure your implementation is complete, well-structured, and follows best practi
         break;
       }
     }
-    
+
     if (targetDir) {
       // Clean up the target directory (remove trailing words if needed)
       targetDir = targetDir.replace(/\s+.*$/, '');
       // Use absolute path or resolve relative to current directory
       workDir = targetDir.startsWith('/') ? targetDir : `${getClaudeFlowRoot()}/${targetDir}`;
-      
-      this.logger.debug('Extracted target directory', { 
+
+      this.logger.debug('Extracted target directory', {
         original: task.description,
         targetDir,
-        workDir 
+        workDir,
       });
     }
-    
+
     try {
       // Ensure work directory exists
       await Deno.mkdir(workDir, { recursive: true });
-      
+
       switch (task.type) {
         case 'coding':
           return await this.executeCodeGenerationTask(task, workDir, agent);
-          
+
         case 'analysis':
           return await this.executeAnalysisTask(task, workDir, agent);
-          
+
         case 'documentation':
           return await this.executeDocumentationTask(task, workDir, agent);
-          
+
         case 'testing':
           return await this.executeTestingTask(task, workDir, agent);
-          
+
         default:
           return await this.executeGenericTask(task, workDir, agent);
       }
     } catch (error) {
-      throw new Error(`Task execution failed: ${(error instanceof Error ? error.message : String(error))}`);
+      throw new Error(
+        `Task execution failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
     }
   }
-  
-  private async executeCodeGenerationTask(task: TaskDefinition, workDir: string, agent: AgentState): Promise<any> {
+
+  private async executeCodeGenerationTask(
+    task: TaskDefinition,
+    workDir: string,
+    agent: AgentState,
+  ): Promise<any> {
     this.logger.info('Executing code generation task', { taskId: task.id.id });
-    
+
     // Detect technology from description
     const description = task.description.toLowerCase();
     const isGradio = description.includes('gradio');
-    const isPython = isGradio || description.includes('python') || description.includes('fastapi') || description.includes('django');
+    const isPython =
+      isGradio ||
+      description.includes('python') ||
+      description.includes('fastapi') ||
+      description.includes('django');
     const isHelloWorld = description.includes('hello') && description.includes('world');
     const isRestAPI = description.includes('rest api') || description.includes('api');
-    
+
     if (isGradio) {
       // Create a Gradio application
       return await this.createGradioApp(task, workDir);
@@ -2517,7 +2616,7 @@ Ensure your implementation is complete, well-structured, and follows best practi
       const projectName = 'rest-api';
       const projectDir = `${workDir}/${projectName}`;
       await Deno.mkdir(projectDir, { recursive: true });
-      
+
       // Create main API file
       const apiCode = `const express = require('express');
 const app = express();
@@ -2595,44 +2694,41 @@ app.listen(port, () => {
 
 module.exports = app;
 `;
-      
+
       await fs.writeFile(`${projectDir}/server.js`, apiCode);
-      
+
       // Create package.json
       const packageJson = {
         name: projectName,
-        version: "1.0.0",
-        description: "REST API created by Claude Flow Swarm",
-        main: "server.js",
+        version: '1.0.0',
+        description: 'REST API created by Claude Flow Swarm',
+        main: 'server.js',
         scripts: {
-          start: "node server.js",
-          dev: "nodemon server.js",
-          test: "jest"
+          start: 'node server.js',
+          dev: 'nodemon server.js',
+          test: 'jest',
         },
-        keywords: ["rest", "api", "swarm", "claude-flow"],
-        author: "Claude Flow Swarm",
-        license: "MIT",
+        keywords: ['rest', 'api', 'swarm', 'claude-flow'],
+        author: 'Claude Flow Swarm',
+        license: 'MIT',
         dependencies: {
-          express: "^4.18.2"
+          express: '^4.18.2',
         },
         devDependencies: {
-          nodemon: "^3.0.1",
-          jest: "^29.7.0",
-          supertest: "^6.3.3"
+          nodemon: '^3.0.1',
+          jest: '^29.7.0',
+          supertest: '^6.3.3',
         },
         swarmMetadata: {
           swarmId: this.swarmId.id,
           taskId: task.id.id,
           agentId: agent.id.id,
-          created: new Date().toISOString()
-        }
+          created: new Date().toISOString(),
+        },
       };
-      
-      await fs.writeFile(
-        `${projectDir}/package.json`, 
-        JSON.stringify(packageJson, null, 2)
-      );
-      
+
+      await fs.writeFile(`${projectDir}/package.json`, JSON.stringify(packageJson, null, 2));
+
       // Create README
       const readme = `# REST API
 
@@ -2677,9 +2773,9 @@ ${task.description}
 ---
 Created by Claude Flow Swarm
 `;
-      
+
       await fs.writeFile(`${projectDir}/README.md`, readme);
-      
+
       // Create .gitignore
       const gitignore = `node_modules/
 .env
@@ -2687,27 +2783,27 @@ Created by Claude Flow Swarm
 .DS_Store
 coverage/
 `;
-      
+
       await fs.writeFile(`${projectDir}/.gitignore`, gitignore);
-      
+
       return {
         success: true,
         output: {
           message: 'REST API created successfully',
           location: projectDir,
-          files: ['server.js', 'package.json', 'README.md', '.gitignore']
+          files: ['server.js', 'package.json', 'README.md', '.gitignore'],
         },
         artifacts: {
           mainFile: `${projectDir}/server.js`,
           packageFile: `${projectDir}/package.json`,
-          readmeFile: `${projectDir}/README.md`
-        }
+          readmeFile: `${projectDir}/README.md`,
+        },
       };
     } else if (isHelloWorld) {
       // Create a simple hello world application
       const projectDir = `${workDir}/hello-world`;
       await Deno.mkdir(projectDir, { recursive: true });
-      
+
       // Create main application file
       const mainCode = `#!/usr/bin/env node
 
@@ -2725,29 +2821,26 @@ if (typeof module !== 'undefined' && module.exports) {
   module.exports = { message: 'Hello, World!' };
 }
 `;
-      
+
       await fs.writeFile(`${projectDir}/index.js`, mainCode);
-      
+
       // Create package.json
       const packageJson = {
-        name: "hello-world",
-        version: "1.0.0",
-        description: "Hello World application created by Claude Flow Swarm",
-        main: "index.js",
+        name: 'hello-world',
+        version: '1.0.0',
+        description: 'Hello World application created by Claude Flow Swarm',
+        main: 'index.js',
         scripts: {
-          start: "node index.js",
-          test: "node test.js"
+          start: 'node index.js',
+          test: 'node test.js',
         },
-        keywords: ["hello-world", "swarm", "claude-flow"],
-        author: "Claude Flow Swarm",
-        license: "MIT"
+        keywords: ['hello-world', 'swarm', 'claude-flow'],
+        author: 'Claude Flow Swarm',
+        license: 'MIT',
       };
-      
-      await fs.writeFile(
-        `${projectDir}/package.json`, 
-        JSON.stringify(packageJson, null, 2)
-      );
-      
+
+      await fs.writeFile(`${projectDir}/package.json`, JSON.stringify(packageJson, null, 2));
+
       // Create README
       const readme = `# Hello World
 
@@ -2767,28 +2860,28 @@ npm start
 ## Description
 ${task.description}
 `;
-      
+
       await fs.writeFile(`${projectDir}/README.md`, readme);
-      
+
       return {
         success: true,
         output: {
           message: 'Hello World application created successfully',
           location: projectDir,
-          files: ['index.js', 'package.json', 'README.md']
+          files: ['index.js', 'package.json', 'README.md'],
         },
         artifacts: {
           mainFile: `${projectDir}/index.js`,
           packageFile: `${projectDir}/package.json`,
-          readmeFile: `${projectDir}/README.md`
-        }
+          readmeFile: `${projectDir}/README.md`,
+        },
       };
     }
-    
+
     // For other code generation tasks, create a basic structure
     const projectDir = `${workDir}/generated-code`;
     await Deno.mkdir(projectDir, { recursive: true });
-    
+
     const code = `// Generated code for: ${task.name}
 // ${task.description}
 
@@ -2799,25 +2892,29 @@ function main() {
 
 main();
 `;
-    
+
     await fs.writeFile(`${projectDir}/main.js`, code);
-    
+
     return {
       success: true,
       output: {
         message: 'Code generated successfully',
         location: projectDir,
-        files: ['main.js']
-      }
+        files: ['main.js'],
+      },
     };
   }
-  
-  private async executeAnalysisTask(task: TaskDefinition, workDir: string, agent: AgentState): Promise<any> {
+
+  private async executeAnalysisTask(
+    task: TaskDefinition,
+    workDir: string,
+    agent: AgentState,
+  ): Promise<any> {
     this.logger.info('Executing analysis task', { taskId: task.id.id });
-    
+
     const analysisDir = `${workDir}/analysis`;
     await Deno.mkdir(analysisDir, { recursive: true });
-    
+
     const analysis = {
       task: task.name,
       description: task.description,
@@ -2825,35 +2922,36 @@ main();
       findings: [
         'Analysis point 1: Task objectives are clear',
         'Analysis point 2: Resources are allocated',
-        'Analysis point 3: Implementation path is defined'
+        'Analysis point 3: Implementation path is defined',
       ],
       recommendations: [
         'Proceed with implementation',
         'Monitor progress regularly',
-        'Adjust resources as needed'
-      ]
+        'Adjust resources as needed',
+      ],
     };
-    
-    await fs.writeFile(
-      `${analysisDir}/analysis-report.json`,
-      JSON.stringify(analysis, null, 2)
-    );
-    
+
+    await fs.writeFile(`${analysisDir}/analysis-report.json`, JSON.stringify(analysis, null, 2));
+
     return {
       success: true,
       output: analysis,
       artifacts: {
-        report: `${analysisDir}/analysis-report.json`
-      }
+        report: `${analysisDir}/analysis-report.json`,
+      },
     };
   }
-  
-  private async executeDocumentationTask(task: TaskDefinition, workDir: string, agent: AgentState): Promise<any> {
+
+  private async executeDocumentationTask(
+    task: TaskDefinition,
+    workDir: string,
+    agent: AgentState,
+  ): Promise<any> {
     this.logger.info('Executing documentation task', { taskId: task.id.id });
-    
+
     const docsDir = `${workDir}/docs`;
     await Deno.mkdir(docsDir, { recursive: true });
-    
+
     const documentation = `# ${task.name}
 
 ${task.description}
@@ -2873,28 +2971,32 @@ ${task.instructions}
 - This is an automated documentation generated by the swarm
 - Further details would be added based on actual implementation
 `;
-    
+
     await fs.writeFile(`${docsDir}/documentation.md`, documentation);
-    
+
     return {
       success: true,
       output: {
         message: 'Documentation created successfully',
         location: docsDir,
-        files: ['documentation.md']
+        files: ['documentation.md'],
       },
       artifacts: {
-        documentation: `${docsDir}/documentation.md`
-      }
+        documentation: `${docsDir}/documentation.md`,
+      },
     };
   }
-  
-  private async executeTestingTask(task: TaskDefinition, workDir: string, agent: AgentState): Promise<any> {
+
+  private async executeTestingTask(
+    task: TaskDefinition,
+    workDir: string,
+    agent: AgentState,
+  ): Promise<any> {
     this.logger.info('Executing testing task', { taskId: task.id.id });
-    
+
     const testDir = `${workDir}/tests`;
     await Deno.mkdir(testDir, { recursive: true });
-    
+
     const testCode = `// Test suite for: ${task.name}
 // ${task.description}
 
@@ -2913,9 +3015,9 @@ describe('${task.name}', () => {
 
 console.log('Tests completed for: ${task.name}');
 `;
-    
+
     await fs.writeFile(`${testDir}/test.js`, testCode);
-    
+
     return {
       success: true,
       output: {
@@ -2923,40 +3025,41 @@ console.log('Tests completed for: ${task.name}');
         location: testDir,
         files: ['test.js'],
         testsPassed: 2,
-        testsFailed: 0
+        testsFailed: 0,
       },
       artifacts: {
-        testFile: `${testDir}/test.js`
-      }
+        testFile: `${testDir}/test.js`,
+      },
     };
   }
-  
-  private async executeGenericTask(task: TaskDefinition, workDir: string, agent: AgentState): Promise<any> {
+
+  private async executeGenericTask(
+    task: TaskDefinition,
+    workDir: string,
+    agent: AgentState,
+  ): Promise<any> {
     this.logger.info('Executing generic task', { taskId: task.id.id });
-    
+
     const outputDir = `${workDir}/output`;
     await Deno.mkdir(outputDir, { recursive: true });
-    
+
     const output = {
       task: task.name,
       type: task.type,
       description: task.description,
       status: 'completed',
       timestamp: new Date().toISOString(),
-      result: 'Task executed successfully'
+      result: 'Task executed successfully',
     };
-    
-    await fs.writeFile(
-      `${outputDir}/result.json`,
-      JSON.stringify(output, null, 2)
-    );
-    
+
+    await fs.writeFile(`${outputDir}/result.json`, JSON.stringify(output, null, 2));
+
     return {
       success: true,
       output,
       artifacts: {
-        result: `${outputDir}/result.json`
-      }
+        result: `${outputDir}/result.json`,
+      },
     };
   }
 
@@ -2968,12 +3071,12 @@ console.log('Tests completed for: ${task.name}');
   private updateAgentMetrics(agent: AgentState, task: TaskDefinition): void {
     // Update agent performance metrics
     const executionTime = task.completedAt!.getTime() - (task.startedAt?.getTime() || 0);
-    
-    agent.metrics.averageExecutionTime = 
-      (agent.metrics.averageExecutionTime * agent.metrics.tasksCompleted + executionTime) / 
+
+    agent.metrics.averageExecutionTime =
+      (agent.metrics.averageExecutionTime * agent.metrics.tasksCompleted + executionTime) /
       (agent.metrics.tasksCompleted + 1);
-    
-    agent.metrics.successRate = 
+
+    agent.metrics.successRate =
       agent.metrics.tasksCompleted / (agent.metrics.tasksCompleted + agent.metrics.tasksFailed);
   }
 
@@ -3002,17 +3105,17 @@ console.log('Tests completed for: ${task.name}');
   private processHeartbeats(): void {
     const now = new Date();
     const timeout = this.config.monitoring.heartbeatInterval * 10; // Increased multiplier for long-running Claude tasks
-    
+
     for (const agent of this.agents.values()) {
       if (agent.status === 'offline' || agent.status === 'terminated') {
         continue;
       }
-      
+
       const timeSinceHeartbeat = now.getTime() - agent.lastHeartbeat.getTime();
       if (timeSinceHeartbeat > timeout) {
-        this.logger.warn('Agent heartbeat timeout', { 
-          agentId: agent.id.id, 
-          timeSinceHeartbeat 
+        this.logger.warn('Agent heartbeat timeout', {
+          agentId: agent.id.id,
+          timeSinceHeartbeat,
         });
         agent.status = 'error';
         agent.health = 0;
@@ -3042,6 +3145,100 @@ console.log('Tests completed for: ${task.name}');
       agent.status = 'error';
       agent.health = 0;
       this.logger.error('Agent error', { agentId, error });
+
+      // Track error in JSON output if enabled
+      if (this.jsonOutputAggregator) {
+        this.jsonOutputAggregator.addAgentError(
+          agentId,
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+    }
+  }
+
+  // ===== JSON OUTPUT METHODS =====
+
+  /**
+   * Enable JSON output collection for non-interactive mode
+   */
+  enableJsonOutput(objective: string): void {
+    if (!this.jsonOutputAggregator) {
+      this.jsonOutputAggregator = new SwarmJsonOutputAggregator(
+        this.swarmId.id,
+        objective,
+        this.config,
+      );
+      this.logger.info('JSON output aggregation enabled', { swarmId: this.swarmId.id });
     }
   }
-}
+
+  /**
+   * Get the final JSON output for the swarm
+   */
+  getJsonOutput(
+    status: 'completed' | 'failed' | 'timeout' | 'cancelled' = 'completed',
+  ): string | null {
+    if (!this.jsonOutputAggregator) {
+      return null;
+    }
+    return this.jsonOutputAggregator.getJsonOutput(status);
+  }
+
+  /**
+   * Save JSON output to file
+   */
+  async saveJsonOutput(
+    filePath: string,
+    status: 'completed' | 'failed' | 'timeout' | 'cancelled' = 'completed',
+  ): Promise<void> {
+    if (!this.jsonOutputAggregator) {
+      throw new Error('JSON output aggregation not enabled');
+    }
+    await this.jsonOutputAggregator.saveToFile(filePath, status);
+  }
+
+  /**
+   * Track agent activity in JSON output
+   */
+  private trackAgentInJsonOutput(agent: AgentState): void {
+    if (this.jsonOutputAggregator) {
+      this.jsonOutputAggregator.addAgent(agent);
+    }
+  }
+
+  /**
+   * Track task activity in JSON output
+   */
+  private trackTaskInJsonOutput(task: TaskDefinition): void {
+    if (this.jsonOutputAggregator) {
+      this.jsonOutputAggregator.addTask(task);
+    }
+  }
+
+  /**
+   * Add output to JSON aggregator
+   */
+  private addOutputToJsonAggregator(agentId: string, output: string): void {
+    if (this.jsonOutputAggregator) {
+      this.jsonOutputAggregator.addAgentOutput(agentId, output);
+    }
+  }
+
+  /**
+   * Add insight to JSON aggregator
+   */
+  addInsight(insight: string): void {
+    if (this.jsonOutputAggregator) {
+      this.jsonOutputAggregator.addInsight(insight);
+    }
+  }
+
+  /**
+   * Add artifact to JSON aggregator
+   */
+  addArtifact(key: string, artifact: any): void {
+    if (this.jsonOutputAggregator) {
+      this.jsonOutputAggregator.addArtifact(key, artifact);
+    }
+  }
+}