claude-flow-novice 1.6.4 → 1.6.6

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/integration/state-machine-integration.js

@@ -0,0 +1,635 @@
+/**
+ * Agent Coordination V2 - State Machine Integration
+ *
+ * Bidirectional synchronization between Phase 01 state machine and Phase 02 dependency graph.
+ * Bridges agent lifecycle states with task scheduling and dependency resolution.
+ *
+ * Integration flow:
+ * - State machine transitions → Task status updates
+ * - Task assignments → Agent state transitions
+ * - Completion events → Dependency resolution
+ * - Error handling → Blocked state propagation
+ *
+ * Performance Requirements:
+ * - Dependency resolution: <50ms (p95)
+ * - State transition handling: <100ms (p99)
+ * - Agent assignment: <20ms (p95)
+ * - Memory leak prevention: Automatic listener cleanup
+ *
+ * @module coordination/v2/integration/state-machine-integration
+ */ import { EventEmitter } from 'node:events';
+import { AgentState } from '../../shared/core/agent-state.js';
+import { DependencyNodeStatus } from '../core/dependency-node.js';
+import { Logger } from '../../../core/logger.js';
+/**
+ * StateMachineIntegration - Bidirectional synchronization layer
+ *
+ * Responsibilities:
+ * 1. Listen to state machine events and update task statuses
+ * 2. Listen to scheduler events and trigger state transitions
+ * 3. Manage agent-task assignments
+ * 4. Propagate errors and handle retries
+ * 5. Maintain consistency between state machine and dependency graph
+ */ export class StateMachineIntegration extends EventEmitter {
+    logger;
+    stateMachine;
+    scheduler;
+    graph;
+    config;
+    agentTaskMappings;
+    taskAgentMappings;
+    taskRetryCount;
+    statistics;
+    isRunning;
+    schedulingInterval;
+    constructor(stateMachine, scheduler, graph, config){
+        super();
+        this.logger = new Logger({
+            level: 'info',
+            format: 'text',
+            destination: 'console'
+        });
+        this.stateMachine = stateMachine;
+        this.scheduler = scheduler;
+        this.graph = graph;
+        this.config = {
+            autoAssignAgents: config?.autoAssignAgents ?? true,
+            maxRetryAttempts: config?.maxRetryAttempts ?? 3,
+            validateTaskStatus: config?.validateTaskStatus ?? true,
+            enableConsistencyChecks: config?.enableConsistencyChecks ?? true
+        };
+        this.agentTaskMappings = new Map();
+        this.taskAgentMappings = new Map();
+        this.taskRetryCount = new Map();
+        this.isRunning = false;
+        this.statistics = {
+            totalAssignments: 0,
+            totalCompletions: 0,
+            totalFailures: 0,
+            totalRetries: 0,
+            activeAssignments: 0,
+            consistencyChecksPassed: 0,
+            consistencyChecksFailed: 0
+        };
+        this.setupEventListeners();
+        this.logger.info('StateMachineIntegration initialized', {
+            autoAssignAgents: this.config.autoAssignAgents,
+            maxRetryAttempts: this.config.maxRetryAttempts
+        });
+    }
+    /**
+   * Setup bidirectional event listeners
+   */ setupEventListeners() {
+        // State machine → Scheduler (agent state changes affect tasks)
+        this.stateMachine.on('state:transition', this.onAgentStateChange.bind(this));
+        // Scheduler → State machine (task events trigger agent state changes)
+        this.scheduler.on('task:scheduled', this.onTaskScheduled.bind(this));
+        this.scheduler.on('task:completed', this.onTaskCompleted.bind(this));
+        // Custom event for task failures (emitted by scheduler or manually)
+        this.on('task:failed', this.onTaskFailed.bind(this));
+        this.logger.debug('Event listeners configured');
+    }
+    // ============================================
+    // State Machine → Scheduler Integration
+    // ============================================
+    /**
+   * Handle agent state transitions
+   * Maps state machine events to task status updates
+   */ async onAgentStateChange(event) {
+        const { agentId, fromState, toState } = event;
+        this.logger.debug('Agent state changed', {
+            agentId,
+            fromState,
+            toState,
+            timestamp: event.timestamp
+        });
+        const mapping = this.agentTaskMappings.get(agentId);
+        if (!mapping) {
+            // Agent has no assigned task, this is normal for IDLE agents
+            return;
+        }
+        const taskId = mapping.taskId;
+        const node = this.graph.getNode(taskId);
+        if (!node) {
+            this.logger.warn('Task not found in graph', {
+                taskId,
+                agentId
+            });
+            return;
+        }
+        // Update mapping status
+        mapping.status = toState;
+        // Map agent states to task statuses
+        try {
+            if (toState === AgentState.WORKING) {
+                // Agent started working → task is executing
+                await this.updateTaskStatus(node, DependencyNodeStatus.EXECUTING, {
+                    agentId,
+                    startedAt: Date.now()
+                });
+            } else if (toState === AgentState.COMPLETED) {
+                // Agent completed → mark task as completed
+                await this.updateTaskStatus(node, DependencyNodeStatus.COMPLETED, {
+                    agentId,
+                    completedAt: Date.now()
+                });
+                // Notify scheduler of completion
+                await this.scheduler.onTaskComplete(taskId);
+                // Clear assignment
+                this.clearAgentAssignment(agentId);
+            } else if (toState === AgentState.BLOCKED || toState === AgentState.ERROR) {
+                // Agent blocked/errored → task failed
+                const error = new Error(`Agent ${agentId} transitioned to ${toState}`);
+                await this.handleTaskFailure(taskId, agentId, error);
+            } else if (toState === AgentState.WAITING) {
+                // Agent waiting → task pending dependencies
+                await this.updateTaskStatus(node, DependencyNodeStatus.PENDING, {
+                    agentId,
+                    waitingAt: Date.now()
+                });
+            } else if (toState === AgentState.IDLE) {
+                // Agent returned to idle → ready for new assignment
+                // Only clear if task was previously completed
+                if (fromState === AgentState.COMPLETED) {
+                    this.clearAgentAssignment(agentId);
+                }
+            }
+            // Consistency check
+            if (this.config.enableConsistencyChecks) {
+                await this.validateStateConsistency(agentId, taskId);
+            }
+        } catch (error) {
+            this.logger.error('Failed to handle agent state change', {
+                agentId,
+                taskId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    // ============================================
+    // Scheduler → State Machine Integration
+    // ============================================
+    /**
+   * Handle task scheduled event
+   * Assigns tasks to available agents
+   */ async onTaskScheduled(event) {
+        const { taskId, priority } = event;
+        this.logger.debug('Task scheduled', {
+            taskId,
+            priority,
+            dependenciesMet: event.dependenciesMet
+        });
+        // Only assign if dependencies are met and auto-assignment is enabled
+        if (!event.dependenciesMet || !this.config.autoAssignAgents) {
+            return;
+        }
+        try {
+            // Find available agent
+            const agentId = await this.findAvailableAgent();
+            if (!agentId) {
+                this.logger.debug('No available agents for task assignment', {
+                    taskId
+                });
+                return;
+            }
+            // Assign task to agent
+            await this.assignTaskToAgent(taskId, agentId);
+        } catch (error) {
+            this.logger.error('Failed to assign task', {
+                taskId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    /**
+   * Handle task completion event
+   * Transitions agent to completed state
+   */ async onTaskCompleted(event) {
+        const { taskId, agentId } = event;
+        this.logger.info('Task completed', {
+            taskId,
+            agentId,
+            completionTime: event.completionTime,
+            newlyReadyTasks: event.newlyReadyTasks
+        });
+        if (!agentId) {
+            this.logger.warn('Task completed without assigned agent', {
+                taskId
+            });
+            return;
+        }
+        try {
+            // Transition agent to COMPLETED then IDLE
+            const currentState = this.stateMachine.getState(agentId);
+            if (currentState !== AgentState.COMPLETED) {
+                await this.stateMachine.transition(agentId, AgentState.COMPLETED, {
+                    metadata: {
+                        taskId,
+                        completedAt: Date.now()
+                    }
+                });
+            }
+            // Then to IDLE for next assignment
+            await this.stateMachine.transition(agentId, AgentState.IDLE);
+            // Update statistics
+            this.statistics.totalCompletions++;
+            this.statistics.activeAssignments--;
+            // Emit completion event
+            this.emit('integration:task-completed', {
+                taskId,
+                agentId
+            });
+        } catch (error) {
+            this.logger.error('Failed to handle task completion', {
+                taskId,
+                agentId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    /**
+   * Handle task failure event
+   * Manages retries and agent error states
+   */ async onTaskFailed(event) {
+        const { taskId, agentId, error } = event;
+        this.logger.warn('Task failed', {
+            taskId,
+            agentId,
+            error: error.message
+        });
+        try {
+            await this.handleTaskFailure(taskId, agentId, error);
+        } catch (handlingError) {
+            this.logger.error('Failed to handle task failure', {
+                taskId,
+                agentId,
+                error: handlingError instanceof Error ? handlingError.message : String(handlingError)
+            });
+        }
+    }
+    // ============================================
+    // Agent Assignment Logic
+    // ============================================
+    /**
+   * Assign a task to an available agent
+   */ async assignTaskToAgent(taskId, agentId) {
+        const node = this.graph.getNode(taskId);
+        if (!node) {
+            throw new Error(`Task ${taskId} not found in graph`);
+        }
+        this.logger.info('Assigning task to agent', {
+            taskId,
+            agentId
+        });
+        // Create mapping
+        const mapping = {
+            agentId,
+            taskId,
+            assignedAt: Date.now(),
+            status: AgentState.WORKING
+        };
+        this.agentTaskMappings.set(agentId, mapping);
+        this.taskAgentMappings.set(taskId, agentId);
+        // Update statistics
+        this.statistics.totalAssignments++;
+        this.statistics.activeAssignments++;
+        // Transition agent to WORKING
+        await this.stateMachine.transition(agentId, AgentState.WORKING, {
+            metadata: {
+                taskId,
+                assignedAt: Date.now()
+            }
+        });
+        // Update task node
+        await this.updateTaskStatus(node, DependencyNodeStatus.EXECUTING, {
+            agentId,
+            assignedAt: Date.now()
+        });
+        // Emit assignment event
+        const event = {
+            taskId,
+            agentId,
+            timestamp: new Date()
+        };
+        this.emit('task:assigned', event);
+    }
+    /**
+   * Find an available agent (IDLE or WAITING state)
+   */ async findAvailableAgent() {
+        const allStates = this.stateMachine.getAllStates();
+        for (const [agentId, state] of allStates){
+            // Agent is available if idle or waiting
+            if (state === AgentState.IDLE || state === AgentState.WAITING) {
+                // Check not already assigned
+                if (!this.agentTaskMappings.has(agentId)) {
+                    return agentId;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+   * Clear agent assignment
+   */ clearAgentAssignment(agentId) {
+        const mapping = this.agentTaskMappings.get(agentId);
+        if (mapping) {
+            this.taskAgentMappings.delete(mapping.taskId);
+            this.agentTaskMappings.delete(agentId);
+            this.statistics.activeAssignments--;
+            this.logger.debug('Cleared agent assignment', {
+                agentId,
+                taskId: mapping.taskId
+            });
+        }
+    }
+    // ============================================
+    // Error Handling & Retry Logic
+    // ============================================
+    /**
+   * Handle task failure with retry logic
+   */ async handleTaskFailure(taskId, agentId, error) {
+        const node = this.graph.getNode(taskId);
+        if (!node) {
+            this.logger.warn('Task not found for failure handling', {
+                taskId
+            });
+            return;
+        }
+        // Update statistics
+        this.statistics.totalFailures++;
+        // Check retry count
+        const retryCount = this.taskRetryCount.get(taskId) || 0;
+        if (retryCount < this.config.maxRetryAttempts) {
+            // Retry task
+            this.taskRetryCount.set(taskId, retryCount + 1);
+            this.statistics.totalRetries++;
+            this.logger.info('Retrying failed task', {
+                taskId,
+                attempt: retryCount + 1,
+                maxAttempts: this.config.maxRetryAttempts
+            });
+            // Reset task to READY status
+            await this.updateTaskStatus(node, DependencyNodeStatus.READY, {
+                retryCount: retryCount + 1,
+                lastError: error.message
+            });
+            // Transition agent to ERROR then IDLE
+            if (this.stateMachine.getState(agentId) !== AgentState.ERROR) {
+                await this.stateMachine.transition(agentId, AgentState.ERROR, {
+                    metadata: {
+                        taskId,
+                        error: error.message
+                    }
+                });
+            }
+            await this.stateMachine.transition(agentId, AgentState.IDLE);
+            // Clear assignment
+            this.clearAgentAssignment(agentId);
+            // Re-schedule task
+            await this.scheduler.scheduleTask(node);
+        } else {
+            // Max retries exceeded → permanent failure
+            this.logger.error('Task failed permanently after max retries', {
+                taskId,
+                attempts: retryCount + 1,
+                error: error.message
+            });
+            // Mark as failed
+            await this.updateTaskStatus(node, DependencyNodeStatus.FAILED, {
+                error: error.message,
+                failedAt: Date.now()
+            });
+            // Transition agent to ERROR then IDLE
+            if (this.stateMachine.getState(agentId) !== AgentState.ERROR) {
+                await this.stateMachine.transition(agentId, AgentState.ERROR, {
+                    metadata: {
+                        taskId,
+                        error: error.message
+                    }
+                });
+            }
+            await this.stateMachine.transition(agentId, AgentState.IDLE);
+            // Clear assignment
+            this.clearAgentAssignment(agentId);
+            // Emit permanent failure event
+            this.emit('integration:task-permanent-failure', {
+                taskId,
+                agentId,
+                error
+            });
+        }
+    }
+    // ============================================
+    // Helper Methods
+    // ============================================
+    /**
+   * Update task status in graph
+   */ async updateTaskStatus(node, status, metadata = {}) {
+        if (this.config.validateTaskStatus) {
+            // Validate status transition
+            const currentStatus = node.status;
+            if (!this.isValidTaskStatusTransition(currentStatus, status)) {
+                throw new Error(`Invalid task status transition: ${currentStatus} -> ${status}`);
+            }
+        }
+        // Update node (requires mutable access, assume graph handles this)
+        // Note: DependencyNode interface is readonly, but implementation may provide update methods
+        const mutableNode = node;
+        mutableNode._status = status;
+        mutableNode._metadata = {
+            ...node.metadata,
+            ...metadata
+        };
+        mutableNode._updatedAt = Date.now();
+        this.logger.debug('Updated task status', {
+            taskId: node.taskId,
+            status,
+            metadata
+        });
+    }
+    /**
+   * Validate task status transition
+   */ isValidTaskStatusTransition(current, next) {
+        const validTransitions = {
+            [DependencyNodeStatus.PENDING]: [
+                DependencyNodeStatus.READY,
+                DependencyNodeStatus.FAILED
+            ],
+            [DependencyNodeStatus.READY]: [
+                DependencyNodeStatus.EXECUTING,
+                DependencyNodeStatus.FAILED
+            ],
+            [DependencyNodeStatus.EXECUTING]: [
+                DependencyNodeStatus.COMPLETED,
+                DependencyNodeStatus.FAILED,
+                DependencyNodeStatus.READY
+            ],
+            [DependencyNodeStatus.COMPLETED]: [],
+            [DependencyNodeStatus.FAILED]: [
+                DependencyNodeStatus.READY
+            ]
+        };
+        return validTransitions[current]?.includes(next) ?? false;
+    }
+    /**
+   * Validate state consistency between agent and task
+   */ async validateStateConsistency(agentId, taskId) {
+        const agentState = this.stateMachine.getState(agentId);
+        const node = this.graph.getNode(taskId);
+        if (!agentState || !node) {
+            this.statistics.consistencyChecksFailed++;
+            return false;
+        }
+        // Define expected mappings
+        const expectedMappings = {
+            [AgentState.IDLE]: [
+                DependencyNodeStatus.PENDING,
+                DependencyNodeStatus.READY
+            ],
+            [AgentState.WORKING]: [
+                DependencyNodeStatus.EXECUTING
+            ],
+            [AgentState.WAITING]: [
+                DependencyNodeStatus.PENDING
+            ],
+            [AgentState.COMPLETED]: [
+                DependencyNodeStatus.COMPLETED
+            ],
+            [AgentState.ERROR]: [
+                DependencyNodeStatus.FAILED
+            ],
+            [AgentState.BLOCKED]: [
+                DependencyNodeStatus.FAILED,
+                DependencyNodeStatus.PENDING
+            ],
+            [AgentState.HELPING]: [
+                DependencyNodeStatus.EXECUTING
+            ],
+            [AgentState.PAUSED]: [
+                DependencyNodeStatus.EXECUTING,
+                DependencyNodeStatus.PENDING
+            ],
+            [AgentState.TERMINATED]: [
+                DependencyNodeStatus.COMPLETED,
+                DependencyNodeStatus.FAILED
+            ]
+        };
+        const allowedStatuses = expectedMappings[agentState] || [];
+        const isConsistent = allowedStatuses.includes(node.status);
+        if (isConsistent) {
+            this.statistics.consistencyChecksPassed++;
+        } else {
+            this.statistics.consistencyChecksFailed++;
+            this.logger.warn('State inconsistency detected', {
+                agentId,
+                taskId,
+                agentState,
+                taskStatus: node.status,
+                expectedTaskStatuses: allowedStatuses
+            });
+        }
+        return isConsistent;
+    }
+    /**
+   * Get task for agent
+   */ async getTaskForAgent(agentId) {
+        const mapping = this.agentTaskMappings.get(agentId);
+        return mapping?.taskId;
+    }
+    /**
+   * Get agent for task
+   */ getAgentForTask(taskId) {
+        return this.taskAgentMappings.get(taskId);
+    }
+    // ============================================
+    // Public API
+    // ============================================
+    /**
+   * Start the integration layer
+   * Begins automatic agent assignment and scheduling
+   */ async start() {
+        if (this.isRunning) {
+            this.logger.warn('Integration already running');
+            return;
+        }
+        this.isRunning = true;
+        // Start automatic task scheduling loop
+        if (this.config.autoAssignAgents) {
+            this.schedulingInterval = setInterval(()=>{
+                this.processReadyTasks();
+            }, 1000); // Check every second
+        }
+        this.logger.info('StateMachineIntegration started');
+    }
+    /**
+   * Stop the integration layer
+   */ async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        // Clear scheduling interval
+        if (this.schedulingInterval) {
+            clearInterval(this.schedulingInterval);
+            this.schedulingInterval = undefined;
+        }
+        this.logger.info('StateMachineIntegration stopped');
+    }
+    /**
+   * Process ready tasks and assign to available agents
+   */ async processReadyTasks() {
+        try {
+            const readyTasks = this.graph.getReadyTasks();
+            for (const node of readyTasks){
+                // Skip if already assigned
+                if (this.taskAgentMappings.has(node.taskId)) {
+                    continue;
+                }
+                // Find available agent
+                const agentId = await this.findAvailableAgent();
+                if (!agentId) {
+                    break; // No more agents available
+                }
+                // Assign task
+                await this.assignTaskToAgent(node.taskId, agentId);
+            }
+        } catch (error) {
+            this.logger.error('Error processing ready tasks', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    /**
+   * Get integration statistics
+   */ getStatistics() {
+        return {
+            ...this.statistics
+        };
+    }
+    /**
+   * Get all active agent-task assignments
+   */ getActiveAssignments() {
+        return Array.from(this.agentTaskMappings.values());
+    }
+    /**
+   * Cleanup and reset integration state
+   */ async cleanup() {
+        await this.stop();
+        this.agentTaskMappings.clear();
+        this.taskAgentMappings.clear();
+        this.taskRetryCount.clear();
+        this.statistics = {
+            totalAssignments: 0,
+            totalCompletions: 0,
+            totalFailures: 0,
+            totalRetries: 0,
+            activeAssignments: 0,
+            consistencyChecksPassed: 0,
+            consistencyChecksFailed: 0
+        };
+        this.removeAllListeners();
+        this.logger.info('StateMachineIntegration cleaned up');
+    }
+}
+
+//# sourceMappingURL=state-machine-integration.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/integration/state-machine-integration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/integration/state-machine-integration.ts"],"names":["EventEmitter","AgentState","DependencyNodeStatus","Logger","StateMachineIntegration","logger","stateMachine","scheduler","graph","config","agentTaskMappings","taskAgentMappings","taskRetryCount","statistics","isRunning","schedulingInterval","level","format","destination","autoAssignAgents","maxRetryAttempts","validateTaskStatus","enableConsistencyChecks","Map","totalAssignments","totalCompletions","totalFailures","totalRetries","activeAssignments","consistencyChecksPassed","consistencyChecksFailed","setupEventListeners","info","on","onAgentStateChange","bind","onTaskScheduled","onTaskCompleted","onTaskFailed","debug","event","agentId","fromState","toState","timestamp","mapping","get","taskId","node","getNode","warn","status","WORKING","updateTaskStatus","EXECUTING","startedAt","Date","now","COMPLETED","completedAt","onTaskComplete","clearAgentAssignment","BLOCKED","ERROR","error","Error","handleTaskFailure","WAITING","PENDING","waitingAt","IDLE","validateStateConsistency","message","String","priority","dependenciesMet","findAvailableAgent","assignTaskToAgent","completionTime","newlyReadyTasks","currentState","getState","transition","metadata","emit","handlingError","assignedAt","set","allStates","getAllStates","state","has","undefined","delete","retryCount","attempt","maxAttempts","READY","lastError","scheduleTask","attempts","FAILED","failedAt","currentStatus","isValidTaskStatusTransition","mutableNode","_status","_metadata","_updatedAt","current","next","validTransitions","includes","agentState","expectedMappings","HELPING","PAUSED","TERMINATED","allowedStatuses","isConsistent","taskStatus","expectedTaskStatuses","getTaskForAgent","getAgentForTask","start","setInterval","processReadyTasks","stop","clearInterval","readyTasks","getReadyTasks","getStatistics","getActiveAssignments","Array","from","values","cleanup","clear","removeAllListeners"],"mappings":"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"}