claude-flow-novice 1.6.3 → 1.6.5

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/dependency-resolver.js

@@ -0,0 +1,335 @@
+/**
+ * Agent Coordination V2 - Dependency Resolver Implementation
+ *
+ * Provides dependency resolution with:
+ * - Full topological resolution (<100ms for 100 tasks)
+ * - Incremental batch resolution for concurrent execution
+ * - Critical path analysis for minimum execution time estimation
+ * - Parallelization factor calculation for agent pool sizing
+ * - Comprehensive validation with cycle detection
+ *
+ * @module coordination/v2/core/dependency-resolver
+ */ import { DependencyNodeStatus } from './dependency-node.js';
+/**
+ * Dependency Resolver for DAG-based task scheduling.
+ *
+ * Provides efficient dependency resolution algorithms with performance targets:
+ * - Full resolution: <100ms for 100 tasks
+ * - Incremental resolution: <10ms per batch
+ * - Critical path analysis: <50ms for 100 tasks
+ *
+ * @example
+ * ```typescript
+ * const resolver = new DependencyResolver(graph);
+ *
+ * // Validate resolution is possible
+ * const validation = resolver.canResolve();
+ * if (!validation.success) {
+ *   console.error('Blockers:', validation.blockers);
+ * }
+ *
+ * // Get next batch of ready tasks
+ * const batch = resolver.getNextBatch(5);
+ *
+ * // Analyze critical path
+ * const criticalPath = resolver.getCriticalPath();
+ * console.log('Min execution time:', criticalPath.estimatedDuration);
+ * ```
+ */ export class DependencyResolver {
+    graph;
+    /**
+   * Creates a new dependency resolver.
+   *
+   * @param graph - Dependency graph to resolve
+   */ constructor(graph){
+        this.graph = graph;
+    }
+    // ============================================
+    // Full Resolution
+    // ============================================
+    /**
+   * Performs full topological resolution of the dependency graph.
+   *
+   * Returns all nodes in dependency order (dependencies before dependents).
+   * Target: <100ms for 100 tasks.
+   *
+   * @returns Array of nodes in topological order
+   * @throws {DependencyGraphError} If graph contains cycles
+   */ resolve() {
+        const startTime = performance.now();
+        // Use graph's topological sort (already optimized with Kahn's algorithm)
+        const sortedIds = this.graph.getTopologicalOrder();
+        // Map IDs to nodes
+        const result = sortedIds.map((id)=>{
+            const node = this.graph.getNode(id);
+            if (!node) {
+                throw new Error(`Node ${id} not found in graph during resolution`);
+            }
+            return node;
+        });
+        const duration = performance.now() - startTime;
+        // Performance validation
+        if (duration > 100 && this.graph.size() === 100) {
+            console.warn(`Dependency resolution exceeded 100ms target: ${duration.toFixed(2)}ms for ${this.graph.size()} nodes`);
+        }
+        return result;
+    }
+    // ============================================
+    // Incremental Resolution
+    // ============================================
+    /**
+   * Gets the next batch of ready tasks for execution.
+   *
+   * Returns tasks with all dependencies satisfied, limited by maxConcurrency.
+   * Tasks are sorted by priority (highest first).
+   *
+   * @param maxConcurrency - Maximum number of tasks to return
+   * @returns Array of ready tasks (up to maxConcurrency)
+   */ getNextBatch(maxConcurrency) {
+        if (maxConcurrency < 1) {
+            throw new Error('maxConcurrency must be at least 1');
+        }
+        // Get ready tasks from graph (already sorted by priority)
+        const ready = this.graph.getReadyTasks();
+        // Return up to maxConcurrency tasks
+        return ready.slice(0, maxConcurrency);
+    }
+    // ============================================
+    // Critical Path Analysis
+    // ============================================
+    /**
+   * Analyzes the critical path through the dependency graph.
+   *
+   * The critical path is the longest dependency chain, which determines
+   * the minimum possible execution time for the entire graph.
+   *
+   * This is useful for:
+   * - Estimating minimum execution time
+   * - Identifying bottleneck tasks
+   * - Optimizing task priorities
+   *
+   * @returns Critical path analysis result
+   */ getCriticalPath() {
+        const nodes = this.graph.getAllNodes();
+        if (nodes.length === 0) {
+            return {
+                path: [],
+                estimatedDuration: 0,
+                depth: 0
+            };
+        }
+        // Build depth map: node -> maximum depth from root
+        const depthMap = new Map();
+        const pathMap = new Map(); // node -> path to node
+        // Initialize all nodes to depth 0
+        for (const node of nodes){
+            depthMap.set(node.id, 0);
+            pathMap.set(node.id, [
+                node.id
+            ]);
+        }
+        // Process nodes in topological order
+        const sortedIds = this.graph.getTopologicalOrder();
+        for (const nodeId of sortedIds){
+            const node = this.graph.getNode(nodeId);
+            const currentDepth = depthMap.get(nodeId);
+            const currentPath = pathMap.get(nodeId);
+            // Update all dependents
+            const dependents = this.graph.getDependents(nodeId);
+            for (const dependentId of dependents){
+                const dependentNode = this.graph.getNode(dependentId);
+                const newDepth = currentDepth + 1; // Each node adds 1 to depth
+                const existingDepth = depthMap.get(dependentId);
+                // Update if this path is longer
+                if (newDepth > existingDepth) {
+                    depthMap.set(dependentId, newDepth);
+                    pathMap.set(dependentId, [
+                        ...currentPath,
+                        dependentId
+                    ]);
+                }
+            }
+        }
+        // Find node with maximum depth (end of critical path)
+        let maxDepth = 0;
+        let criticalNodeId = sortedIds[0];
+        for (const [nodeId, depth] of depthMap){
+            if (depth > maxDepth) {
+                maxDepth = depth;
+                criticalNodeId = nodeId;
+            }
+        }
+        // Reconstruct critical path
+        const criticalPathIds = pathMap.get(criticalNodeId);
+        const criticalPathNodes = criticalPathIds.map((id)=>this.graph.getNode(id));
+        // Estimate duration (sum of priorities as proxy for execution time)
+        const estimatedDuration = criticalPathNodes.reduce((sum, node)=>sum + node.priority, 0);
+        return {
+            path: criticalPathNodes,
+            estimatedDuration,
+            depth: maxDepth
+        };
+    }
+    /**
+   * Calculates the parallelization factor for the graph.
+   *
+   * This is the maximum number of tasks that can run concurrently,
+   * useful for sizing the agent pool.
+   *
+   * Algorithm:
+   * 1. Group nodes by depth level in topological order
+   * 2. Find the level with the most nodes
+   * 3. Return that count as max parallelization
+   *
+   * @returns Maximum number of tasks that can run concurrently
+   */ getParallelizationFactor() {
+        const nodes = this.graph.getAllNodes();
+        if (nodes.length === 0) {
+            return 0;
+        }
+        // Build level map: depth -> count of nodes at that depth
+        const levelCounts = new Map();
+        // Calculate depth for each node
+        const depthMap = new Map();
+        const sortedIds = this.graph.getTopologicalOrder();
+        // Initialize
+        for (const nodeId of sortedIds){
+            depthMap.set(nodeId, 0);
+        }
+        // Calculate depths
+        for (const nodeId of sortedIds){
+            const dependencies = this.graph.getDependencies(nodeId);
+            if (dependencies.size === 0) {
+                depthMap.set(nodeId, 0);
+            } else {
+                // Depth is 1 + max depth of dependencies
+                let maxDepDepth = -1;
+                for (const depId of dependencies){
+                    const depDepth = depthMap.get(depId) ?? 0;
+                    maxDepDepth = Math.max(maxDepDepth, depDepth);
+                }
+                depthMap.set(nodeId, maxDepDepth + 1);
+            }
+        }
+        // Count nodes at each level
+        for (const depth of depthMap.values()){
+            levelCounts.set(depth, (levelCounts.get(depth) ?? 0) + 1);
+        }
+        // Find maximum count
+        let maxParallel = 0;
+        for (const count of levelCounts.values()){
+            maxParallel = Math.max(maxParallel, count);
+        }
+        return maxParallel;
+    }
+    // ============================================
+    // Validation
+    // ============================================
+    /**
+   * Validates that the dependency graph can be resolved.
+   *
+   * Checks for:
+   * - Circular dependencies (cycles)
+   * - Orphaned tasks (no path from root nodes)
+   * - Invalid node references
+   * - Graph consistency
+   *
+   * @returns Validation result with blockers and warnings
+   */ canResolve() {
+        const blockers = [];
+        const warnings = [];
+        // 1. Check for cycles
+        const cycleResult = this.graph.detectCycles();
+        if (cycleResult.hasCycle) {
+            blockers.push(`Circular dependency detected: ${cycleResult.cycles.map((c)=>c.join(' -> ')).join(', ')}`);
+        }
+        // 2. Check graph integrity
+        const graphErrors = this.graph.validate();
+        if (graphErrors.length > 0) {
+            blockers.push(...graphErrors.map((err)=>`Graph integrity error: ${err}`));
+        }
+        // 3. Check for orphaned tasks (nodes with no path to root)
+        const orphanedNodes = this.findOrphanedNodes();
+        if (orphanedNodes.length > 0) {
+            warnings.push(`Found ${orphanedNodes.length} orphaned nodes: ${orphanedNodes.slice(0, 5).join(', ')}${orphanedNodes.length > 5 ? '...' : ''}`);
+        }
+        // 4. Check for nodes in terminal failure state
+        const failedNodes = this.graph.getAllNodes().filter((node)=>node.status === DependencyNodeStatus.FAILED);
+        if (failedNodes.length > 0) {
+            warnings.push(`${failedNodes.length} nodes in FAILED state: ${failedNodes.slice(0, 3).map((n)=>n.id).join(', ')}${failedNodes.length > 3 ? '...' : ''}`);
+        }
+        // 5. Check for tasks with unresolvable dependencies
+        const unresolvableTasks = this.findUnresolvableTasks();
+        if (unresolvableTasks.length > 0) {
+            blockers.push(`Tasks with failed dependencies: ${unresolvableTasks.slice(0, 5).join(', ')}${unresolvableTasks.length > 5 ? ` (and ${unresolvableTasks.length - 5} more)` : ''}`);
+        }
+        return {
+            success: blockers.length === 0,
+            blockers,
+            warnings: warnings.length > 0 ? warnings : undefined
+        };
+    }
+    // ============================================
+    // Private Helper Methods
+    // ============================================
+    /**
+   * Finds orphaned nodes (no path from root nodes).
+   *
+   * A node is orphaned if:
+   * - It has dependencies BUT none of its dependencies exist in the graph
+   * - This typically indicates a graph construction error
+   *
+   * @returns Array of orphaned node IDs
+   */ findOrphanedNodes() {
+        const orphaned = [];
+        for (const node of this.graph.getAllNodes()){
+            const deps = this.graph.getDependencies(node.id);
+            if (deps.size > 0) {
+                // Check if any dependencies exist
+                let hasValidDependency = false;
+                for (const depId of deps){
+                    if (this.graph.hasNode(depId)) {
+                        hasValidDependency = true;
+                        break;
+                    }
+                }
+                if (!hasValidDependency) {
+                    orphaned.push(node.id);
+                }
+            }
+        }
+        return orphaned;
+    }
+    /**
+   * Finds tasks that cannot be resolved due to failed dependencies.
+   *
+   * A task is unresolvable if any of its dependencies (direct or transitive)
+   * are in FAILED state.
+   *
+   * @returns Array of unresolvable task IDs
+   */ findUnresolvableTasks() {
+        const unresolvable = [];
+        const failedNodes = new Set(this.graph.getAllNodes().filter((node)=>node.status === DependencyNodeStatus.FAILED).map((node)=>node.id));
+        if (failedNodes.size === 0) {
+            return [];
+        }
+        // For each node, check if it depends on a failed node
+        for (const node of this.graph.getAllNodes()){
+            if (failedNodes.has(node.id)) {
+                continue; // Already failed
+            }
+            // Get full dependency chain
+            const chain = this.graph.getDependencyChain(node.id);
+            // Check if any dependency is failed
+            for (const depId of chain){
+                if (failedNodes.has(depId)) {
+                    unresolvable.push(node.id);
+                    break;
+                }
+            }
+        }
+        return unresolvable;
+    }
+}
+
+//# sourceMappingURL=dependency-resolver.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/dependency-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/core/dependency-resolver.ts"],"names":["DependencyNodeStatus","DependencyResolver","graph","resolve","startTime","performance","now","sortedIds","getTopologicalOrder","result","map","id","node","getNode","Error","duration","size","console","warn","toFixed","getNextBatch","maxConcurrency","ready","getReadyTasks","slice","getCriticalPath","nodes","getAllNodes","length","path","estimatedDuration","depth","depthMap","Map","pathMap","set","nodeId","currentDepth","get","currentPath","dependents","getDependents","dependentId","dependentNode","newDepth","existingDepth","maxDepth","criticalNodeId","criticalPathIds","criticalPathNodes","reduce","sum","priority","getParallelizationFactor","levelCounts","dependencies","getDependencies","maxDepDepth","depId","depDepth","Math","max","values","maxParallel","count","canResolve","blockers","warnings","cycleResult","detectCycles","hasCycle","push","cycles","c","join","graphErrors","validate","err","orphanedNodes","findOrphanedNodes","failedNodes","filter","status","FAILED","n","unresolvableTasks","findUnresolvableTasks","success","undefined","orphaned","deps","hasValidDependency","hasNode","unresolvable","Set","has","chain","getDependencyChain"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/help-request-metrics.js

@@ -0,0 +1,211 @@
+/**
+ * Agent Coordination V2 - Help Request Metrics
+ *
+ * Tracks metrics for agent help requests and helper state management.
+ * Monitors WAITING → HELPING transitions, checkpoint recovery times,
+ * and helper collaboration performance.
+ *
+ * @module coordination/v2/core/help-request-metrics
+ */ /**
+ * HelpRequestTracker - Manages help request metrics and checkpoint recovery
+ */ export class HelpRequestTracker {
+    helpRequests = new Map();
+    activeHelpers = new Map();
+    waitTimes = [];
+    helpDurations = [];
+    checkpointRecoveryTimes = [];
+    metrics = {
+        totalRequests: 0,
+        completedRequests: 0,
+        failedRequests: 0,
+        averageWaitTimeMs: 0,
+        averageHelpDurationMs: 0,
+        p99CheckpointRecoveryMs: 0,
+        totalCheckpointRecoveries: 0,
+        activeRequests: 0
+    };
+    /**
+   * Create a new help request
+   */ createHelpRequest(requestingAgentId, helperAgentId, reason) {
+        const requestId = this.generateRequestId(requestingAgentId, helperAgentId);
+        const request = {
+            id: requestId,
+            requestingAgentId,
+            helperAgentId,
+            requestedAt: Date.now(),
+            reason,
+            status: 'pending'
+        };
+        this.helpRequests.set(requestId, request);
+        this.metrics.totalRequests++;
+        this.metrics.activeRequests++;
+        return requestId;
+    }
+    /**
+   * Mark help request as started (helper transitioned to HELPING)
+   */ startHelp(requestId, checkpointId) {
+        const request = this.helpRequests.get(requestId);
+        if (!request) {
+            throw new Error(`Help request ${requestId} not found`);
+        }
+        request.startedAt = Date.now();
+        request.status = 'in_progress';
+        request.checkpointId = checkpointId;
+        // Track wait time
+        const waitTime = request.startedAt - request.requestedAt;
+        this.waitTimes.push(waitTime);
+        this.updateAverageWaitTime();
+        // Mark helper as active
+        this.activeHelpers.set(request.helperAgentId, requestId);
+    }
+    /**
+   * Mark help request as completed
+   */ completeHelp(requestId) {
+        const request = this.helpRequests.get(requestId);
+        if (!request) {
+            throw new Error(`Help request ${requestId} not found`);
+        }
+        request.completedAt = Date.now();
+        request.status = 'completed';
+        // Track help duration
+        if (request.startedAt) {
+            const duration = request.completedAt - request.startedAt;
+            this.helpDurations.push(duration);
+            this.updateAverageHelpDuration();
+        }
+        // Update metrics
+        this.metrics.completedRequests++;
+        this.metrics.activeRequests = Math.max(0, this.metrics.activeRequests - 1);
+        // Remove from active helpers
+        this.activeHelpers.delete(request.helperAgentId);
+    }
+    /**
+   * Mark help request as failed
+   */ failHelp(requestId, error) {
+        const request = this.helpRequests.get(requestId);
+        if (!request) {
+            throw new Error(`Help request ${requestId} not found`);
+        }
+        request.status = 'failed';
+        request.error = error;
+        this.metrics.failedRequests++;
+        this.metrics.activeRequests = Math.max(0, this.metrics.activeRequests - 1);
+        // Remove from active helpers
+        this.activeHelpers.delete(request.helperAgentId);
+    }
+    /**
+   * Track checkpoint recovery for helper state preservation
+   */ trackCheckpointRecovery(recoveryLatencyMs) {
+        this.checkpointRecoveryTimes.push(recoveryLatencyMs);
+        this.metrics.totalCheckpointRecoveries++;
+        this.updateCheckpointRecoveryMetrics();
+        // Enforce p99 < 500ms requirement
+        if (recoveryLatencyMs > 500 && this.metrics.totalCheckpointRecoveries >= 100) {
+            console.warn(`⚠️ Checkpoint recovery exceeded 500ms: ${recoveryLatencyMs.toFixed(2)}ms (p99: ${this.metrics.p99CheckpointRecoveryMs.toFixed(2)}ms)`);
+        }
+    }
+    /**
+   * Get help request by ID
+   */ getHelpRequest(requestId) {
+        return this.helpRequests.get(requestId);
+    }
+    /**
+   * Get active help request for helper agent
+   */ getActiveHelpForAgent(helperAgentId) {
+        const requestId = this.activeHelpers.get(helperAgentId);
+        if (!requestId) {
+            return undefined;
+        }
+        return this.helpRequests.get(requestId);
+    }
+    /**
+   * Get all active help requests
+   */ getActiveHelpRequests() {
+        return Array.from(this.helpRequests.values()).filter((r)=>r.status === 'in_progress' || r.status === 'pending');
+    }
+    /**
+   * Get help request metrics
+   */ getMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    /**
+   * Reset metrics (for testing)
+   */ resetMetrics() {
+        this.helpRequests.clear();
+        this.activeHelpers.clear();
+        this.waitTimes = [];
+        this.helpDurations = [];
+        this.checkpointRecoveryTimes = [];
+        this.metrics = {
+            totalRequests: 0,
+            completedRequests: 0,
+            failedRequests: 0,
+            averageWaitTimeMs: 0,
+            averageHelpDurationMs: 0,
+            p99CheckpointRecoveryMs: 0,
+            totalCheckpointRecoveries: 0,
+            activeRequests: 0
+        };
+    }
+    /**
+   * Private: Generate unique request ID
+   */ generateRequestId(requestingAgentId, helperAgentId) {
+        const timestamp = Date.now();
+        return `help_${requestingAgentId}_${helperAgentId}_${timestamp}`;
+    }
+    /**
+   * Private: Update average wait time
+   */ updateAverageWaitTime() {
+        if (this.waitTimes.length === 0) return;
+        const sum = this.waitTimes.reduce((acc, time)=>acc + time, 0);
+        this.metrics.averageWaitTimeMs = sum / this.waitTimes.length;
+        // Keep only last 1000 samples
+        if (this.waitTimes.length > 1000) {
+            this.waitTimes = this.waitTimes.slice(-1000);
+        }
+    }
+    /**
+   * Private: Update average help duration
+   */ updateAverageHelpDuration() {
+        if (this.helpDurations.length === 0) return;
+        const sum = this.helpDurations.reduce((acc, time)=>acc + time, 0);
+        this.metrics.averageHelpDurationMs = sum / this.helpDurations.length;
+        // Keep only last 1000 samples
+        if (this.helpDurations.length > 1000) {
+            this.helpDurations = this.helpDurations.slice(-1000);
+        }
+    }
+    /**
+   * Private: Update checkpoint recovery metrics
+   */ updateCheckpointRecoveryMetrics() {
+        if (this.checkpointRecoveryTimes.length === 0) return;
+        // Calculate p99
+        const sorted = [
+            ...this.checkpointRecoveryTimes
+        ].sort((a, b)=>a - b);
+        const p99Index = Math.floor(sorted.length * 0.99);
+        this.metrics.p99CheckpointRecoveryMs = sorted[p99Index] || sorted[sorted.length - 1];
+        // Keep only last 1000 samples for p99 calculation
+        if (this.checkpointRecoveryTimes.length > 1000) {
+            this.checkpointRecoveryTimes = this.checkpointRecoveryTimes.slice(-1000);
+        }
+    }
+    /**
+   * Clean up old completed/failed requests (retention policy)
+   */ cleanup(retentionMs = 3600000) {
+        const cutoffTime = Date.now() - retentionMs;
+        let deletedCount = 0;
+        for (const [requestId, request] of this.helpRequests.entries()){
+            const isOld = request.completedAt ? request.completedAt < cutoffTime : request.requestedAt < cutoffTime;
+            if ((request.status === 'completed' || request.status === 'failed') && isOld) {
+                this.helpRequests.delete(requestId);
+                deletedCount++;
+            }
+        }
+        return deletedCount;
+    }
+}
+
+//# sourceMappingURL=help-request-metrics.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/help-request-metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/core/help-request-metrics.ts"],"names":["HelpRequestTracker","helpRequests","Map","activeHelpers","waitTimes","helpDurations","checkpointRecoveryTimes","metrics","totalRequests","completedRequests","failedRequests","averageWaitTimeMs","averageHelpDurationMs","p99CheckpointRecoveryMs","totalCheckpointRecoveries","activeRequests","createHelpRequest","requestingAgentId","helperAgentId","reason","requestId","generateRequestId","request","id","requestedAt","Date","now","status","set","startHelp","checkpointId","get","Error","startedAt","waitTime","push","updateAverageWaitTime","completeHelp","completedAt","duration","updateAverageHelpDuration","Math","max","delete","failHelp","error","trackCheckpointRecovery","recoveryLatencyMs","updateCheckpointRecoveryMetrics","console","warn","toFixed","getHelpRequest","getActiveHelpForAgent","undefined","getActiveHelpRequests","Array","from","values","filter","r","getMetrics","resetMetrics","clear","timestamp","length","sum","reduce","acc","time","slice","sorted","sort","a","b","p99Index","floor","cleanup","retentionMs","cutoffTime","deletedCount","entries","isOld"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/index.js

@@ -0,0 +1,33 @@
+/**
+ * Agent Coordination V2 - Core Module Exports
+ *
+ * Phase 01: State Machine
+ * Phase 02: Dependency Graph
+ * Phase 03: Message Bus
+ *
+ * @module coordination/v2/core
+ */ // ============================================
+// Phase 01: State Machine
+// ============================================
+export { AgentState } from './agent-state.js';
+export { StateMachine } from './state-machine.js';
+export { STATE_TRANSITIONS, EVENT_STATE_MAPPING, DEFAULT_STATE_MACHINE_CONFIG, validateTransitionMatrix, validateEventMapping, getValidNextStates, isValidTransition, getExpectedStateForEvent, validateStateMachineConfig } from './state-machine-config.js';
+export { TransitionEventType, validateTransition, createTransitionEvent, isEventType, isErrorEvent, isTerminalEvent } from './state-transition.js';
+export { HelpRequestTracker } from './help-request-metrics.js';
+// ============================================
+// Phase 02: Dependency Graph
+// ============================================
+export { DependencyGraph, DependencyGraphError } from './dependency-graph.js';
+export { DependencyNodeImpl, DependencyNodeStatus, DependencyNodeValidationError } from './dependency-node.js';
+export { DependencyResolver } from './dependency-resolver.js';
+export { TaskScheduler } from './task-scheduler.js';
+// ============================================
+// Phase 03: Message Bus
+// ============================================
+export { MessagePriority, DeliverySemantics, MessageValidationError, MessageUtils } from './message.js';
+export { MessageBroker, MessageBrokerError } from './message-broker.js';
+export { TopicManager } from './topic-manager.js';
+export { MessageRouter } from './message-router.js';
+export { DeadLetterQueue } from './dead-letter-queue.js';
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/core/index.ts"],"names":["AgentState","StateMachine","STATE_TRANSITIONS","EVENT_STATE_MAPPING","DEFAULT_STATE_MACHINE_CONFIG","validateTransitionMatrix","validateEventMapping","getValidNextStates","isValidTransition","getExpectedStateForEvent","validateStateMachineConfig","TransitionEventType","validateTransition","createTransitionEvent","isEventType","isErrorEvent","isTerminalEvent","HelpRequestTracker","DependencyGraph","DependencyGraphError","DependencyNodeImpl","DependencyNodeStatus","DependencyNodeValidationError","DependencyResolver","TaskScheduler","MessagePriority","DeliverySemantics","MessageValidationError","MessageUtils","MessageBroker","MessageBrokerError","TopicManager","MessageRouter","DeadLetterQueue"],"mappings":"AAAA;;;;;;;;CAQC,GAED,+CAA+C;AAC/C,0BAA0B;AAC1B,+CAA+C;AAE/C,SACEA,UAAU,QACL,mBAAmB;AAE1B,SACEC,YAAY,QAMP,qBAAqB;AAE5B,SACEC,iBAAiB,EACjBC,mBAAmB,EAEnBC,4BAA4B,EAC5BC,wBAAwB,EACxBC,oBAAoB,EACpBC,kBAAkB,EAClBC,iBAAiB,EACjBC,wBAAwB,EACxBC,0BAA0B,QACrB,4BAA4B;AAEnC,SACEC,mBAAmB,EASnBC,kBAAkB,EAClBC,qBAAqB,EACrBC,WAAW,EACXC,YAAY,EACZC,eAAe,QACV,wBAAwB;AAE/B,SACEC,kBAAkB,QAIb,4BAA4B;AAEnC,+CAA+C;AAC/C,6BAA6B;AAC7B,+CAA+C;AAE/C,SACEC,eAAe,EAEfC,oBAAoB,QAEf,wBAAwB;AAE/B,SACEC,kBAAkB,EAClBC,oBAAoB,EACpBC,6BAA6B,QAGxB,uBAAuB;AAE9B,SACEC,kBAAkB,QAGb,2BAA2B;AAElC,SACEC,aAAa,QAMR,sBAAsB;AAE7B,+CAA+C;AAC/C,wBAAwB;AACxB,+CAA+C;AAE/C,SAGEC,eAAe,EACfC,iBAAiB,EACjBC,sBAAsB,EAQtBC,YAAY,QACP,eAAe;AAEtB,SACEC,aAAa,EACbC,kBAAkB,QAEb,sBAAsB;AAE7B,SACEC,YAAY,QAGP,qBAAqB;AAE5B,SACEC,aAAa,QAIR,sBAAsB;AAE7B,SACEC,eAAe,QAKV,yBAAyB"}