claude-flow-novice 1.6.1 → 1.6.3

package/.claude-flow-novice/dist/src/coordination/v2/coordinators/cascading-shutdown.js

@@ -0,0 +1,492 @@
+/**
+ * Agent Coordination V2 - Cascading Shutdown Coordinator
+ *
+ * Hierarchical shutdown coordination with top-down notification and bottom-up completion.
+ * Implements graceful termination with resource cleanup at all levels.
+ *
+ * Performance targets:
+ * - Complete hierarchy shutdown: <1s for 20 agents
+ * - Top-down notification: <100ms per level
+ * - Bottom-up aggregation: <200ms total
+ * - Resource cleanup: 100% coverage
+ *
+ * Features:
+ * - Top-down shutdown notification (root → leaves)
+ * - Bottom-up completion aggregation (leaves → root)
+ * - Graceful resource cleanup (connections, files, processes)
+ * - Integration with Phase 4 hierarchical completion detection
+ * - Emergency shutdown support
+ * - Shutdown checkpoint creation
+ *
+ * @module coordination/v2/coordinators/cascading-shutdown
+ */ import { EventEmitter } from 'events';
+/**
+ * CascadingShutdown - Top-down shutdown with bottom-up completion
+ *
+ * Implements hierarchical shutdown coordination:
+ * 1. Top-down: Notify all levels from root → leaves
+ * 2. Parallel: Each level executes shutdown simultaneously
+ * 3. Bottom-up: Aggregate completion from leaves → root
+ * 4. Cleanup: Resource cleanup at each level
+ * 5. Checkpoint: Optional checkpoint creation
+ *
+ * Shutdown flow:
+ * - Level 0 (root) initiates shutdown
+ * - Notify Level 1 agents → Notify Level 2 agents → ... → Notify Level N agents
+ * - Level N agents complete → Level N-1 aggregates → ... → Level 0 completes
+ * - Children complete before parents (bottom-up guarantee)
+ *
+ * @example
+ * ```typescript
+ * const cascadingShutdown = new CascadingShutdown(
+ *   hierarchicalDetector,
+ *   {
+ *     maxShutdownTimeMs: 10000,
+ *     createShutdownCheckpoints: true,
+ *     enableResourceCleanup: true
+ *   }
+ * );
+ *
+ * // Register hierarchy
+ * cascadingShutdown.registerHierarchy('swarm-1', 'coordinator-0', [
+ *   { agentId: 'coordinator-0', level: 0, childIds: ['agent-1', 'agent-2'] },
+ *   { agentId: 'agent-1', level: 1, parentId: 'coordinator-0' },
+ *   { agentId: 'agent-2', level: 1, parentId: 'coordinator-0' }
+ * ]);
+ *
+ * // Initiate shutdown from root
+ * const result = await cascadingShutdown.initiateShutdown('coordinator-0', 'Task completed');
+ *
+ * console.log(`Shutdown ${result.totalAgents} agents in ${result.totalLatencyMs}ms`);
+ * ```
+ */ export class CascadingShutdown extends EventEmitter {
+    hierarchies = new Map();
+    hierarchicalDetector;
+    config;
+    shutdownInProgress = new Set();
+    resourceCleanupHandlers = new Map();
+    constructor(hierarchicalDetector, config){
+        super();
+        this.hierarchicalDetector = hierarchicalDetector;
+        this.config = {
+            maxShutdownTimeMs: 10000,
+            createShutdownCheckpoints: true,
+            enableResourceCleanup: true,
+            notificationTimeoutMs: 100,
+            completionTimeoutMs: 200,
+            enableEmergencyMode: true,
+            agentGracePeriodMs: 500,
+            ...config
+        };
+    }
+    /**
+   * Register hierarchy for shutdown coordination
+   *
+   * @param swarmId - Swarm identifier
+   * @param rootCoordinatorId - Root coordinator agent ID (Level 0)
+   * @param nodes - Hierarchy node definitions
+   */ registerHierarchy(swarmId, rootCoordinatorId, nodes) {
+        const hierarchyNodes = new Map();
+        // Build hierarchy nodes
+        for (const node of nodes){
+            hierarchyNodes.set(node.agentId, {
+                agentId: node.agentId,
+                level: node.level,
+                parentId: node.parentId,
+                childIds: node.childIds || [],
+                shutdownStatus: 'pending',
+                resources: node.resources || [],
+                sessionId: node.sessionId
+            });
+        }
+        // Ensure root coordinator exists
+        if (!hierarchyNodes.has(rootCoordinatorId)) {
+            hierarchyNodes.set(rootCoordinatorId, {
+                agentId: rootCoordinatorId,
+                level: 0,
+                childIds: [],
+                shutdownStatus: 'pending',
+                resources: []
+            });
+        }
+        // Build parent-child relationships if not provided
+        const nodesArray2 = Array.from(hierarchyNodes.values());
+        for (const node of nodesArray2){
+            if (node.parentId && hierarchyNodes.has(node.parentId)) {
+                const parent = hierarchyNodes.get(node.parentId);
+                if (!parent.childIds.includes(node.agentId)) {
+                    parent.childIds.push(node.agentId);
+                }
+            }
+        }
+        this.hierarchies.set(swarmId, hierarchyNodes);
+        const nodesArray = Array.from(hierarchyNodes.values());
+        this.emit('hierarchy:registered', {
+            swarmId,
+            rootCoordinatorId,
+            totalAgents: hierarchyNodes.size,
+            maxDepth: Math.max(...nodesArray.map((n)=>n.level))
+        });
+    }
+    /**
+   * Register resource cleanup handler for specific resource type
+   *
+   * @param resourceType - Type of resource to handle
+   * @param handler - Cleanup handler function
+   *
+   * @example
+   * ```typescript
+   * cascadingShutdown.registerResourceCleanup('connection', async (resource) => {
+   *   await closeConnection(resource.id);
+   * });
+   * ```
+   */ registerResourceCleanup(resourceType, handler) {
+        this.resourceCleanupHandlers.set(resourceType, handler);
+    }
+    /**
+   * Initiate cascading shutdown from root coordinator
+   *
+   * Performance target: <1s for 20-agent hierarchy
+   *
+   * Process:
+   * 1. Top-down notification (root → leaves)
+   * 2. Parallel shutdown execution at each level
+   * 3. Bottom-up completion aggregation (leaves → root)
+   * 4. Resource cleanup at all levels
+   *
+   * @param rootCoordinatorId - Root coordinator to initiate from
+   * @param reason - Shutdown reason
+   * @param swarmId - Optional swarm ID (auto-detect if omitted)
+   * @returns Promise resolving to CascadingShutdownResult
+   */ async initiateShutdown(rootCoordinatorId, reason = 'Cascading shutdown initiated', swarmId) {
+        const startTime = Date.now();
+        // Find swarm containing root coordinator
+        const targetSwarmId = swarmId || this.findSwarmByAgent(rootCoordinatorId);
+        if (!targetSwarmId) {
+            throw new Error(`Root coordinator ${rootCoordinatorId} not found in any hierarchy`);
+        }
+        const hierarchy = this.hierarchies.get(targetSwarmId);
+        if (!hierarchy) {
+            throw new Error(`Hierarchy not found for swarm ${targetSwarmId}`);
+        }
+        const rootNode = hierarchy.get(rootCoordinatorId);
+        if (!rootNode) {
+            throw new Error(`Root coordinator ${rootCoordinatorId} not found in hierarchy`);
+        }
+        // Check if shutdown already in progress
+        if (this.shutdownInProgress.has(targetSwarmId)) {
+            throw new Error(`Shutdown already in progress for swarm ${targetSwarmId}`);
+        }
+        this.shutdownInProgress.add(targetSwarmId);
+        const hierarchyArray = Array.from(hierarchy.values());
+        const shutdownResult = {
+            rootCoordinatorId,
+            success: true,
+            totalAgents: hierarchy.size,
+            successfulShutdowns: 0,
+            failedShutdowns: 0,
+            maxDepth: Math.max(...hierarchyArray.map((n)=>n.level)),
+            totalLatencyMs: 0,
+            notificationLatencyMs: 0,
+            aggregationLatencyMs: 0,
+            totalResourcesCleaned: 0,
+            agentResults: [],
+            shutdownAt: new Date(),
+            reason
+        };
+        this.emit('shutdown:started', {
+            rootCoordinatorId,
+            swarmId: targetSwarmId,
+            totalAgents: hierarchy.size,
+            reason
+        });
+        try {
+            // Step 1: Top-down shutdown notification (root → leaves)
+            const notificationStartTime = Date.now();
+            await this.notifyShutdownTopDown(hierarchy, rootCoordinatorId);
+            shutdownResult.notificationLatencyMs = Date.now() - notificationStartTime;
+            // Step 2: Bottom-up completion aggregation (leaves → root)
+            const aggregationStartTime = Date.now();
+            shutdownResult.agentResults = await this.aggregateCompletionBottomUp(hierarchy, rootCoordinatorId, reason);
+            shutdownResult.aggregationLatencyMs = Date.now() - aggregationStartTime;
+            // Calculate metrics
+            shutdownResult.successfulShutdowns = shutdownResult.agentResults.filter((r)=>r.success).length;
+            shutdownResult.failedShutdowns = shutdownResult.agentResults.filter((r)=>!r.success).length;
+            shutdownResult.totalResourcesCleaned = shutdownResult.agentResults.reduce((sum, r)=>sum + r.resourcesCleaned, 0);
+            shutdownResult.success = shutdownResult.failedShutdowns === 0;
+            shutdownResult.totalLatencyMs = Date.now() - startTime;
+            // Performance warning if exceeds target
+            if (shutdownResult.totalLatencyMs > 1000 && hierarchy.size <= 20) {
+                console.warn(`[CascadingShutdown] Shutdown latency ${shutdownResult.totalLatencyMs}ms exceeds 1s target for ${hierarchy.size} agents`);
+            }
+            this.emit('shutdown:completed', shutdownResult);
+            return shutdownResult;
+        } catch (error) {
+            shutdownResult.success = false;
+            shutdownResult.totalLatencyMs = Date.now() - startTime;
+            this.emit('shutdown:failed', {
+                error: error instanceof Error ? error.message : String(error),
+                result: shutdownResult
+            });
+            throw error;
+        } finally{
+            this.shutdownInProgress.delete(targetSwarmId);
+        }
+    }
+    /**
+   * Emergency shutdown - immediate termination without checkpoints
+   *
+   * @param rootCoordinatorId - Root coordinator to shutdown
+   * @param reason - Emergency reason
+   * @returns Promise resolving when emergency shutdown complete
+   */ async emergencyShutdown(rootCoordinatorId, reason) {
+        this.emit('shutdown:emergency', {
+            rootCoordinatorId,
+            reason
+        });
+        // Disable checkpoints and resource cleanup for speed
+        const originalCheckpointConfig = this.config.createShutdownCheckpoints;
+        const originalCleanupConfig = this.config.enableResourceCleanup;
+        this.config.createShutdownCheckpoints = false;
+        this.config.enableResourceCleanup = false;
+        try {
+            return await this.initiateShutdown(rootCoordinatorId, `EMERGENCY: ${reason}`);
+        } finally{
+            this.config.createShutdownCheckpoints = originalCheckpointConfig;
+            this.config.enableResourceCleanup = originalCleanupConfig;
+        }
+    }
+    /**
+   * Top-down shutdown notification (root → leaves)
+   *
+   * Notifies all agents in hierarchy using BFS level-by-level traversal.
+   * Target: <100ms per level notification.
+   *
+   * @param hierarchy - Hierarchy nodes map
+   * @param rootId - Root agent to start from
+   */ async notifyShutdownTopDown(hierarchy, rootId) {
+        const queue = [
+            rootId
+        ];
+        const visited = new Set();
+        while(queue.length > 0){
+            const levelSize = queue.length;
+            const levelStartTime = Date.now();
+            const notificationPromises = [];
+            // Process entire level in parallel
+            for(let i = 0; i < levelSize; i++){
+                const agentId = queue.shift();
+                if (visited.has(agentId)) continue;
+                visited.add(agentId);
+                const node = hierarchy.get(agentId);
+                if (!node) continue;
+                // Notify this agent
+                notificationPromises.push(this.notifyAgent(node));
+                // Add children to queue for next level
+                queue.push(...node.childIds);
+            }
+            // Wait for level notifications to complete
+            await Promise.all(notificationPromises);
+            const levelLatency = Date.now() - levelStartTime;
+            if (levelLatency > this.config.notificationTimeoutMs) {
+                console.warn(`[CascadingShutdown] Level notification latency ${levelLatency}ms exceeds ${this.config.notificationTimeoutMs}ms target`);
+            }
+        }
+    }
+    /**
+   * Notify single agent of shutdown
+   *
+   * @param node - Node to notify
+   */ async notifyAgent(node) {
+        node.shutdownStatus = 'notified';
+        node.notifiedAt = Date.now();
+        this.emit('agent:notified', {
+            agentId: node.agentId,
+            level: node.level,
+            timestamp: node.notifiedAt
+        });
+    }
+    /**
+   * Bottom-up completion aggregation (leaves → root)
+   *
+   * Aggregates completion from leaf nodes up to root.
+   * Children complete before parents (guaranteed bottom-up order).
+   *
+   * Target: <200ms total aggregation time.
+   *
+   * @param hierarchy - Hierarchy nodes map
+   * @param rootId - Root agent to aggregate to
+   * @param reason - Shutdown reason
+   * @returns Array of AgentShutdownResult
+   */ async aggregateCompletionBottomUp(hierarchy, rootId, reason) {
+        const results = [];
+        // DFS post-order traversal (children before parent)
+        const processNode = async (agentId)=>{
+            const node = hierarchy.get(agentId);
+            if (!node) return;
+            // First, process all children (recursive)
+            await Promise.all(node.childIds.map((childId)=>processNode(childId)));
+            // Then, shutdown this node (after children complete)
+            const result = await this.shutdownAgent(node, reason);
+            results.push(result);
+        };
+        await processNode(rootId);
+        return results;
+    }
+    /**
+   * Shutdown single agent with resource cleanup
+   *
+   * @param node - Node to shutdown
+   * @param reason - Shutdown reason
+   * @returns AgentShutdownResult
+   */ async shutdownAgent(node, reason) {
+        const notificationLatency = node.notifiedAt ? Date.now() - node.notifiedAt : 0;
+        const startTime = Date.now();
+        const result = {
+            agentId: node.agentId,
+            level: node.level,
+            success: false,
+            notificationLatencyMs: notificationLatency,
+            completionLatencyMs: 0,
+            resourcesCleaned: 0,
+            resourcesFailed: 0
+        };
+        try {
+            node.shutdownStatus = 'completing';
+            // Step 1: Create shutdown checkpoint if enabled
+            if (this.config.createShutdownCheckpoints) {
+                // Checkpoint creation would integrate with Phase 4 checkpoint manager
+                // For now, we track the intention
+                node.checkpointId = `shutdown-${node.agentId}-${Date.now()}`;
+                result.checkpointId = node.checkpointId;
+            }
+            // Step 2: Resource cleanup
+            if (this.config.enableResourceCleanup && node.resources.length > 0) {
+                const cleanupResults = await this.cleanupResources(node);
+                result.resourcesCleaned = cleanupResults.filter((r)=>r.cleaned).length;
+                result.resourcesFailed = cleanupResults.filter((r)=>!r.cleaned).length;
+            }
+            // Step 3: Mark as completed
+            node.shutdownStatus = 'completed';
+            node.completedAt = Date.now();
+            result.success = true;
+            result.completionLatencyMs = Date.now() - startTime;
+            this.emit('agent:shutdown', result);
+        } catch (error) {
+            result.success = false;
+            result.error = error instanceof Error ? error.message : String(error);
+            result.completionLatencyMs = Date.now() - startTime;
+            this.emit('agent:shutdown-failed', result);
+        }
+        return result;
+    }
+    /**
+   * Cleanup resources for agent
+   *
+   * @param node - Node with resources to cleanup
+   * @returns Array of cleaned ResourceDescriptor
+   */ async cleanupResources(node) {
+        const cleanupPromises = node.resources.map(async (resource)=>{
+            try {
+                const handler = this.resourceCleanupHandlers.get(resource.type);
+                if (handler) {
+                    await handler(resource);
+                }
+                resource.cleaned = true;
+                this.emit('resource:cleaned', {
+                    agentId: node.agentId,
+                    resourceType: resource.type,
+                    resourceId: resource.id
+                });
+            } catch (error) {
+                resource.cleaned = false;
+                resource.error = error instanceof Error ? error.message : String(error);
+                this.emit('resource:cleanup-failed', {
+                    agentId: node.agentId,
+                    resourceType: resource.type,
+                    resourceId: resource.id,
+                    error: resource.error
+                });
+            }
+            return resource;
+        });
+        return Promise.all(cleanupPromises);
+    }
+    /**
+   * Find swarm containing specific agent
+   *
+   * @param agentId - Agent to search for
+   * @returns Swarm ID or undefined if not found
+   */ findSwarmByAgent(agentId) {
+        const entriesArray = Array.from(this.hierarchies.entries());
+        for (const [swarmId, hierarchy] of entriesArray){
+            if (hierarchy.has(agentId)) {
+                return swarmId;
+            }
+        }
+        return undefined;
+    }
+    /**
+   * Check if shutdown is in progress for swarm
+   *
+   * @param swarmId - Swarm to check
+   * @returns True if shutdown in progress
+   */ isShutdownInProgress(swarmId) {
+        return this.shutdownInProgress.has(swarmId);
+    }
+    /**
+   * Get shutdown status for agent
+   *
+   * @param agentId - Agent to query
+   * @returns Shutdown status or undefined if not found
+   */ getShutdownStatus(agentId) {
+        const hierarchiesArray = Array.from(this.hierarchies.values());
+        for (const hierarchy of hierarchiesArray){
+            const node = hierarchy.get(agentId);
+            if (node) {
+                return node.shutdownStatus;
+            }
+        }
+        return undefined;
+    }
+    /**
+   * Get shutdown configuration
+   */ getConfig() {
+        return {
+            ...this.config
+        };
+    }
+    /**
+   * Unregister hierarchy
+   *
+   * @param swarmId - Swarm to unregister
+   * @returns True if unregistered, false if not found
+   */ unregisterHierarchy(swarmId) {
+        return this.hierarchies.delete(swarmId);
+    }
+    /**
+   * Cleanup coordinator resources
+   */ async cleanup() {
+        // Shutdown all registered hierarchies
+        const hierarchiesArray = Array.from(this.hierarchies.entries());
+        const shutdownPromises = hierarchiesArray.map(async ([swarmId, hierarchy])=>{
+            const hierarchyArray = Array.from(hierarchy.values());
+            const rootNode = hierarchyArray.find((n)=>n.level === 0);
+            if (rootNode) {
+                try {
+                    await this.initiateShutdown(rootNode.agentId, 'Coordinator cleanup', swarmId);
+                } catch (error) {
+                    console.error(`Failed to shutdown swarm ${swarmId}:`, error);
+                }
+            }
+        });
+        await Promise.all(shutdownPromises);
+        // Clear all state
+        this.hierarchies.clear();
+        this.shutdownInProgress.clear();
+        this.resourceCleanupHandlers.clear();
+        this.emit('coordinator:cleanup');
+    }
+}
+
+//# sourceMappingURL=cascading-shutdown.js.map

package/.claude-flow-novice/dist/src/coordination/v2/coordinators/cascading-shutdown.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/coordinators/cascading-shutdown.ts"],"names":["EventEmitter","CascadingShutdown","hierarchies","Map","hierarchicalDetector","config","shutdownInProgress","Set","resourceCleanupHandlers","maxShutdownTimeMs","createShutdownCheckpoints","enableResourceCleanup","notificationTimeoutMs","completionTimeoutMs","enableEmergencyMode","agentGracePeriodMs","registerHierarchy","swarmId","rootCoordinatorId","nodes","hierarchyNodes","node","set","agentId","level","parentId","childIds","shutdownStatus","resources","sessionId","has","nodesArray2","Array","from","values","parent","get","includes","push","nodesArray","emit","totalAgents","size","maxDepth","Math","max","map","n","registerResourceCleanup","resourceType","handler","initiateShutdown","reason","startTime","Date","now","targetSwarmId","findSwarmByAgent","Error","hierarchy","rootNode","add","hierarchyArray","shutdownResult","success","successfulShutdowns","failedShutdowns","totalLatencyMs","notificationLatencyMs","aggregationLatencyMs","totalResourcesCleaned","agentResults","shutdownAt","notificationStartTime","notifyShutdownTopDown","aggregationStartTime","aggregateCompletionBottomUp","filter","r","length","reduce","sum","resourcesCleaned","console","warn","error","message","String","result","delete","emergencyShutdown","originalCheckpointConfig","originalCleanupConfig","rootId","queue","visited","levelSize","levelStartTime","notificationPromises","i","shift","notifyAgent","Promise","all","levelLatency","notifiedAt","timestamp","results","processNode","childId","shutdownAgent","notificationLatency","completionLatencyMs","resourcesFailed","checkpointId","cleanupResults","cleanupResources","cleaned","completedAt","cleanupPromises","resource","type","resourceId","id","entriesArray","entries","undefined","isShutdownInProgress","getShutdownStatus","hierarchiesArray","getConfig","unregisterHierarchy","cleanup","shutdownPromises","find","clear"],"mappings":"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"}