claude-flow-novice 1.0.0

package/dist/src/swarm/coordinator.js

@@ -0,0 +1,3001 @@
+import { EventEmitter } from 'events';
+import { promises as fs } from 'node:fs';
+import { Logger } from '../core/logger.js';
+import { generateId } from '../utils/helpers.js';
+import { 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 {
+    logger;
+    config;
+    swarmId;
+    // Core state management
+    agents = new Map();
+    tasks = new Map();
+    objectives = new Map();
+    // Execution state
+    _isRunning = false;
+    status = 'planning';
+    startTime;
+    endTime;
+    // Performance tracking
+    metrics;
+    events = [];
+    lastHeartbeat = new Date();
+    // JSON output aggregation (optional)
+    jsonOutputAggregator;
+    // Background processes
+    heartbeatTimer;
+    monitoringTimer;
+    cleanupTimer;
+    executionIntervals;
+    // Strategy instances
+    autoStrategy;
+    constructor(config = {}){
+        super();
+        // Configure logger based on config or default to quiet mode
+        const logLevel = config.logging?.level || 'error';
+        const logFormat = config.logging?.format || 'text';
+        const logDestination = config.logging?.destination || 'console';
+        this.logger = new Logger({
+            level: logLevel,
+            format: logFormat,
+            destination: logDestination
+        }, {
+            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', {
+            swarmId: this.swarmId.id,
+            mode: this.config.mode,
+            strategy: this.config.strategy
+        });
+    }
+    // ===== LIFECYCLE MANAGEMENT =====
+    async initialize() {
+        if (this._isRunning) {
+            throw new Error('Swarm coordinator already running');
+        }
+        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(', ')}`);
+            }
+            // 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(),
+                type: 'swarm.started',
+                source: this.swarmId.id,
+                data: {
+                    swarmId: this.swarmId
+                },
+                broadcast: true,
+                processed: false
+            });
+            this.logger.info('Swarm coordinator initialized successfully');
+        } catch (error) {
+            this.status = 'failed';
+            this.logger.error('Failed to initialize swarm coordinator', {
+                error
+            });
+            throw error;
+        }
+    }
+    async shutdown() {
+        if (!this._isRunning) {
+            return;
+        }
+        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: {
+                    swarmId: this.swarmId,
+                    metrics: this.metrics,
+                    duration: this.endTime.getTime() - (this.startTime?.getTime() || 0)
+                },
+                broadcast: true,
+                processed: false
+            });
+            this.logger.info('Swarm coordinator shut down successfully');
+        } catch (error) {
+            this.logger.error('Error during swarm coordinator shutdown', {
+                error
+            });
+            throw error;
+        }
+    }
+    async pause() {
+        if (!this._isRunning || this.status === 'paused') {
+            return;
+        }
+        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(),
+            type: 'swarm.paused',
+            source: this.swarmId.id,
+            data: {
+                swarmId: this.swarmId
+            },
+            broadcast: true,
+            processed: false
+        });
+    }
+    async resume() {
+        if (!this._isRunning || this.status !== 'paused') {
+            return;
+        }
+        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(),
+            type: 'swarm.resumed',
+            source: this.swarmId.id,
+            data: {
+                swarmId: this.swarmId
+            },
+            broadcast: true,
+            processed: false
+        });
+    }
+    // ===== OBJECTIVE MANAGEMENT =====
+    async createObjective(name, description, strategy = 'auto', requirements = {}) {
+        const objectiveId = generateId('objective');
+        const objective = {
+            id: objectiveId,
+            name,
+            description,
+            strategy,
+            mode: this.config.mode,
+            requirements: {
+                minAgents: 1,
+                maxAgents: this.config.maxAgents,
+                agentTypes: this.determineRequiredAgentTypes(strategy),
+                estimatedDuration: 60 * 60 * 1000,
+                maxDuration: 4 * 60 * 60 * 1000,
+                qualityThreshold: this.config.qualityThreshold,
+                reviewCoverage: 0.8,
+                testCoverage: 0.7,
+                reliabilityTarget: 0.95,
+                ...requirements
+            },
+            constraints: {
+                minQuality: this.config.qualityThreshold,
+                requiredApprovals: [],
+                allowedFailures: Math.floor(this.config.maxAgents * 0.1),
+                recoveryTime: 5 * 60 * 1000,
+                milestones: []
+            },
+            tasks: [],
+            dependencies: [],
+            status: 'planning',
+            progress: this.initializeProgress(),
+            createdAt: new Date(),
+            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);
+        } 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
+        });
+        return objectiveId;
+    }
+    async executeObjective(objectiveId) {
+        const objective = this.objectives.get(objectiveId);
+        if (!objective) {
+            throw new Error(`Objective not found: ${objectiveId}`);
+        }
+        if (objective.status !== 'planning') {
+            throw new Error(`Objective already ${objective.status}`);
+        }
+        this.logger.info('Executing objective', {
+            objectiveId,
+            name: objective.name
+        });
+        objective.status = 'executing';
+        objective.startedAt = new Date();
+        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
+            });
+            throw error;
+        }
+    }
+    // ===== AGENT MANAGEMENT =====
+    async registerAgent(name, type, capabilities = {}) {
+        const agentId = {
+            id: generateId('agent'),
+            swarmId: this.swarmId.id,
+            type,
+            instance: this.getNextInstanceNumber(type)
+        };
+        const agentState = {
+            id: agentId,
+            name,
+            type,
+            status: 'initializing',
+            capabilities: {
+                // Default capabilities
+                codeGeneration: false,
+                codeReview: false,
+                testing: false,
+                documentation: false,
+                research: false,
+                analysis: false,
+                webSearch: false,
+                apiIntegration: false,
+                fileSystem: true,
+                terminalAccess: true,
+                languages: [],
+                frameworks: [],
+                domains: [],
+                tools: [],
+                maxConcurrentTasks: 3,
+                maxMemoryUsage: SWARM_CONSTANTS.DEFAULT_MEMORY_LIMIT,
+                maxExecutionTime: SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT,
+                reliability: 0.8,
+                speed: 1.0,
+                quality: 0.8,
+                ...capabilities
+            },
+            metrics: {
+                tasksCompleted: 0,
+                tasksFailed: 0,
+                averageExecutionTime: 0,
+                successRate: 0,
+                cpuUsage: 0,
+                memoryUsage: 0,
+                diskUsage: 0,
+                networkUsage: 0,
+                codeQuality: 0,
+                testCoverage: 0,
+                bugRate: 0,
+                userSatisfaction: 0,
+                totalUptime: 0,
+                lastActivity: new Date(),
+                responseTime: 0
+            },
+            workload: 0,
+            health: 1.0,
+            config: {
+                autonomyLevel: 0.7,
+                learningEnabled: true,
+                adaptationEnabled: true,
+                maxTasksPerHour: 10,
+                maxConcurrentTasks: capabilities.maxConcurrentTasks || 3,
+                timeoutThreshold: SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT,
+                reportingInterval: 30000,
+                heartbeatInterval: SWARM_CONSTANTS.DEFAULT_HEARTBEAT_INTERVAL,
+                permissions: this.getDefaultPermissions(type),
+                trustedAgents: [],
+                expertise: {},
+                preferences: {}
+            },
+            environment: {
+                runtime: 'deno',
+                version: '1.0.0',
+                workingDirectory: `/tmp/swarm/${this.swarmId.id}/agents/${agentId.id}`,
+                tempDirectory: `/tmp/swarm/${this.swarmId.id}/agents/${agentId.id}/temp`,
+                logDirectory: `/tmp/swarm/${this.swarmId.id}/agents/${agentId.id}/logs`,
+                apiEndpoints: {},
+                credentials: {},
+                availableTools: [],
+                toolConfigs: {}
+            },
+            endpoints: [],
+            lastHeartbeat: new Date(),
+            taskHistory: [],
+            errorHistory: [],
+            childAgents: [],
+            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,
+            type,
+            capabilities: Object.keys(capabilities)
+        });
+        this.emitSwarmEvent({
+            id: generateId('event'),
+            timestamp: new Date(),
+            type: 'agent.created',
+            source: agentId.id,
+            data: {
+                agent: agentState
+            },
+            broadcast: false,
+            processed: false
+        });
+        return agentId.id;
+    }
+    async unregisterAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        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(),
+            type: 'agent.stopped',
+            source: agentId,
+            data: {
+                agentId
+            },
+            broadcast: false,
+            processed: false
+        });
+    }
+    async startAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        if (agent.status !== 'initializing' && agent.status !== 'offline') {
+            return;
+        }
+        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(),
+                type: 'agent.started',
+                source: agentId,
+                data: {
+                    agent
+                },
+                broadcast: 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),
+                stack: error.stack,
+                context: {
+                    agentId
+                },
+                severity: 'high',
+                resolved: false
+            });
+            this.logger.error('Failed to start agent', {
+                agentId,
+                error
+            });
+            throw error;
+        }
+    }
+    async stopAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        if (agent.status === 'offline' || agent.status === 'terminated') {
+            return;
+        }
+        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
+            });
+        }
+    }
+    async pauseAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent || agent.status !== 'busy') {
+            return;
+        }
+        agent.status = 'paused';
+        this.logger.info('Paused agent', {
+            agentId
+        });
+    }
+    async resumeAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent || agent.status !== 'paused') {
+            return;
+        }
+        agent.status = 'busy';
+        this.logger.info('Resumed agent', {
+            agentId
+        });
+    }
+    // ===== TASK MANAGEMENT =====
+    async createTask(type, name, description, instructions, options = {}) {
+        const taskId = {
+            id: generateId('task'),
+            swarmId: this.swarmId.id,
+            sequence: this.tasks.size + 1,
+            priority: 1
+        };
+        const task = {
+            id: taskId,
+            type,
+            name,
+            description,
+            instructions,
+            requirements: {
+                capabilities: this.getRequiredCapabilities(type),
+                tools: this.getRequiredTools(type),
+                permissions: this.getRequiredPermissions(type),
+                ...options.requirements
+            },
+            constraints: {
+                dependencies: [],
+                dependents: [],
+                conflicts: [],
+                maxRetries: SWARM_CONSTANTS.MAX_RETRIES,
+                timeoutAfter: SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT,
+                ...options.constraints
+            },
+            priority: 'normal',
+            input: options.input || {},
+            context: options.context || {},
+            examples: options.examples || [],
+            status: 'created',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            attempts: [],
+            statusHistory: [
+                {
+                    timestamp: new Date(),
+                    from: 'created',
+                    to: 'created',
+                    reason: 'Task created',
+                    triggeredBy: 'system'
+                }
+            ],
+            ...options
+        };
+        this.tasks.set(taskId.id, task);
+        // Track task in JSON output if enabled
+        this.trackTaskInJsonOutput(task);
+        this.logger.info('Created task', {
+            taskId: taskId.id,
+            type,
+            name,
+            priority: task.priority
+        });
+        this.emitSwarmEvent({
+            id: generateId('event'),
+            timestamp: new Date(),
+            type: 'task.created',
+            source: this.swarmId.id,
+            data: {
+                task
+            },
+            broadcast: false,
+            processed: false
+        });
+        return taskId.id;
+    }
+    async assignTask(taskId, agentId) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        if (task.status !== 'created' && task.status !== 'queued') {
+            throw new Error(`Task cannot be assigned, current status: ${task.status}`);
+        }
+        // Select agent if not specified
+        if (!agentId) {
+            agentId = await this.selectAgentForTask(task);
+            if (!agentId) {
+                throw new Error('No suitable agent available for task');
+            }
+        }
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        if (agent.status !== 'idle') {
+            throw new Error(`Agent not available: ${agent.status}`);
+        }
+        // Assign task
+        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'
+        });
+        this.logger.info('Assigned task', {
+            taskId,
+            agentId,
+            agentName: agent.name
+        });
+        this.emitSwarmEvent({
+            id: generateId('event'),
+            timestamp: new Date(),
+            type: 'task.assigned',
+            source: agentId,
+            data: {
+                task,
+                agent
+            },
+            broadcast: false,
+            processed: false
+        });
+        // Start task execution
+        await this.startTaskExecution(task);
+    }
+    async startTaskExecution(task) {
+        if (!task.assignedTo) {
+            throw new Error('Task not assigned to any agent');
+        }
+        const agent = this.agents.get(task.assignedTo.id);
+        if (!agent) {
+            throw new Error(`Agent not found: ${task.assignedTo.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',
+            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
+        });
+        this.emitSwarmEvent({
+            id: generateId('event'),
+            timestamp: new Date(),
+            type: 'task.started',
+            source: agent.id.id,
+            data: {
+                task,
+                agent,
+                attempt
+            },
+            broadcast: 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);
+        }
+    }
+    async completeTask(taskId, result) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        const agent = task.assignedTo ? this.agents.get(task.assignedTo.id) : null;
+        if (!agent) {
+            throw new Error('Task not assigned to any agent');
+        }
+        this.logger.info('Completing task', {
+            taskId,
+            agentId: agent.id.id
+        });
+        task.status = 'completed';
+        task.completedAt = new Date();
+        task.result = {
+            output: result,
+            artifacts: {},
+            metadata: {},
+            quality: this.assessTaskQuality(task, result),
+            completeness: 1.0,
+            accuracy: 1.0,
+            executionTime: task.completedAt.getTime() - (task.startedAt?.getTime() || 0),
+            resourcesUsed: {},
+            validated: false
+        };
+        // Update attempt
+        const currentAttempt = task.attempts[task.attempts.length - 1];
+        if (currentAttempt) {
+            currentAttempt.completedAt = new Date();
+            currentAttempt.status = 'completed';
+            currentAttempt.result = task.result;
+        }
+        // Update agent state
+        agent.status = 'idle';
+        agent.currentTask = undefined;
+        agent.metrics.tasksCompleted++;
+        agent.metrics.lastActivity = new Date();
+        agent.taskHistory.push(task.id);
+        // Update agent metrics
+        this.updateAgentMetrics(agent, task);
+        // Update status history
+        task.statusHistory.push({
+            timestamp: new Date(),
+            from: 'running',
+            to: 'completed',
+            reason: 'Task completed successfully',
+            triggeredBy: agent.id
+        });
+        this.emitSwarmEvent({
+            id: generateId('event'),
+            timestamp: new Date(),
+            type: 'task.completed',
+            source: agent.id.id,
+            data: {
+                task,
+                agent,
+                result: task.result
+            },
+            broadcast: false,
+            processed: false
+        });
+        // Check for dependent tasks
+        await this.processDependentTasks(task);
+    }
+    async failTask(taskId, error) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        const agent = task.assignedTo ? this.agents.get(task.assignedTo.id) : null;
+        if (!agent) {
+            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)
+        });
+        task.error = {
+            type: error.constructor.name,
+            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)
+        };
+        // Update attempt
+        const currentAttempt = task.attempts[task.attempts.length - 1];
+        if (currentAttempt) {
+            currentAttempt.completedAt = new Date();
+            currentAttempt.status = 'failed';
+            currentAttempt.error = task.error;
+        }
+        // Update agent state
+        agent.status = 'idle';
+        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),
+            stack: error.stack,
+            context: {
+                taskId
+            },
+            severity: 'medium',
+            resolved: false
+        });
+        // Determine if we should retry
+        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
+            });
+            this.emitSwarmEvent({
+                id: generateId('event'),
+                timestamp: new Date(),
+                type: 'task.retried',
+                source: agent.id.id,
+                data: {
+                    task,
+                    error: task.error,
+                    attempt: task.attempts.length
+                },
+                broadcast: false,
+                processed: false
+            });
+            // Schedule retry with exponential backoff
+            const retryDelay = Math.pow(2, task.attempts.length) * 1000;
+            setTimeout(()=>{
+                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
+            });
+            this.emitSwarmEvent({
+                id: generateId('event'),
+                timestamp: new Date(),
+                type: 'task.failed',
+                source: agent.id.id,
+                data: {
+                    task,
+                    error: task.error
+                },
+                broadcast: false,
+                processed: false
+            });
+            // Handle failure cascade
+            await this.handleTaskFailureCascade(task);
+        }
+    }
+    async cancelTask(taskId, reason) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        const agent = task.assignedTo ? this.agents.get(task.assignedTo.id) : null;
+        this.logger.info('Cancelling task', {
+            taskId,
+            reason
+        });
+        task.status = 'cancelled';
+        task.completedAt = new Date();
+        if (agent) {
+            agent.status = 'idle';
+            agent.currentTask = undefined;
+        }
+        // Update status history
+        task.statusHistory.push({
+            timestamp: new Date(),
+            from: task.statusHistory[task.statusHistory.length - 1].to,
+            to: 'cancelled',
+            reason: `Task cancelled: ${reason}`,
+            triggeredBy: 'system'
+        });
+        this.emitSwarmEvent({
+            id: generateId('event'),
+            timestamp: new Date(),
+            type: 'task.cancelled',
+            source: this.swarmId.id,
+            data: {
+                task,
+                reason
+            },
+            broadcast: false,
+            processed: false
+        });
+    }
+    // ===== ADVANCED FEATURES =====
+    async selectAgentForTask(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)=>({
+                agent,
+                score: this.calculateAgentScore(agent, task)
+            }));
+        // Sort by score (highest first)
+        scoredAgents.sort((a, b)=>b.score - a.score);
+        return scoredAgents[0].agent.id.id;
+    }
+    calculateAgentScore(agent, task) {
+        let score = 0;
+        // Capability match (40% weight)
+        const capabilityMatch = this.calculateCapabilityMatch(agent, task);
+        score += capabilityMatch * 0.4;
+        // Performance history (30% weight)
+        const performanceScore = agent.metrics.successRate * agent.capabilities.reliability;
+        score += performanceScore * 0.3;
+        // Current workload (20% weight)
+        const workloadScore = 1 - agent.workload;
+        score += workloadScore * 0.2;
+        // Quality rating (10% weight)
+        score += agent.capabilities.quality * 0.1;
+        return score;
+    }
+    calculateCapabilityMatch(agent, task) {
+        const requiredCapabilities = task.requirements.capabilities;
+        let matches = 0;
+        let total = requiredCapabilities.length;
+        for (const capability of requiredCapabilities){
+            if (this.agentHasCapability(agent, capability)) {
+                matches++;
+            }
+        }
+        return total > 0 ? matches / total : 1.0;
+    }
+    agentHasCapability(agent, capability) {
+        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);
+        }
+    }
+    agentCanHandleTask(agent, task) {
+        // Check if agent type is suitable
+        if (task.requirements.agentType && agent.type !== task.requirements.agentType) {
+            return false;
+        }
+        // Check if agent has required capabilities
+        for (const capability of task.requirements.capabilities){
+            if (!this.agentHasCapability(agent, capability)) {
+                return false;
+            }
+        }
+        // Check reliability requirement
+        if (task.requirements.minReliability && agent.capabilities.reliability < task.requirements.minReliability) {
+            return false;
+        }
+        // Check if agent has capacity
+        if (agent.workload >= 1.0) {
+            return false;
+        }
+        return true;
+    }
+    // ===== HELPER METHODS =====
+    generateSwarmId() {
+        return {
+            id: generateId('swarm'),
+            timestamp: Date.now(),
+            namespace: 'default'
+        };
+    }
+    mergeWithDefaults(config) {
+        return {
+            name: 'Unnamed Swarm',
+            description: 'Auto-generated swarm',
+            version: '1.0.0',
+            mode: 'centralized',
+            strategy: 'auto',
+            coordinationStrategy: {
+                name: 'default',
+                description: 'Default coordination strategy',
+                agentSelection: 'capability-based',
+                taskScheduling: 'priority',
+                loadBalancing: 'work-stealing',
+                faultTolerance: 'retry',
+                communication: 'event-driven'
+            },
+            maxAgents: 10,
+            maxTasks: 100,
+            maxDuration: 4 * 60 * 60 * 1000,
+            resourceLimits: {
+                memory: SWARM_CONSTANTS.DEFAULT_MEMORY_LIMIT,
+                cpu: SWARM_CONSTANTS.DEFAULT_CPU_LIMIT,
+                disk: SWARM_CONSTANTS.DEFAULT_DISK_LIMIT
+            },
+            qualityThreshold: SWARM_CONSTANTS.DEFAULT_QUALITY_THRESHOLD,
+            reviewRequired: true,
+            testingRequired: true,
+            monitoring: {
+                metricsEnabled: true,
+                loggingEnabled: true,
+                tracingEnabled: false,
+                metricsInterval: 10000,
+                heartbeatInterval: SWARM_CONSTANTS.DEFAULT_HEARTBEAT_INTERVAL,
+                healthCheckInterval: 30000,
+                retentionPeriod: 24 * 60 * 60 * 1000,
+                maxLogSize: 100 * 1024 * 1024,
+                maxMetricPoints: 10000,
+                alertingEnabled: true,
+                alertThresholds: {
+                    errorRate: 0.1,
+                    responseTime: 5000,
+                    memoryUsage: 0.8,
+                    cpuUsage: 0.8
+                },
+                exportEnabled: false,
+                exportFormat: 'json',
+                exportDestination: '/tmp/swarm-metrics'
+            },
+            memory: {
+                namespace: 'default',
+                partitions: [],
+                permissions: {
+                    read: 'swarm',
+                    write: 'team',
+                    delete: 'private',
+                    share: 'team'
+                },
+                persistent: true,
+                backupEnabled: true,
+                distributed: false,
+                consistency: 'eventual',
+                cacheEnabled: true,
+                compressionEnabled: false
+            },
+            security: {
+                authenticationRequired: false,
+                authorizationRequired: false,
+                encryptionEnabled: false,
+                defaultPermissions: [
+                    'read',
+                    'write'
+                ],
+                adminRoles: [
+                    'admin',
+                    'coordinator'
+                ],
+                auditEnabled: true,
+                auditLevel: 'info',
+                inputValidation: true,
+                outputSanitization: true
+            },
+            performance: {
+                maxConcurrency: 10,
+                defaultTimeout: SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT,
+                cacheEnabled: true,
+                cacheSize: 100,
+                cacheTtl: 3600000,
+                optimizationEnabled: true,
+                adaptiveScheduling: true,
+                predictiveLoading: false,
+                resourcePooling: true,
+                connectionPooling: true,
+                memoryPooling: false
+            },
+            ...config
+        };
+    }
+    initializeMetrics() {
+        return {
+            throughput: 0,
+            latency: 0,
+            efficiency: 0,
+            reliability: 0,
+            averageQuality: 0,
+            defectRate: 0,
+            reworkRate: 0,
+            resourceUtilization: {},
+            costEfficiency: 0,
+            agentUtilization: 0,
+            agentSatisfaction: 0,
+            collaborationEffectiveness: 0,
+            scheduleVariance: 0,
+            deadlineAdherence: 0
+        };
+    }
+    initializeProgress() {
+        return {
+            totalTasks: 0,
+            completedTasks: 0,
+            failedTasks: 0,
+            runningTasks: 0,
+            estimatedCompletion: new Date(),
+            timeRemaining: 0,
+            percentComplete: 0,
+            averageQuality: 0,
+            passedReviews: 0,
+            passedTests: 0,
+            resourceUtilization: {},
+            costSpent: 0,
+            activeAgents: 0,
+            idleAgents: 0,
+            busyAgents: 0
+        };
+    }
+    // ===== EVENT HANDLING =====
+    setupEventHandlers() {
+        // Handle agent heartbeats
+        this.on('agent.heartbeat', (data)=>{
+            const agent = this.agents.get(data.agentId);
+            if (agent) {
+                agent.lastHeartbeat = new Date();
+                agent.health = data.health || 1.0;
+                agent.metrics = {
+                    ...agent.metrics,
+                    ...data.metrics
+                };
+            }
+        });
+        // Handle task completion events
+        this.on('task.completed', (data)=>{
+            this.updateSwarmMetrics();
+            this.checkObjectiveCompletion();
+        });
+        // Handle task failure events
+        this.on('task.failed', (data)=>{
+            this.updateSwarmMetrics();
+            this.checkObjectiveFailure(data.task);
+        });
+        // Handle agent errors
+        this.on('agent.error', (data)=>{
+            this.handleAgentError(data.agentId, data.error);
+        });
+    }
+    // ===== SWARM EVENT EMITTER IMPLEMENTATION =====
+    emitSwarmEvent(event) {
+        this.events.push(event);
+        // Limit event history
+        if (this.events.length > 1000) {
+            this.events = this.events.slice(-500);
+        }
+        return this.emit(event.type, event);
+    }
+    emitSwarmEvents(events) {
+        let success = true;
+        for (const event of events){
+            if (!this.emitSwarmEvent(event)) {
+                success = false;
+            }
+        }
+        return success;
+    }
+    onSwarmEvent(type, handler) {
+        return this.on(type, handler);
+    }
+    offSwarmEvent(type, handler) {
+        return this.off(type, handler);
+    }
+    filterEvents(predicate) {
+        return this.events.filter(predicate);
+    }
+    correlateEvents(correlationId) {
+        return this.events.filter((event)=>event.correlationId === correlationId);
+    }
+    // ===== PUBLIC API METHODS =====
+    getSwarmId() {
+        return this.swarmId;
+    }
+    getStatus() {
+        return this.status;
+    }
+    getAgents() {
+        return Array.from(this.agents.values());
+    }
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    getTasks() {
+        return Array.from(this.tasks.values());
+    }
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    getObjectives() {
+        return Array.from(this.objectives.values());
+    }
+    getObjective(objectiveId) {
+        return this.objectives.get(objectiveId);
+    }
+    getMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    getEvents() {
+        return [
+            ...this.events
+        ];
+    }
+    isRunning() {
+        return this._isRunning;
+    }
+    getUptime() {
+        if (!this.startTime) return 0;
+        const endTime = this.endTime || new Date();
+        return endTime.getTime() - this.startTime.getTime();
+    }
+    getSwarmStatus() {
+        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;
+        return {
+            status: this.status,
+            objectives: this.objectives.size,
+            tasks: {
+                completed: completedTasks,
+                failed: failedTasks,
+                total: tasks.length
+            },
+            agents: {
+                total: this.agents.size
+            }
+        };
+    }
+    // ===== STUB METHODS (TO BE IMPLEMENTED) =====
+    async validateConfiguration() {
+        // Implementation needed
+        return {
+            valid: true,
+            errors: [],
+            warnings: [],
+            validatedAt: new Date(),
+            validator: 'SwarmCoordinator',
+            context: {}
+        };
+    }
+    async initializeSubsystems() {
+    // Implementation needed
+    }
+    startBackgroundProcesses() {
+        // Start heartbeat monitoring
+        this.heartbeatTimer = setInterval(()=>{
+            this.processHeartbeats();
+        }, this.config.monitoring.heartbeatInterval);
+        // Start performance monitoring
+        this.monitoringTimer = setInterval(()=>{
+            this.updateSwarmMetrics();
+        }, this.config.monitoring.metricsInterval);
+        // Start cleanup process
+        this.cleanupTimer = setInterval(()=>{
+            this.performCleanup();
+        }, 60000); // Every minute
+    }
+    stopBackgroundProcesses() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
+        if (this.monitoringTimer) {
+            clearInterval(this.monitoringTimer);
+            this.monitoringTimer = undefined;
+        }
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+        // Stop all execution intervals
+        if (this.executionIntervals) {
+            for (const [objectiveId, interval] of this.executionIntervals){
+                clearInterval(interval);
+            }
+            this.executionIntervals.clear();
+        }
+    }
+    async stopAllAgents() {
+        const stopPromises = Array.from(this.agents.keys()).map((agentId)=>this.stopAgent(agentId));
+        await Promise.allSettled(stopPromises);
+    }
+    async completeRunningTasks() {
+        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));
+        }
+        // Cancel any remaining running tasks
+        for (const task of runningTasks){
+            if (task.status === 'running') {
+                await this.cancelTask(task.id.id, 'Swarm shutdown');
+            }
+        }
+    }
+    async saveState() {
+    // Implementation needed - save swarm state to persistence layer
+    }
+    determineRequiredAgentTypes(strategy) {
+        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'
+                ];
+        }
+    }
+    getAgentTypeInstructions(agentType) {
+        switch(agentType){
+            case 'coder':
+                return '- Focus on implementation, code quality, and best practices\n- Create clean, maintainable code\n- Consider architecture and design patterns';
+            case 'tester':
+                return '- Focus on testing, edge cases, and quality assurance\n- Create comprehensive test suites\n- Identify potential bugs and issues';
+            case 'analyst':
+                return '- Focus on analysis, research, and understanding\n- Break down complex problems\n- Provide insights and recommendations';
+            case 'researcher':
+                return '- Focus on gathering information and best practices\n- Research existing solutions and patterns\n- Document findings and recommendations';
+            case 'reviewer':
+                return '- Focus on code review and quality checks\n- Identify improvements and optimizations\n- Ensure standards compliance';
+            case 'coordinator':
+                return '- Focus on coordination and integration\n- Ensure all parts work together\n- Manage dependencies and interfaces';
+            case 'monitor':
+                return '- Focus on monitoring and observability\n- Set up logging and metrics\n- Ensure system health tracking';
+            default:
+                return '- Execute the task to the best of your ability\n- Follow best practices for your domain';
+        }
+    }
+    getAgentCapabilities(agentType) {
+        switch(agentType){
+            case 'coder':
+                return [
+                    'code-generation',
+                    'file-system',
+                    'debugging'
+                ];
+            case 'tester':
+                return [
+                    'testing',
+                    'code-generation',
+                    'analysis'
+                ];
+            case 'analyst':
+                return [
+                    'analysis',
+                    'documentation',
+                    'research'
+                ];
+            case 'researcher':
+                return [
+                    'research',
+                    'documentation',
+                    'analysis'
+                ];
+            case 'reviewer':
+                return [
+                    'code-review',
+                    'analysis',
+                    'documentation'
+                ];
+            case 'coordinator':
+                return [
+                    'coordination',
+                    'analysis',
+                    'documentation'
+                ];
+            case 'monitor':
+                return [
+                    'monitoring',
+                    'analysis',
+                    'documentation'
+                ];
+            default:
+                return [
+                    'analysis',
+                    'documentation'
+                ];
+        }
+    }
+    async decomposeObjective(objective) {
+        // Decompose objective into tasks with clear instructions for Claude
+        this.logger.info('Decomposing objective', {
+            objectiveId: objective.id,
+            description: objective.description
+        });
+        const tasks = [];
+        // Extract target directory from objective
+        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;
+        // 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', {
+                agentTypes,
+                mode: this.config.mode
+            });
+            for (const agentType of agentTypes){
+                const taskId = this.createTaskForObjective(`${agentType}-task`, agentType, {
+                    title: `${agentType.charAt(0).toUpperCase() + agentType.slice(1)} Agent Task`,
+                    description: `${agentType} agent executing: ${objective.description}`,
+                    instructions: `You are a ${agentType} agent. Please execute the following task from your perspective:
+
+${objective.description}
+
+${targetPath ? `Target Directory: ${targetPath}` : ''}
+
+As a ${agentType} agent, focus on aspects relevant to your role:
+${this.getAgentTypeInstructions(agentType)}
+
+Work independently but be aware that other agents are working on this same objective from their perspectives.`,
+                    priority: 'high',
+                    estimatedDuration: 10 * 60 * 1000,
+                    requiredCapabilities: this.getAgentCapabilities(agentType)
+                });
+                tasks.push(taskId);
+            }
+        } else if (objective.strategy === 'development') {
+            // Task 1: Analyze and Plan
+            const task1 = this.createTaskForObjective('analyze-requirements', 'analysis', {
+                title: 'Analyze Requirements and Plan Implementation',
+                description: `Analyze the requirements and create a plan for: ${objective.description}`,
+                instructions: `Please analyze the following request and create a detailed implementation plan:
+
+Request: ${objective.description}
+
+Target Directory: ${targetPath || 'Not specified - determine appropriate location'}
+
+Your analysis should include:
+1. Understanding of what needs to be built
+2. Technology choices and rationale
+3. Project structure and file organization
+4. Key components and their responsibilities
+5. Any external dependencies needed
+
+Please provide a clear, structured plan that the next tasks can follow.`,
+                priority: 'high',
+                estimatedDuration: 5 * 60 * 1000,
+                requiredCapabilities: [
+                    'analysis',
+                    'documentation'
+                ]
+            });
+            tasks.push(task1);
+            // Task 2: Implementation
+            const task2 = this.createTaskForObjective('create-implementation', 'coding', {
+                title: 'Implement the Solution',
+                description: `Create the implementation for: ${objective.description}`,
+                instructions: `Please implement the following request:
+
+Request: ${objective.description}
+
+Target Directory: ${targetPath || 'Create in an appropriate location'}
+
+Based on the analysis from the previous task, please:
+1. Create all necessary files and directories
+2. Implement the core functionality as requested
+3. Ensure the code is well-structured and follows best practices
+4. Include appropriate error handling
+5. Add any necessary configuration files (package.json, requirements.txt, etc.)
+
+Focus on creating a working implementation that matches the user's request exactly.`,
+                priority: 'high',
+                estimatedDuration: 10 * 60 * 1000,
+                requiredCapabilities: [
+                    'code-generation',
+                    'file-system'
+                ],
+                dependencies: [
+                    task1.id.id
+                ]
+            });
+            tasks.push(task2);
+            // Task 3: Testing
+            const task3 = this.createTaskForObjective('write-tests', 'testing', {
+                title: 'Create Tests',
+                description: `Write tests for the implementation`,
+                instructions: `Please create comprehensive tests for the implementation created in the previous task.
+
+Target Directory: ${targetPath || 'Use the same directory as the implementation'}
+
+Create appropriate test files that:
+1. Test the main functionality
+2. Cover edge cases
+3. Ensure the implementation works as expected
+4. Use appropriate testing frameworks for the technology stack
+5. Include both unit tests and integration tests where applicable`,
+                priority: 'medium',
+                estimatedDuration: 5 * 60 * 1000,
+                requiredCapabilities: [
+                    'testing',
+                    'code-generation'
+                ],
+                dependencies: [
+                    task2.id.id
+                ]
+            });
+            tasks.push(task3);
+            // Task 4: Documentation
+            const task4 = this.createTaskForObjective('create-documentation', 'documentation', {
+                title: 'Create Documentation',
+                description: `Document the implementation`,
+                instructions: `Please create comprehensive documentation for the implemented solution.
+
+Target Directory: ${targetPath || 'Use the same directory as the implementation'}
+
+Create documentation that includes:
+1. README.md with project overview, setup instructions, and usage examples
+2. API documentation (if applicable)
+3. Configuration options
+4. Architecture overview
+5. Deployment instructions (if applicable)
+6. Any other relevant documentation
+
+Make sure the documentation is clear, complete, and helps users understand and use the implementation.`,
+                priority: 'medium',
+                estimatedDuration: 5 * 60 * 1000,
+                requiredCapabilities: [
+                    'documentation'
+                ],
+                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:
+
+${objective.description}
+
+${targetPath ? `Target Directory: ${targetPath}` : ''}
+
+Please analyze what is being requested and implement it appropriately. This may involve:
+- Creating files and directories
+- Writing code
+- Setting up configurations
+- Creating documentation
+- Any other tasks necessary to fulfill the request
+
+Ensure your implementation is complete, well-structured, and follows best practices.`,
+                priority: 'high',
+                estimatedDuration: 15 * 60 * 1000,
+                requiredCapabilities: [
+                    'code-generation',
+                    'file-system',
+                    'documentation'
+                ]
+            }));
+        }
+        this.logger.info('Objective decomposed', {
+            objectiveId: objective.id,
+            taskCount: tasks.length
+        });
+        return tasks;
+    }
+    createTaskForObjective(id, type, params) {
+        const taskId = {
+            id: generateId('task'),
+            swarmId: this.swarmId.id,
+            sequence: this.tasks.size + 1,
+            priority: 1
+        };
+        return {
+            id: taskId,
+            type,
+            name: params.title,
+            description: params.description,
+            instructions: params.description,
+            requirements: {
+                capabilities: params.requiredCapabilities || [],
+                tools: this.getRequiredTools(type),
+                permissions: this.getRequiredPermissions(type)
+            },
+            constraints: {
+                dependencies: params.dependencies || [],
+                dependents: [],
+                conflicts: [],
+                maxRetries: SWARM_CONSTANTS.MAX_RETRIES,
+                timeoutAfter: params.estimatedDuration || SWARM_CONSTANTS.DEFAULT_TASK_TIMEOUT
+            },
+            priority: params.priority || 'medium',
+            input: {
+                description: params.description,
+                objective: params.description
+            },
+            context: {
+                objectiveId: id,
+                targetDir: params.targetDir
+            },
+            examples: [],
+            status: 'created',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            attempts: [],
+            statusHistory: [
+                {
+                    timestamp: new Date(),
+                    from: 'created',
+                    to: 'created',
+                    reason: 'Task created',
+                    triggeredBy: 'system'
+                }
+            ]
+        };
+    }
+    analyzeDependencies(tasks) {
+        // Implementation needed - analyze task dependencies
+        return [];
+    }
+    convertDependenciesToTaskDependencies(dependencies) {
+        // Convert decomposition dependencies to task dependencies format
+        const result = [];
+        dependencies.forEach((deps, taskId)=>{
+            deps.forEach((dependsOn)=>{
+                result.push({
+                    taskId,
+                    dependsOn,
+                    type: 'sequential'
+                });
+            });
+        });
+        return result;
+    }
+    async ensureRequiredAgents(objective) {
+    // Implementation needed - ensure required agents are available
+    }
+    async scheduleInitialTasks(objective) {
+        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
+        ];
+        let objectiveTargetDir = null;
+        for (const pattern of targetDirPatterns){
+            const match = objective.description.match(pattern);
+            if (match) {
+                objectiveTargetDir = match[1] || match[0];
+                break;
+            }
+        }
+        // Add all tasks to the tasks map
+        for (const task of objective.tasks){
+            task.context.objectiveId = objective.id;
+            // Propagate target directory to all tasks
+            if (objectiveTargetDir && !task.context.targetDir) {
+                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);
+        this.logger.info('Found initial tasks without dependencies', {
+            count: initialTasks.length,
+            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',
+                to: 'queued',
+                reason: 'Task queued for execution',
+                triggeredBy: 'system'
+            });
+            // Emit task queued event
+            this.emitSwarmEvent({
+                id: generateId('event'),
+                timestamp: new Date(),
+                type: 'task.queued',
+                source: this.swarmId.id,
+                data: {
+                    task
+                },
+                broadcast: false,
+                processed: false
+            });
+        }
+        // Update objective progress
+        objective.progress.totalTasks = objective.tasks.length;
+        objective.progress.runningTasks = 0;
+        objective.progress.completedTasks = 0;
+        objective.progress.failedTasks = 0;
+    }
+    startTaskExecutionLoop(objective) {
+        this.logger.info('Starting task execution loop for objective', {
+            objectiveId: objective.id
+        });
+        // Create an interval to process queued tasks
+        const executionInterval = setInterval(async ()=>{
+            try {
+                // Check if objective is still executing
+                if (objective.status !== 'executing') {
+                    clearInterval(executionInterval);
+                    return;
+                }
+                // Find queued tasks
+                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');
+                if (queuedTasks.length > 0 && idleAgents.length > 0) {
+                    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));
+                    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);
+                        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');
+                // Find tasks that can now be queued (dependencies met)
+                const pendingTasks = Array.from(this.tasks.values()).filter((task)=>task.context?.objectiveId === objective.id && task.status === 'created' && 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',
+                        to: 'queued',
+                        reason: 'Dependencies met, task queued',
+                        triggeredBy: 'system'
+                    });
+                    this.emitSwarmEvent({
+                        id: generateId('event'),
+                        timestamp: new Date(),
+                        type: 'task.queued',
+                        source: this.swarmId.id,
+                        data: {
+                            task
+                        },
+                        broadcast: 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 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,
+                                runtime: Math.round(runtime / 1000),
+                                timeout: Math.round(timeout / 1000)
+                            });
+                            // Mark task as failed due to timeout
+                            task.status = 'failed';
+                            task.completedAt = new Date();
+                            task.error = {
+                                type: 'TimeoutError',
+                                message: `Task exceeded timeout of ${timeout}ms`,
+                                code: 'TASK_TIMEOUT',
+                                context: {
+                                    taskId: task.id.id,
+                                    runtime
+                                },
+                                recoverable: true,
+                                retryable: true
+                            };
+                            // Update agent state if assigned
+                            if (task.assignedTo) {
+                                const agent = this.agents.get(task.assignedTo.id);
+                                if (agent) {
+                                    agent.status = 'idle';
+                                    agent.currentTask = undefined;
+                                    agent.metrics.tasksFailed++;
+                                }
+                            }
+                            // Emit timeout event
+                            this.emitSwarmEvent({
+                                id: generateId('event'),
+                                timestamp: new Date(),
+                                type: 'task.failed',
+                                source: this.swarmId.id,
+                                data: {
+                                    task,
+                                    reason: 'timeout'
+                                },
+                                broadcast: false,
+                                processed: false
+                            });
+                        }
+                    }
+                }
+                // Update objective progress
+                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;
+                // Check if objective is complete
+                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', {
+                        objectiveId: objective.id,
+                        status: objective.status,
+                        completedTasks: objective.progress.completedTasks,
+                        failedTasks: objective.progress.failedTasks
+                    });
+                    this.emitSwarmEvent({
+                        id: generateId('event'),
+                        timestamp: new Date(),
+                        type: objective.status === 'completed' ? 'objective.completed' : 'objective.failed',
+                        source: this.swarmId.id,
+                        data: {
+                            objective
+                        },
+                        broadcast: true,
+                        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);
+    }
+    taskDependenciesMet(task, completedTasks) {
+        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)=>{
+            // Handle both string and TaskId object dependencies
+            const depId = typeof dep === 'string' ? dep : dep.id;
+            return completedTaskIds.includes(depId);
+        });
+    }
+    getNextInstanceNumber(type) {
+        const agentsOfType = Array.from(this.agents.values()).filter((agent)=>agent.type === type);
+        return agentsOfType.length + 1;
+    }
+    getDefaultPermissions(type) {
+        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'
+                ];
+        }
+    }
+    async initializeAgentCapabilities(agent) {
+        // Set capabilities based on agent type
+        switch(agent.type){
+            case 'coordinator':
+                agent.capabilities.codeGeneration = false;
+                agent.capabilities.codeReview = true;
+                agent.capabilities.testing = false;
+                agent.capabilities.documentation = true;
+                agent.capabilities.research = true;
+                agent.capabilities.analysis = true;
+                break;
+            case 'coder':
+                agent.capabilities.codeGeneration = true;
+                agent.capabilities.codeReview = true;
+                agent.capabilities.testing = true;
+                agent.capabilities.documentation = true;
+                break;
+            case 'researcher':
+                agent.capabilities.research = true;
+                agent.capabilities.analysis = true;
+                agent.capabilities.webSearch = true;
+                agent.capabilities.documentation = true;
+                break;
+            case 'analyst':
+                agent.capabilities.analysis = true;
+                agent.capabilities.research = true;
+                agent.capabilities.documentation = true;
+                break;
+            case 'reviewer':
+                agent.capabilities.codeReview = true;
+                agent.capabilities.testing = true;
+                agent.capabilities.documentation = true;
+                break;
+            case 'tester':
+                agent.capabilities.testing = true;
+                agent.capabilities.codeReview = true;
+                break;
+        }
+    }
+    async initializeAgentEnvironment(agent) {
+    // Implementation needed - setup agent environment
+    }
+    startAgentHeartbeat(agent) {
+    // Implementation needed - start agent heartbeat
+    }
+    stopAgentHeartbeat(agent) {
+    // Implementation needed - stop agent heartbeat
+    }
+    async cleanupAgentEnvironment(agent) {
+    // Implementation needed - cleanup agent environment
+    }
+    getRequiredCapabilities(type) {
+        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 [];
+        }
+    }
+    getRequiredTools(type) {
+        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 [];
+        }
+    }
+    getRequiredPermissions(type) {
+        switch(type){
+            case 'coding':
+                return [
+                    'read',
+                    'write',
+                    'execute'
+                ];
+            case 'testing':
+                return [
+                    'read',
+                    'execute'
+                ];
+            case 'research':
+                return [
+                    'read',
+                    'network'
+                ];
+            default:
+                return [
+                    'read'
+                ];
+        }
+    }
+    async executeTaskWithAgent(task, agent) {
+        this.logger.info('Executing task with agent', {
+            taskId: task.id.id,
+            taskName: task.name,
+            agentId: agent.id.id,
+            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({
+                logger: this.logger,
+                claudeFlowPath: getClaudeFlowBin(),
+                enableSparc: true,
+                verbose: this.config.logging?.level === 'debug',
+                timeoutMinutes: this.config.taskTimeoutMinutes
+            });
+            const result = await executor.executeTask(task, agent, targetDir);
+            this.logger.info('Task execution completed', {
+                taskId: task.id.id,
+                success: true,
+                outputLength: JSON.stringify(result).length
+            });
+            return result;
+        } catch (error) {
+            this.logger.error('Task execution failed', {
+                taskId: task.id.id,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    createExecutionPrompt(task) {
+        // 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;
+    }
+    extractTargetDirectory(task) {
+        // Try multiple patterns to find the target directory
+        const patterns = [
+            /in\s+([^\s]+\/?)$/i,
+            /(?:in|to|at)\s+([^\s]+\/[^\s]+)/i,
+            /([^\s]+\/[^\s]+)$/,
+            /examples\/[^\s]+/i
+        ];
+        let targetDir = null;
+        // First check task description and input
+        for (const pattern of patterns){
+            const descMatch = task.description.match(pattern);
+            const inputMatch = task.input?.objective?.match(pattern);
+            if (descMatch || inputMatch) {
+                targetDir = (descMatch || inputMatch)[descMatch ? 1 : 0];
+                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);
+            if (objective) {
+                for (const pattern of patterns){
+                    const match = objective.description.match(pattern);
+                    if (match) {
+                        targetDir = match[1] || match[0];
+                        break;
+                    }
+                }
+            }
+        }
+        if (targetDir) {
+            // Clean up the target directory
+            targetDir = targetDir.replace(/\s+.*$/, '');
+            // Resolve relative to current directory
+            if (!targetDir.startsWith('/')) {
+                targetDir = `${getClaudeFlowRoot()}/${targetDir}`;
+            }
+        }
+        return targetDir;
+    }
+    async executeClaudeTask(task, agent, prompt, targetDir) {
+        // 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');
+        // 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
+        // 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', {
+                args: [
+                    'claude'
+                ],
+                stdout: 'piped',
+                stderr: 'piped'
+            });
+            const checkResult = await checkCommand.output();
+            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', {
+                args: claudeArgs,
+                cwd: targetDir || process.cwd(),
+                env: {
+                    ...Deno.env.toObject(),
+                    CLAUDE_INSTANCE_ID: instanceId,
+                    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_NAMESPACE: `swarm-${this.swarmId.id}`
+                },
+                stdin: 'null',
+                stdout: 'piped',
+                stderr: 'piped'
+            });
+            this.logger.info('Spawning Claude agent for task', {
+                taskId: task.id.id,
+                agentId: agent.id.id,
+                instanceId,
+                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
+                });
+                return {
+                    success: true,
+                    output,
+                    instanceId,
+                    targetDir
+                };
+            } else {
+                const errorOutput = new TextDecoder().decode(stderr);
+                this.logger.error(`Claude agent failed with code ${code}`, {
+                    taskId: task.id.id,
+                    error: errorOutput
+                });
+                throw new Error(`Claude execution failed: ${errorOutput}`);
+            }
+        } catch (error) {
+            this.logger.error('Failed to execute Claude agent', {
+                taskId: task.id.id,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    determineToolsForTask(task, agent) {
+        const tools = new Set();
+        // Basic tools for all tasks
+        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');
+                break;
+            case 'testing':
+                tools.add('Test');
+                tools.add('View');
+                break;
+            case 'documentation':
+                tools.add('Write');
+                tools.add('Create');
+                break;
+            case 'analysis':
+                tools.add('Analyze');
+                tools.add('Search');
+                break;
+            case 'research':
+                tools.add('WebSearch');
+                tools.add('Search');
+                break;
+        }
+        // Add tools based on agent capabilities
+        if (agent.capabilities.fileSystem) {
+            tools.add('FileSystem');
+        }
+        if (agent.capabilities.terminalAccess) {
+            tools.add('Terminal');
+        }
+        if (agent.capabilities.webSearch) {
+            tools.add('WebSearch');
+        }
+        if (agent.capabilities.apiIntegration) {
+            tools.add('API');
+        }
+        return Array.from(tools);
+    }
+    async simulateTaskExecution(task, agent, prompt) {
+        // 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|to|at)\s+([^\s]+\/[^\s]+)/i,
+            /([^\s]+\/[^\s]+)$/,
+            /examples\/[^\s]+/i
+        ];
+        let targetDir = null;
+        for (const pattern of patterns){
+            const descMatch = task.description.match(pattern);
+            const inputMatch = task.input?.objective?.match(pattern);
+            if (descMatch || inputMatch) {
+                targetDir = (descMatch || inputMatch)[descMatch ? 1 : 0];
+                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', {
+                original: task.description,
+                targetDir,
+                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)}`);
+        }
+    }
+    async executeCodeGenerationTask(task, workDir, agent) {
+        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 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);
+        } else if (isPython && isRestAPI) {
+            // Create a Python REST API (FastAPI)
+            return await this.createPythonRestAPI(task, workDir);
+        } else if (isRestAPI) {
+            // Create a REST API application
+            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();
+const port = process.env.PORT || 3000;
+
+// Middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ 
+    status: 'healthy',
+    service: 'REST API',
+    swarmId: '${this.swarmId.id}',
+    created: '${new Date().toISOString()}'
+  });
+});
+
+// Sample endpoints
+app.get('/api/v1/items', (req, res) => {
+  res.json({
+    items: [
+      { id: 1, name: 'Item 1', description: 'First item' },
+      { id: 2, name: 'Item 2', description: 'Second item' }
+    ],
+    total: 2
+  });
+});
+
+app.get('/api/v1/items/:id', (req, res) => {
+  const id = parseInt(req.params.id);
+  res.json({
+    id,
+    name: \`Item \${id}\`,
+    description: \`Description for item \${id}\`
+  });
+});
+
+app.post('/api/v1/items', (req, res) => {
+  const newItem = {
+    id: Date.now(),
+    ...req.body,
+    createdAt: new Date().toISOString()
+  };
+  res.status(201).json(newItem);
+});
+
+app.put('/api/v1/items/:id', (req, res) => {
+  const id = parseInt(req.params.id);
+  const updatedItem = {
+    id,
+    ...req.body,
+    updatedAt: new Date().toISOString()
+  };
+  res.json(updatedItem);
+});
+
+app.delete('/api/v1/items/:id', (req, res) => {
+  const id = parseInt(req.params.id);
+  res.json({ message: \`Item \${id} deleted successfully\` });
+});
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json({ error: 'Internal server error' });
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(\`REST API server running on port \${port}\`);
+  console.log('Created by Claude Flow Swarm');
+});
+
+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',
+                scripts: {
+                    start: 'node server.js',
+                    dev: 'nodemon server.js',
+                    test: 'jest'
+                },
+                keywords: [
+                    'rest',
+                    'api',
+                    'swarm',
+                    'claude-flow'
+                ],
+                author: 'Claude Flow Swarm',
+                license: 'MIT',
+                dependencies: {
+                    express: '^4.18.2'
+                },
+                devDependencies: {
+                    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()
+                }
+            };
+            await fs.writeFile(`${projectDir}/package.json`, JSON.stringify(packageJson, null, 2));
+            // Create README
+            const readme = `# REST API
+
+This REST API was created by the Claude Flow Swarm system.
+
+## Swarm Details
+- Swarm ID: ${this.swarmId.id}
+- Task: ${task.name}
+- Agent: ${agent.name}
+- Generated: ${new Date().toISOString()}
+
+## Installation
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Usage
+
+Start the server:
+\`\`\`bash
+npm start
+\`\`\`
+
+Development mode with auto-reload:
+\`\`\`bash
+npm run dev
+\`\`\`
+
+## API Endpoints
+
+- \`GET /health\` - Health check
+- \`GET /api/v1/items\` - Get all items
+- \`GET /api/v1/items/:id\` - Get item by ID
+- \`POST /api/v1/items\` - Create new item
+- \`PUT /api/v1/items/:id\` - Update item
+- \`DELETE /api/v1/items/:id\` - Delete item
+
+## Description
+${task.description}
+
+---
+Created by Claude Flow Swarm
+`;
+            await fs.writeFile(`${projectDir}/README.md`, readme);
+            // Create .gitignore
+            const gitignore = `node_modules/
+.env
+*.log
+.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'
+                    ]
+                },
+                artifacts: {
+                    mainFile: `${projectDir}/server.js`,
+                    packageFile: `${projectDir}/package.json`,
+                    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
+
+// Hello World Application
+// Generated by Claude Flow Swarm
+
+console.log('Hello, World!');
+console.log('This application was created by the Claude Flow Swarm system.');
+console.log('Swarm ID: ${this.swarmId.id}');
+console.log('Task: ${task.name}');
+console.log('Generated at: ${new Date().toISOString()}');
+
+// Export for testing
+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',
+                scripts: {
+                    start: 'node index.js',
+                    test: 'node test.js'
+                },
+                keywords: [
+                    'hello-world',
+                    'swarm',
+                    'claude-flow'
+                ],
+                author: 'Claude Flow Swarm',
+                license: 'MIT'
+            };
+            await fs.writeFile(`${projectDir}/package.json`, JSON.stringify(packageJson, null, 2));
+            // Create README
+            const readme = `# Hello World
+
+This application was created by the Claude Flow Swarm system.
+
+## Swarm Details
+- Swarm ID: ${this.swarmId.id}
+- Task: ${task.name}
+- Generated: ${new Date().toISOString()}
+
+## Usage
+
+\`\`\`bash
+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'
+                    ]
+                },
+                artifacts: {
+                    mainFile: `${projectDir}/index.js`,
+                    packageFile: `${projectDir}/package.json`,
+                    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}
+
+function main() {
+  console.log('Executing task: ${task.name}');
+  // Implementation would go here
+}
+
+main();
+`;
+        await fs.writeFile(`${projectDir}/main.js`, code);
+        return {
+            success: true,
+            output: {
+                message: 'Code generated successfully',
+                location: projectDir,
+                files: [
+                    'main.js'
+                ]
+            }
+        };
+    }
+    async executeAnalysisTask(task, workDir, agent) {
+        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,
+            timestamp: new Date().toISOString(),
+            findings: [
+                'Analysis point 1: Task objectives are clear',
+                'Analysis point 2: Resources are allocated',
+                'Analysis point 3: Implementation path is defined'
+            ],
+            recommendations: [
+                'Proceed with implementation',
+                'Monitor progress regularly',
+                'Adjust resources as needed'
+            ]
+        };
+        await fs.writeFile(`${analysisDir}/analysis-report.json`, JSON.stringify(analysis, null, 2));
+        return {
+            success: true,
+            output: analysis,
+            artifacts: {
+                report: `${analysisDir}/analysis-report.json`
+            }
+        };
+    }
+    async executeDocumentationTask(task, workDir, agent) {
+        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}
+
+## Overview
+This documentation was generated by the Claude Flow Swarm system.
+
+## Details
+- Task ID: ${task.id.id}
+- Generated: ${new Date().toISOString()}
+- Swarm ID: ${this.swarmId.id}
+
+## Instructions
+${task.instructions}
+
+## Implementation Notes
+- 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'
+                ]
+            },
+            artifacts: {
+                documentation: `${docsDir}/documentation.md`
+            }
+        };
+    }
+    async executeTestingTask(task, workDir, agent) {
+        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}
+
+const assert = require('assert');
+
+describe('${task.name}', () => {
+  it('should pass basic test', () => {
+    assert.strictEqual(1 + 1, 2);
+  });
+  
+  it('should validate implementation', () => {
+    // Test implementation would go here
+    assert.ok(true, 'Implementation validated');
+  });
+});
+
+console.log('Tests completed for: ${task.name}');
+`;
+        await fs.writeFile(`${testDir}/test.js`, testCode);
+        return {
+            success: true,
+            output: {
+                message: 'Test suite created successfully',
+                location: testDir,
+                files: [
+                    'test.js'
+                ],
+                testsPassed: 2,
+                testsFailed: 0
+            },
+            artifacts: {
+                testFile: `${testDir}/test.js`
+            }
+        };
+    }
+    async executeGenericTask(task, workDir, agent) {
+        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'
+        };
+        await fs.writeFile(`${outputDir}/result.json`, JSON.stringify(output, null, 2));
+        return {
+            success: true,
+            output,
+            artifacts: {
+                result: `${outputDir}/result.json`
+            }
+        };
+    }
+    assessTaskQuality(task, result) {
+        // Implementation needed - assess task quality
+        return 0.8;
+    }
+    updateAgentMetrics(agent, task) {
+        // 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.tasksCompleted + 1);
+        agent.metrics.successRate = agent.metrics.tasksCompleted / (agent.metrics.tasksCompleted + agent.metrics.tasksFailed);
+    }
+    async processDependentTasks(task) {
+    // Implementation needed - process tasks that depend on this one
+    }
+    isRecoverableError(error) {
+        // Implementation needed - determine if error is recoverable
+        return true;
+    }
+    isRetryableError(error) {
+        // Implementation needed - determine if error is retryable
+        return true;
+    }
+    async handleTaskFailureCascade(task) {
+    // Implementation needed - handle failure cascade
+    }
+    async reassignTask(taskId) {
+    // Implementation needed - reassign task to different agent
+    }
+    processHeartbeats() {
+        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
+                });
+                agent.status = 'error';
+                agent.health = 0;
+            }
+        }
+    }
+    updateSwarmMetrics() {
+    // Implementation needed - update swarm-level metrics
+    }
+    performCleanup() {
+    // Implementation needed - perform periodic cleanup
+    }
+    checkObjectiveCompletion() {
+    // Implementation needed - check if objectives are complete
+    }
+    checkObjectiveFailure(task) {
+    // Implementation needed - check if objective has failed
+    }
+    handleAgentError(agentId, error) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            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) {
+        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') {
+        if (!this.jsonOutputAggregator) {
+            return null;
+        }
+        return this.jsonOutputAggregator.getJsonOutput(status);
+    }
+    /**
+   * Save JSON output to file
+   */ async saveJsonOutput(filePath, status = 'completed') {
+        if (!this.jsonOutputAggregator) {
+            throw new Error('JSON output aggregation not enabled');
+        }
+        await this.jsonOutputAggregator.saveToFile(filePath, status);
+    }
+    /**
+   * Track agent activity in JSON output
+   */ trackAgentInJsonOutput(agent) {
+        if (this.jsonOutputAggregator) {
+            this.jsonOutputAggregator.addAgent(agent);
+        }
+    }
+    /**
+   * Track task activity in JSON output
+   */ trackTaskInJsonOutput(task) {
+        if (this.jsonOutputAggregator) {
+            this.jsonOutputAggregator.addTask(task);
+        }
+    }
+    /**
+   * Add output to JSON aggregator
+   */ addOutputToJsonAggregator(agentId, output) {
+        if (this.jsonOutputAggregator) {
+            this.jsonOutputAggregator.addAgentOutput(agentId, output);
+        }
+    }
+    /**
+   * Add insight to JSON aggregator
+   */ addInsight(insight) {
+        if (this.jsonOutputAggregator) {
+            this.jsonOutputAggregator.addInsight(insight);
+        }
+    }
+    /**
+   * Add artifact to JSON aggregator
+   */ addArtifact(key, artifact) {
+        if (this.jsonOutputAggregator) {
+            this.jsonOutputAggregator.addArtifact(key, artifact);
+        }
+    }
+}
+
+//# sourceMappingURL=coordinator.js.map