@sparkleideas/swarm 3.0.0-alpha.6-patch.16 → 3.0.0-alpha.6-patch.18

package/dist/queen-coordinator.js

@@ -1,1308 +0,0 @@
-/**
- * Queen Coordinator - Central Orchestrator for 15-Agent Swarm
- *
- * The Queen Coordinator is the strategic decision-maker for the V3 hive-mind system.
- * It analyzes tasks, delegates to appropriate agents, monitors swarm health,
- * coordinates consensus, and learns from outcomes using ReasoningBank patterns.
- *
- * Features:
- * - Strategic task analysis with ReasoningBank pattern matching
- * - Agent delegation with capability scoring and load balancing
- * - Swarm health monitoring with bottleneck detection
- * - Consensus coordination (majority, weighted, unanimous)
- * - Learning from outcomes for continuous improvement
- *
- * Performance Targets:
- * - Task analysis: <50ms
- * - Agent scoring: <20ms
- * - Consensus coordination: <100ms
- * - Health check: <30ms
- *
- * @module @sparkleideas/swarm/queen-coordinator
- */
-import { EventEmitter } from 'events';
-/**
- * Default Queen Coordinator configuration
- */
-const DEFAULT_CONFIG = {
-    enableLearning: true,
-    patternRetrievalK: 5,
-    patternThreshold: 0.6,
-    complexityThresholds: {
-        simple: 0.3,
-        moderate: 0.6,
-        complex: 0.85,
-    },
-    healthCheckIntervalMs: 10000,
-    bottleneckThresholds: {
-        queueDepth: 10,
-        errorRate: 0.1,
-        responseTimeMs: 5000,
-    },
-    consensusTimeouts: {
-        majority: 5000,
-        supermajority: 10000,
-        unanimous: 30000,
-    },
-    enableFailover: true,
-    maxDelegationAttempts: 3,
-};
-// =============================================================================
-// Queen Coordinator Class
-// =============================================================================
-/**
- * Queen Coordinator - Central orchestrator for the 15-agent hive-mind swarm
- *
- * The Queen is responsible for:
- * 1. Strategic task analysis and decomposition
- * 2. Agent delegation with load balancing
- * 3. Swarm health monitoring
- * 4. Consensus coordination
- * 5. Learning from outcomes
- */
-export class QueenCoordinator extends EventEmitter {
-    config;
-    swarm;
-    neural;
-    memory;
-    // Internal state
-    analysisCache = new Map();
-    delegationPlans = new Map();
-    activeDecisions = new Map();
-    outcomeHistory = [];
-    healthHistory = [];
-    // Counters for IDs
-    analysisCounter = 0;
-    planCounter = 0;
-    reportCounter = 0;
-    decisionCounter = 0;
-    // Health monitoring
-    healthCheckInterval;
-    lastHealthReport;
-    // Performance tracking
-    analysisLatencies = [];
-    delegationLatencies = [];
-    consensusLatencies = [];
-    constructor(swarm, config = {}, neural, memory) {
-        super();
-        this.swarm = swarm;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.neural = neural;
-        this.memory = memory;
-    }
-    // ===========================================================================
-    // Lifecycle
-    // ===========================================================================
-    /**
-     * Initialize the Queen Coordinator
-     */
-    async initialize() {
-        // Initialize neural system if available
-        if (this.neural && this.config.enableLearning) {
-            await this.neural.initialize();
-        }
-        // Start health monitoring
-        this.startHealthMonitoring();
-        this.emitEvent('queen.initialized', {
-            config: this.config,
-            learningEnabled: this.config.enableLearning && !!this.neural,
-        });
-    }
-    /**
-     * Shutdown the Queen Coordinator
-     */
-    async shutdown() {
-        this.stopHealthMonitoring();
-        // Trigger final learning if enabled
-        if (this.neural && this.config.enableLearning) {
-            await this.neural.triggerLearning();
-        }
-        this.emitEvent('queen.shutdown', {
-            totalAnalyses: this.analysisCounter,
-            totalPlans: this.planCounter,
-            totalDecisions: this.decisionCounter,
-        });
-    }
-    // ===========================================================================
-    // Strategic Task Analysis
-    // ===========================================================================
-    /**
-     * Analyze a task for optimal execution
-     *
-     * @param task - Task to analyze
-     * @returns Task analysis with recommendations
-     */
-    async analyzeTask(task) {
-        const startTime = performance.now();
-        this.analysisCounter++;
-        const analysisId = `analysis_${Date.now()}_${this.analysisCounter}`;
-        // Decompose complex tasks
-        const subtasks = this.decomposeTask(task);
-        // Identify required capabilities
-        const requiredCapabilities = this.identifyRequiredCapabilities(task);
-        // Calculate complexity
-        const complexity = this.calculateComplexity(task, subtasks);
-        // Estimate duration
-        const estimatedDurationMs = this.estimateDuration(task, complexity, subtasks);
-        // Determine recommended domain
-        const recommendedDomain = this.determineOptimalDomain(task, requiredCapabilities);
-        // Find matching patterns from ReasoningBank
-        const matchedPatterns = await this.findMatchingPatterns(task);
-        // Estimate resource requirements
-        const resourceRequirements = this.estimateResources(task, complexity);
-        // Calculate confidence
-        const confidence = this.calculateAnalysisConfidence(matchedPatterns, complexity, requiredCapabilities);
-        const analysis = {
-            analysisId,
-            taskId: task.id.id,
-            complexity,
-            estimatedDurationMs,
-            requiredCapabilities,
-            recommendedDomain,
-            subtasks,
-            matchedPatterns,
-            resourceRequirements,
-            confidence,
-            timestamp: new Date(),
-        };
-        // Cache the analysis
-        this.analysisCache.set(analysisId, analysis);
-        // Record latency
-        const latency = performance.now() - startTime;
-        this.analysisLatencies.push(latency);
-        if (this.analysisLatencies.length > 100) {
-            this.analysisLatencies.shift();
-        }
-        this.emitEvent('queen.task.analyzed', {
-            analysisId,
-            taskId: task.id.id,
-            complexity,
-            recommendedDomain,
-            patternsFound: matchedPatterns.length,
-            latencyMs: latency,
-        });
-        return analysis;
-    }
-    /**
-     * Decompose a complex task into subtasks
-     */
-    decomposeTask(task) {
-        const subtasks = [];
-        // Simple tasks don't need decomposition
-        if (this.isSimpleTask(task)) {
-            return subtasks;
-        }
-        // Decompose based on task type
-        switch (task.type) {
-            case 'coding':
-                subtasks.push(...this.decomposeCodingTask(task));
-                break;
-            case 'testing':
-                subtasks.push(...this.decomposeTestingTask(task));
-                break;
-            case 'research':
-                subtasks.push(...this.decomposeResearchTask(task));
-                break;
-            case 'coordination':
-                subtasks.push(...this.decomposeCoordinationTask(task));
-                break;
-            default:
-                // Generic decomposition
-                subtasks.push(...this.decomposeGenericTask(task));
-        }
-        return subtasks;
-    }
-    isSimpleTask(task) {
-        // Estimate if task is simple based on description length and type
-        const descLength = task.description?.length || 0;
-        const isSimpleType = ['documentation', 'review'].includes(task.type);
-        return descLength < 200 || isSimpleType;
-    }
-    decomposeCodingTask(task) {
-        return [
-            {
-                id: `${task.id.id}_design`,
-                name: 'Design & Planning',
-                description: 'Design the solution architecture',
-                type: 'analysis',
-                priority: task.priority,
-                dependencies: [],
-                estimatedDurationMs: 10000,
-                requiredCapabilities: ['design', 'architecture'],
-                recommendedDomain: 'core',
-            },
-            {
-                id: `${task.id.id}_implement`,
-                name: 'Implementation',
-                description: 'Implement the designed solution',
-                type: 'coding',
-                priority: task.priority,
-                dependencies: [`${task.id.id}_design`],
-                estimatedDurationMs: 30000,
-                requiredCapabilities: ['coding', 'implementation'],
-                recommendedDomain: 'integration',
-            },
-            {
-                id: `${task.id.id}_test`,
-                name: 'Testing',
-                description: 'Test the implementation',
-                type: 'testing',
-                priority: task.priority,
-                dependencies: [`${task.id.id}_implement`],
-                estimatedDurationMs: 15000,
-                requiredCapabilities: ['testing', 'validation'],
-                recommendedDomain: 'support',
-            },
-        ];
-    }
-    decomposeTestingTask(task) {
-        return [
-            {
-                id: `${task.id.id}_analyze`,
-                name: 'Test Analysis',
-                description: 'Analyze what needs to be tested',
-                type: 'analysis',
-                priority: task.priority,
-                dependencies: [],
-                estimatedDurationMs: 5000,
-                requiredCapabilities: ['analysis', 'testing'],
-                recommendedDomain: 'support',
-            },
-            {
-                id: `${task.id.id}_execute`,
-                name: 'Test Execution',
-                description: 'Execute the tests',
-                type: 'testing',
-                priority: task.priority,
-                dependencies: [`${task.id.id}_analyze`],
-                estimatedDurationMs: 20000,
-                requiredCapabilities: ['testing', 'execution'],
-                recommendedDomain: 'support',
-            },
-        ];
-    }
-    decomposeResearchTask(task) {
-        return [
-            {
-                id: `${task.id.id}_gather`,
-                name: 'Information Gathering',
-                description: 'Gather relevant information',
-                type: 'research',
-                priority: task.priority,
-                dependencies: [],
-                estimatedDurationMs: 15000,
-                requiredCapabilities: ['research', 'analysis'],
-                recommendedDomain: 'core',
-            },
-            {
-                id: `${task.id.id}_analyze`,
-                name: 'Analysis',
-                description: 'Analyze gathered information',
-                type: 'analysis',
-                priority: task.priority,
-                dependencies: [`${task.id.id}_gather`],
-                estimatedDurationMs: 10000,
-                requiredCapabilities: ['analysis', 'synthesis'],
-                recommendedDomain: 'core',
-            },
-        ];
-    }
-    decomposeCoordinationTask(task) {
-        return [
-            {
-                id: `${task.id.id}_plan`,
-                name: 'Planning',
-                description: 'Create coordination plan',
-                type: 'coordination',
-                priority: task.priority,
-                dependencies: [],
-                estimatedDurationMs: 5000,
-                requiredCapabilities: ['planning', 'coordination'],
-                recommendedDomain: 'queen',
-            },
-            {
-                id: `${task.id.id}_execute`,
-                name: 'Execution',
-                description: 'Execute coordination plan',
-                type: 'coordination',
-                priority: task.priority,
-                dependencies: [`${task.id.id}_plan`],
-                estimatedDurationMs: 10000,
-                requiredCapabilities: ['coordination', 'oversight'],
-                recommendedDomain: 'queen',
-            },
-        ];
-    }
-    decomposeGenericTask(task) {
-        return [
-            {
-                id: `${task.id.id}_execute`,
-                name: 'Task Execution',
-                description: task.description,
-                type: task.type,
-                priority: task.priority,
-                dependencies: [],
-                estimatedDurationMs: 20000,
-                requiredCapabilities: this.identifyRequiredCapabilities(task),
-                recommendedDomain: this.inferDomainFromType(task.type),
-            },
-        ];
-    }
-    /**
-     * Identify required capabilities for a task
-     */
-    identifyRequiredCapabilities(task) {
-        const capabilities = new Set();
-        // Add type-based capabilities
-        const typeCapabilities = {
-            research: ['research', 'analysis', 'synthesis'],
-            analysis: ['analysis', 'reasoning', 'synthesis'],
-            coding: ['coding', 'implementation', 'debugging'],
-            testing: ['testing', 'validation', 'quality'],
-            review: ['review', 'analysis', 'feedback'],
-            documentation: ['documentation', 'writing', 'clarity'],
-            coordination: ['coordination', 'planning', 'oversight'],
-            consensus: ['consensus', 'voting', 'agreement'],
-            custom: ['general', 'execution'],
-        };
-        for (const cap of typeCapabilities[task.type] || ['general']) {
-            capabilities.add(cap);
-        }
-        // Extract additional capabilities from description
-        const descLower = (task.description || '').toLowerCase();
-        if (descLower.includes('security'))
-            capabilities.add('security');
-        if (descLower.includes('performance'))
-            capabilities.add('performance');
-        if (descLower.includes('architecture'))
-            capabilities.add('architecture');
-        if (descLower.includes('integration'))
-            capabilities.add('integration');
-        if (descLower.includes('deploy'))
-            capabilities.add('deployment');
-        return Array.from(capabilities);
-    }
-    /**
-     * Calculate task complexity score
-     */
-    calculateComplexity(task, subtasks) {
-        let complexity = 0.3; // Base complexity
-        // Add complexity for subtasks
-        complexity += subtasks.length * 0.1;
-        // Add complexity for dependencies
-        const totalDeps = subtasks.reduce((sum, st) => sum + st.dependencies.length, 0);
-        complexity += totalDeps * 0.05;
-        // Add complexity for priority
-        const priorityMultipliers = {
-            critical: 1.3,
-            high: 1.15,
-            normal: 1.0,
-            low: 0.9,
-            background: 0.8,
-        };
-        complexity *= priorityMultipliers[task.priority];
-        // Add complexity for task type
-        const typeComplexity = {
-            coordination: 0.2,
-            consensus: 0.25,
-            coding: 0.15,
-            testing: 0.1,
-            analysis: 0.1,
-            research: 0.1,
-            review: 0.05,
-            documentation: 0.05,
-            custom: 0.1,
-        };
-        complexity += typeComplexity[task.type] || 0.1;
-        // Add complexity for description length
-        const descLength = task.description?.length || 0;
-        complexity += Math.min(descLength / 2000, 0.2);
-        return Math.min(complexity, 1.0);
-    }
-    /**
-     * Estimate task duration
-     */
-    estimateDuration(task, complexity, subtasks) {
-        // Base duration by type (in ms)
-        const baseDurations = {
-            research: 30000,
-            analysis: 20000,
-            coding: 60000,
-            testing: 30000,
-            review: 15000,
-            documentation: 20000,
-            coordination: 10000,
-            consensus: 15000,
-            custom: 30000,
-        };
-        const baseDuration = baseDurations[task.type] || 30000;
-        // Adjust for complexity
-        const complexityMultiplier = 0.5 + complexity * 1.5;
-        // Add subtask durations
-        const subtaskDuration = subtasks.reduce((sum, st) => sum + st.estimatedDurationMs, 0);
-        // Total estimate
-        return Math.round(baseDuration * complexityMultiplier + subtaskDuration * 0.5);
-    }
-    /**
-     * Determine optimal domain for task execution
-     */
-    determineOptimalDomain(task, capabilities) {
-        // Check capabilities for domain hints
-        if (capabilities.includes('security'))
-            return 'security';
-        if (capabilities.includes('coordination') || capabilities.includes('planning'))
-            return 'queen';
-        if (capabilities.includes('testing') || capabilities.includes('performance'))
-            return 'support';
-        if (capabilities.includes('integration'))
-            return 'integration';
-        // Fall back to type-based inference
-        return this.inferDomainFromType(task.type);
-    }
-    inferDomainFromType(type) {
-        const typeDomains = {
-            coordination: 'queen',
-            consensus: 'queen',
-            coding: 'integration',
-            testing: 'support',
-            review: 'security',
-            analysis: 'core',
-            research: 'core',
-            documentation: 'support',
-            custom: 'core',
-        };
-        return typeDomains[type] || 'core';
-    }
-    /**
-     * Find matching patterns from ReasoningBank
-     */
-    async findMatchingPatterns(task) {
-        const patterns = [];
-        if (!this.neural || !this.config.enableLearning) {
-            return patterns;
-        }
-        try {
-            // Create a simple embedding from task description
-            const embedding = this.createSimpleEmbedding(task.description || task.name);
-            // Query ReasoningBank for similar patterns
-            const results = await this.neural.findPatterns(embedding, this.config.patternRetrievalK);
-            for (const result of results) {
-                if (result.relevanceScore >= this.config.patternThreshold) {
-                    patterns.push({
-                        patternId: result.patternId,
-                        strategy: result.strategy,
-                        successRate: result.successRate,
-                        relevanceScore: result.relevanceScore,
-                        keyLearnings: result.keyLearnings || [],
-                    });
-                }
-            }
-        }
-        catch (error) {
-            // Log but don't fail - patterns are optional
-            this.emitEvent('queen.pattern.error', { error: String(error) });
-        }
-        return patterns;
-    }
-    /**
-     * Create a simple embedding from text using hash-based approach.
-     * For higher quality embeddings, integrate agentic-flow's computeEmbedding.
-     */
-    createSimpleEmbedding(text) {
-        // Hash-based embedding - lightweight and fast for local similarity matching
-        // For production ML embeddings, use: import('agentic-flow').computeEmbedding
-        const embedding = new Float32Array(768);
-        const words = text.toLowerCase().split(/\s+/);
-        for (let i = 0; i < words.length; i++) {
-            const word = words[i];
-            for (let j = 0; j < word.length; j++) {
-                const idx = (word.charCodeAt(j) * (i + 1) * (j + 1)) % 768;
-                embedding[idx] += 1 / words.length;
-            }
-        }
-        // Normalize
-        let norm = 0;
-        for (let i = 0; i < embedding.length; i++) {
-            norm += embedding[i] * embedding[i];
-        }
-        norm = Math.sqrt(norm);
-        if (norm > 0) {
-            for (let i = 0; i < embedding.length; i++) {
-                embedding[i] /= norm;
-            }
-        }
-        return embedding;
-    }
-    /**
-     * Estimate resource requirements
-     */
-    estimateResources(task, complexity) {
-        const minAgents = complexity > 0.7 ? 2 : 1;
-        const maxAgents = complexity > 0.8 ? 4 : complexity > 0.5 ? 3 : 2;
-        return {
-            minAgents,
-            maxAgents,
-            memoryMb: Math.round(256 + complexity * 512),
-            cpuIntensive: ['coding', 'analysis'].includes(task.type),
-            ioIntensive: ['research', 'testing'].includes(task.type),
-            networkRequired: task.type === 'research',
-        };
-    }
-    /**
-     * Calculate confidence in analysis
-     */
-    calculateAnalysisConfidence(patterns, complexity, capabilities) {
-        let confidence = 0.5; // Base confidence
-        // Higher confidence with more matching patterns
-        confidence += patterns.length * 0.1;
-        // Higher confidence for simpler tasks
-        confidence += (1 - complexity) * 0.2;
-        // Higher confidence with clear capabilities
-        confidence += Math.min(capabilities.length * 0.05, 0.15);
-        // Boost from high-success patterns
-        const avgPatternSuccess = patterns.length > 0
-            ? patterns.reduce((sum, p) => sum + p.successRate, 0) / patterns.length
-            : 0;
-        confidence += avgPatternSuccess * 0.1;
-        return Math.min(confidence, 0.95);
-    }
-    // ===========================================================================
-    // Agent Delegation
-    // ===========================================================================
-    /**
-     * Delegate a task to agents based on analysis
-     *
-     * @param task - Task to delegate
-     * @param analysis - Previous task analysis
-     * @returns Delegation plan
-     */
-    async delegateToAgents(task, analysis) {
-        const startTime = performance.now();
-        this.planCounter++;
-        const planId = `plan_${Date.now()}_${this.planCounter}`;
-        // Score all available agents for this task
-        const agentScores = this.scoreAgents(task, analysis.matchedPatterns);
-        // Select primary agent
-        const primaryAgent = this.selectPrimaryAgent(task, agentScores, analysis);
-        // Select backup agents
-        const backupAgents = this.selectBackupAgents(task, agentScores, primaryAgent);
-        // Create parallel assignments for subtasks
-        const parallelAssignments = this.createParallelAssignments(analysis.subtasks, agentScores);
-        // Determine execution strategy
-        const strategy = this.determineExecutionStrategy(analysis);
-        const plan = {
-            planId,
-            taskId: task.id.id,
-            analysisId: analysis.analysisId,
-            primaryAgent,
-            backupAgents,
-            parallelAssignments,
-            strategy,
-            estimatedCompletionMs: analysis.estimatedDurationMs,
-            timestamp: new Date(),
-        };
-        // Store the plan
-        this.delegationPlans.set(planId, plan);
-        // Execute the delegation
-        await this.executeDelegation(plan);
-        // Record latency
-        const latency = performance.now() - startTime;
-        this.delegationLatencies.push(latency);
-        if (this.delegationLatencies.length > 100) {
-            this.delegationLatencies.shift();
-        }
-        this.emitEvent('queen.task.delegated', {
-            planId,
-            taskId: task.id.id,
-            primaryAgent: primaryAgent.agentId,
-            strategy,
-            latencyMs: latency,
-        });
-        return plan;
-    }
-    /**
-     * Score agents for task assignment
-     */
-    scoreAgents(task, patterns) {
-        const agents = this.swarm.getAllAgents();
-        const scores = [];
-        for (const agent of agents) {
-            const score = this.scoreAgent(agent, task, patterns);
-            scores.push(score);
-        }
-        // Sort by total score descending
-        scores.sort((a, b) => b.totalScore - a.totalScore);
-        return scores;
-    }
-    scoreAgent(agent, task, patterns) {
-        const domain = this.getAgentDomain(agent);
-        // Capability score - how well agent capabilities match task
-        const capabilityScore = this.calculateCapabilityScore(agent, task);
-        // Load score - prefer less loaded agents
-        const loadScore = 1 - agent.workload;
-        // Performance score - based on past performance
-        const performanceScore = this.calculatePerformanceScore(agent, patterns);
-        // Health score - agent health
-        const healthScore = agent.health;
-        // Availability score - is agent actually available
-        const availabilityScore = agent.status === 'idle' ? 1.0 :
-            agent.status === 'busy' ? 0.3 : 0.0;
-        // Weighted total
-        const totalScore = capabilityScore * 0.30 +
-            loadScore * 0.20 +
-            performanceScore * 0.25 +
-            healthScore * 0.15 +
-            availabilityScore * 0.10;
-        return {
-            agentId: agent.id.id,
-            domain,
-            totalScore,
-            capabilityScore,
-            loadScore,
-            performanceScore,
-            healthScore,
-            availabilityScore,
-        };
-    }
-    calculateCapabilityScore(agent, task) {
-        let score = 0.5; // Base score
-        // Check type match
-        const typeMatches = {
-            research: ['researcher'],
-            analysis: ['analyst', 'researcher'],
-            coding: ['coder'],
-            testing: ['tester'],
-            review: ['reviewer'],
-            documentation: ['documenter'],
-            coordination: ['coordinator', 'queen'],
-            consensus: ['coordinator', 'queen'],
-            custom: ['worker'],
-        };
-        const preferredTypes = typeMatches[task.type] || ['worker'];
-        if (preferredTypes.includes(agent.type)) {
-            score += 0.3;
-        }
-        // Check specific capabilities
-        const caps = agent.capabilities;
-        if (task.type === 'coding' && caps.codeGeneration)
-            score += 0.1;
-        if (task.type === 'review' && caps.codeReview)
-            score += 0.1;
-        if (task.type === 'testing' && caps.testing)
-            score += 0.1;
-        if (task.type === 'coordination' && caps.coordination)
-            score += 0.1;
-        return Math.min(score, 1.0);
-    }
-    calculatePerformanceScore(agent, patterns) {
-        // Base on agent's success rate
-        let score = agent.metrics.successRate;
-        // Boost if patterns suggest this agent type is successful
-        const agentDomain = this.getAgentDomain(agent);
-        for (const pattern of patterns) {
-            if (pattern.strategy.toLowerCase().includes(agentDomain)) {
-                score += pattern.successRate * 0.1;
-            }
-        }
-        return Math.min(score, 1.0);
-    }
-    getAgentDomain(agent) {
-        // Determine domain from agent type
-        switch (agent.type) {
-            case 'queen':
-                return 'queen';
-            case 'specialist':
-                return 'security';
-            case 'architect':
-                return 'core';
-            case 'coder':
-                return 'integration';
-            case 'tester':
-                return 'support';
-            default:
-                return 'core';
-        }
-    }
-    selectPrimaryAgent(task, scores, analysis) {
-        // Prefer agent from recommended domain
-        const domainAgents = scores.filter(s => s.domain === analysis.recommendedDomain);
-        // Fall back to best overall if no domain match
-        const bestScore = domainAgents.length > 0 ? domainAgents[0] : scores[0];
-        return {
-            agentId: bestScore.agentId,
-            domain: bestScore.domain,
-            taskId: task.id.id,
-            score: bestScore.totalScore,
-            assignedAt: new Date(),
-        };
-    }
-    selectBackupAgents(task, scores, primary) {
-        const backups = [];
-        // Select up to 2 backup agents
-        for (const score of scores) {
-            if (score.agentId === primary.agentId)
-                continue;
-            if (score.totalScore < 0.3)
-                continue;
-            if (backups.length >= 2)
-                break;
-            backups.push({
-                agentId: score.agentId,
-                domain: score.domain,
-                taskId: task.id.id,
-                score: score.totalScore,
-                assignedAt: new Date(),
-            });
-        }
-        return backups;
-    }
-    createParallelAssignments(subtasks, scores) {
-        const assignments = [];
-        for (const subtask of subtasks) {
-            // Find best agent for this subtask's domain
-            const domainScores = scores.filter(s => s.domain === subtask.recommendedDomain);
-            const bestScore = domainScores.length > 0 ? domainScores[0] : scores[0];
-            assignments.push({
-                subtaskId: subtask.id,
-                agentId: bestScore.agentId,
-                domain: subtask.recommendedDomain,
-                dependencies: subtask.dependencies,
-            });
-        }
-        return assignments;
-    }
-    determineExecutionStrategy(analysis) {
-        const subtaskCount = analysis.subtasks.length;
-        if (subtaskCount === 0) {
-            return 'sequential';
-        }
-        // Check for dependencies
-        const hasDependencies = analysis.subtasks.some(st => st.dependencies.length > 0);
-        if (!hasDependencies && subtaskCount > 2) {
-            return 'parallel';
-        }
-        if (hasDependencies && subtaskCount > 3) {
-            return 'pipeline';
-        }
-        if (analysis.complexity > 0.7) {
-            return 'fan-out-fan-in';
-        }
-        return 'hybrid';
-    }
-    async executeDelegation(plan) {
-        // Delegate to the primary agent
-        await this.swarm.assignTaskToDomain(plan.taskId, plan.primaryAgent.domain);
-        // Notify about the delegation
-        await this.swarm.broadcastMessage({
-            type: 'delegation',
-            planId: plan.planId,
-            taskId: plan.taskId,
-            primaryAgent: plan.primaryAgent.agentId,
-            strategy: plan.strategy,
-        }, 'normal');
-    }
-    // ===========================================================================
-    // Swarm Health Monitoring
-    // ===========================================================================
-    /**
-     * Monitor swarm health and detect issues
-     *
-     * @returns Health report
-     */
-    async monitorSwarmHealth() {
-        this.reportCounter++;
-        const reportId = `health_${Date.now()}_${this.reportCounter}`;
-        const agents = this.swarm.getAllAgents();
-        const status = this.swarm.getStatus();
-        const metrics = this.swarm.getMetrics();
-        // Compute domain health
-        const domainHealth = this.computeDomainHealth(status.domains);
-        // Compute agent health
-        const agentHealth = this.computeAgentHealth(agents);
-        // Detect bottlenecks
-        const bottlenecks = this.detectBottlenecks(status, agents, metrics);
-        // Generate alerts
-        const alerts = this.generateAlerts(bottlenecks, agentHealth, metrics);
-        // Overall health score
-        const overallHealth = this.calculateOverallHealth(domainHealth, agentHealth, bottlenecks);
-        // Generate recommendations
-        const recommendations = this.generateRecommendations(bottlenecks, overallHealth);
-        // Compile health metrics
-        const healthMetrics = {
-            totalAgents: agents.length,
-            activeAgents: agents.filter(a => a.status === 'idle' || a.status === 'busy').length,
-            idleAgents: agents.filter(a => a.status === 'idle').length,
-            errorAgents: agents.filter(a => a.status === 'error').length,
-            totalTasks: metrics.totalTasks,
-            completedTasks: metrics.completedTasks,
-            failedTasks: metrics.failedTasks,
-            avgTaskDurationMs: metrics.avgTaskDurationMs,
-            taskThroughputPerMin: metrics.completedTasks / Math.max(metrics.uptime / 60, 1),
-            consensusSuccessRate: metrics.consensusSuccessRate,
-        };
-        const report = {
-            reportId,
-            timestamp: new Date(),
-            overallHealth,
-            domainHealth,
-            agentHealth,
-            bottlenecks,
-            alerts,
-            metrics: healthMetrics,
-            recommendations,
-        };
-        // Store in history
-        this.healthHistory.push(report);
-        if (this.healthHistory.length > 100) {
-            this.healthHistory.shift();
-        }
-        this.lastHealthReport = report;
-        this.emitEvent('queen.health.report', {
-            reportId,
-            overallHealth,
-            bottleneckCount: bottlenecks.length,
-            alertCount: alerts.length,
-        });
-        return report;
-    }
-    computeDomainHealth(domains) {
-        const health = new Map();
-        for (const domain of domains) {
-            const utilization = domain.agentCount > 0
-                ? domain.busyAgents / domain.agentCount
-                : 0;
-            const queuePressure = domain.tasksQueued > 5 ? 0.3 : domain.tasksQueued * 0.05;
-            const domainHealth = Math.max(0, 1 - queuePressure - (1 - utilization) * 0.2);
-            health.set(domain.name, {
-                domain: domain.name,
-                health: domainHealth,
-                activeAgents: domain.availableAgents + domain.busyAgents,
-                totalAgents: domain.agentCount,
-                queuedTasks: domain.tasksQueued,
-                avgResponseTimeMs: 0, // Would need tracking
-                errorRate: 0, // Would need tracking
-            });
-        }
-        return health;
-    }
-    computeAgentHealth(agents) {
-        return agents.map(agent => ({
-            agentId: agent.id.id,
-            domain: this.getAgentDomain(agent),
-            health: agent.health,
-            status: agent.status,
-            lastHeartbeat: agent.lastHeartbeat,
-            currentLoad: agent.workload,
-            recentErrors: agent.metrics.tasksFailed,
-        }));
-    }
-    detectBottlenecks(status, agents, metrics) {
-        const bottlenecks = [];
-        // Check domain queues
-        for (const domain of status.domains) {
-            if (domain.tasksQueued > this.config.bottleneckThresholds.queueDepth) {
-                bottlenecks.push({
-                    type: 'domain',
-                    location: domain.name,
-                    severity: domain.tasksQueued > 20 ? 'critical' : 'high',
-                    description: `High task queue depth in ${domain.name} domain`,
-                    impact: `${domain.tasksQueued} tasks waiting for processing`,
-                    suggestedAction: `Consider scaling ${domain.name} domain agents`,
-                });
-            }
-        }
-        // Check error agents
-        const errorAgents = agents.filter(a => a.status === 'error');
-        if (errorAgents.length > 0) {
-            bottlenecks.push({
-                type: 'agent',
-                location: errorAgents.map(a => a.id.id).join(', '),
-                severity: errorAgents.length > 3 ? 'critical' : 'medium',
-                description: `${errorAgents.length} agents in error state`,
-                impact: 'Reduced processing capacity',
-                suggestedAction: 'Investigate and recover error agents',
-            });
-        }
-        // Check coordination latency
-        if (metrics.coordinationLatencyMs > this.config.bottleneckThresholds.responseTimeMs) {
-            bottlenecks.push({
-                type: 'resource',
-                location: 'coordination',
-                severity: 'high',
-                description: 'High coordination latency detected',
-                impact: `Current latency: ${metrics.coordinationLatencyMs}ms`,
-                suggestedAction: 'Optimize coordination or reduce concurrent tasks',
-            });
-        }
-        return bottlenecks;
-    }
-    generateAlerts(bottlenecks, agentHealth, metrics) {
-        const alerts = [];
-        // Generate alerts for critical bottlenecks
-        for (const bottleneck of bottlenecks) {
-            if (bottleneck.severity === 'critical' || bottleneck.severity === 'high') {
-                alerts.push({
-                    alertId: `alert_${Date.now()}_${alerts.length}`,
-                    type: bottleneck.severity === 'critical' ? 'critical' : 'error',
-                    source: bottleneck.location,
-                    message: bottleneck.description,
-                    timestamp: new Date(),
-                    acknowledged: false,
-                });
-            }
-        }
-        // Alert on low overall agent health
-        const avgHealth = agentHealth.length > 0
-            ? agentHealth.reduce((sum, a) => sum + a.health, 0) / agentHealth.length
-            : 1.0;
-        if (avgHealth < 0.5) {
-            alerts.push({
-                alertId: `alert_${Date.now()}_health`,
-                type: avgHealth < 0.3 ? 'critical' : 'warning',
-                source: 'swarm',
-                message: `Low average agent health: ${(avgHealth * 100).toFixed(1)}%`,
-                timestamp: new Date(),
-                acknowledged: false,
-            });
-        }
-        // Alert on high failure rate
-        const failureRate = metrics.totalTasks > 0
-            ? metrics.failedTasks / metrics.totalTasks
-            : 0;
-        if (failureRate > this.config.bottleneckThresholds.errorRate) {
-            alerts.push({
-                alertId: `alert_${Date.now()}_failures`,
-                type: failureRate > 0.2 ? 'critical' : 'warning',
-                source: 'tasks',
-                message: `High task failure rate: ${(failureRate * 100).toFixed(1)}%`,
-                timestamp: new Date(),
-                acknowledged: false,
-            });
-        }
-        return alerts;
-    }
-    calculateOverallHealth(domainHealth, agentHealth, bottlenecks) {
-        // Average domain health
-        const domainHealthAvg = domainHealth.size > 0
-            ? Array.from(domainHealth.values()).reduce((sum, d) => sum + d.health, 0) / domainHealth.size
-            : 1.0;
-        // Average agent health
-        const agentHealthAvg = agentHealth.length > 0
-            ? agentHealth.reduce((sum, a) => sum + a.health, 0) / agentHealth.length
-            : 1.0;
-        // Bottleneck penalty
-        const bottleneckPenalty = bottlenecks.reduce((penalty, b) => {
-            switch (b.severity) {
-                case 'critical': return penalty + 0.2;
-                case 'high': return penalty + 0.1;
-                case 'medium': return penalty + 0.05;
-                case 'low': return penalty + 0.02;
-                default: return penalty;
-            }
-        }, 0);
-        const overallHealth = (domainHealthAvg * 0.4 + agentHealthAvg * 0.4) - bottleneckPenalty;
-        return Math.max(0, Math.min(1, overallHealth));
-    }
-    generateRecommendations(bottlenecks, overallHealth) {
-        const recommendations = [];
-        // Add bottleneck-specific recommendations
-        for (const bottleneck of bottlenecks) {
-            recommendations.push(bottleneck.suggestedAction);
-        }
-        // General recommendations based on health
-        if (overallHealth < 0.5) {
-            recommendations.push('Consider reducing task load or adding more agents');
-        }
-        if (overallHealth < 0.3) {
-            recommendations.push('URGENT: Investigate system-wide issues immediately');
-        }
-        return [...new Set(recommendations)]; // Deduplicate
-    }
-    startHealthMonitoring() {
-        this.healthCheckInterval = setInterval(async () => {
-            try {
-                await this.monitorSwarmHealth();
-            }
-            catch (error) {
-                this.emitEvent('queen.health.error', { error: String(error) });
-            }
-        }, this.config.healthCheckIntervalMs);
-    }
-    stopHealthMonitoring() {
-        if (this.healthCheckInterval) {
-            clearInterval(this.healthCheckInterval);
-            this.healthCheckInterval = undefined;
-        }
-    }
-    // ===========================================================================
-    // Consensus Coordination
-    // ===========================================================================
-    /**
-     * Coordinate consensus for a decision
-     *
-     * @param decision - Decision requiring consensus
-     * @returns Consensus result
-     */
-    async coordinateConsensus(decision) {
-        const startTime = performance.now();
-        this.decisionCounter++;
-        decision.decisionId = `decision_${Date.now()}_${this.decisionCounter}`;
-        // Store active decision
-        this.activeDecisions.set(decision.decisionId, decision);
-        try {
-            let result;
-            switch (decision.requiredConsensus) {
-                case 'queen-override':
-                    // Queen can make unilateral decisions for certain types
-                    result = this.queenOverride(decision);
-                    break;
-                case 'unanimous':
-                    result = await this.unanimousConsensus(decision);
-                    break;
-                case 'supermajority':
-                    result = await this.supermajorityConsensus(decision);
-                    break;
-                case 'weighted':
-                    result = await this.weightedConsensus(decision);
-                    break;
-                case 'majority':
-                default:
-                    result = await this.majorityConsensus(decision);
-            }
-            // Record latency
-            const latency = performance.now() - startTime;
-            this.consensusLatencies.push(latency);
-            if (this.consensusLatencies.length > 100) {
-                this.consensusLatencies.shift();
-            }
-            this.emitEvent('queen.consensus.completed', {
-                decisionId: decision.decisionId,
-                type: decision.requiredConsensus,
-                approved: result.approved,
-                approvalRate: result.approvalRate,
-                latencyMs: latency,
-            });
-            return result;
-        }
-        finally {
-            this.activeDecisions.delete(decision.decisionId);
-        }
-    }
-    queenOverride(decision) {
-        // Queen can make immediate decisions for:
-        // - Emergency actions
-        // - Agent termination
-        // - Priority overrides
-        const allowedTypes = ['emergency-action', 'agent-termination', 'priority-override'];
-        if (!allowedTypes.includes(decision.type)) {
-            throw new Error(`Queen override not allowed for decision type: ${decision.type}`);
-        }
-        return {
-            proposalId: decision.decisionId,
-            approved: true,
-            approvalRate: 1.0,
-            participationRate: 1.0,
-            finalValue: decision.proposal,
-            rounds: 1,
-            durationMs: 0,
-        };
-    }
-    async majorityConsensus(decision) {
-        // Use swarm's consensus engine with majority threshold
-        const result = await this.swarm.proposeConsensus({
-            decision,
-            threshold: 0.51,
-            timeout: this.config.consensusTimeouts.majority,
-        });
-        return result;
-    }
-    async supermajorityConsensus(decision) {
-        // Use swarm's consensus engine with 2/3 threshold
-        const result = await this.swarm.proposeConsensus({
-            decision,
-            threshold: 0.67,
-            timeout: this.config.consensusTimeouts.supermajority,
-        });
-        return result;
-    }
-    async unanimousConsensus(decision) {
-        // Use swarm's consensus engine with unanimous requirement
-        const result = await this.swarm.proposeConsensus({
-            decision,
-            threshold: 1.0,
-            timeout: this.config.consensusTimeouts.unanimous,
-        });
-        return result;
-    }
-    async weightedConsensus(decision) {
-        // Weighted consensus based on agent performance
-        // For now, delegate to the standard consensus with metadata
-        const agents = this.swarm.getAllAgents();
-        const weights = new Map();
-        for (const agent of agents) {
-            const weight = agent.metrics.successRate * agent.health;
-            weights.set(agent.id.id, weight);
-        }
-        const result = await this.swarm.proposeConsensus({
-            decision,
-            weights: Object.fromEntries(weights),
-            threshold: 0.51,
-            timeout: this.config.consensusTimeouts.majority,
-        });
-        return result;
-    }
-    // ===========================================================================
-    // Learning from Outcomes
-    // ===========================================================================
-    /**
-     * Record task outcome for learning
-     *
-     * @param task - Completed task
-     * @param result - Task result
-     */
-    async recordOutcome(task, result) {
-        // Store in outcome history
-        this.outcomeHistory.push(result);
-        if (this.outcomeHistory.length > 1000) {
-            this.outcomeHistory.shift();
-        }
-        // Learn from outcome if neural system available
-        if (this.neural && this.config.enableLearning) {
-            await this.learnFromOutcome(task, result);
-        }
-        // Store in memory service if available
-        if (this.memory) {
-            await this.storeOutcomeMemory(task, result);
-        }
-        this.emitEvent('queen.outcome.recorded', {
-            taskId: task.id.id,
-            success: result.success,
-            durationMs: result.durationMs,
-            qualityScore: result.metrics.qualityScore,
-        });
-    }
-    async learnFromOutcome(task, result) {
-        if (!this.neural)
-            return;
-        // Create trajectory for this task
-        const trajectoryId = this.neural.beginTask(task.description || task.name, result.domain);
-        // Record the execution step
-        const embedding = this.createSimpleEmbedding(task.description || task.name);
-        const reward = result.success
-            ? result.metrics.qualityScore * 0.8 + 0.2
-            : result.metrics.qualityScore * 0.3;
-        this.neural.recordStep(trajectoryId, `executed_${task.type}_in_${result.domain}`, reward, embedding);
-        // Complete the task trajectory
-        await this.neural.completeTask(trajectoryId, result.metrics.qualityScore);
-    }
-    async storeOutcomeMemory(task, result) {
-        if (!this.memory)
-            return;
-        try {
-            await this.memory.store({
-                key: `outcome_${task.id.id}`,
-                content: this.formatOutcomeContent(task, result),
-                namespace: 'queen-outcomes',
-                tags: [
-                    task.type,
-                    result.domain,
-                    result.success ? 'success' : 'failure',
-                ],
-                metadata: {
-                    taskId: task.id.id,
-                    success: result.success,
-                    durationMs: result.durationMs,
-                    qualityScore: result.metrics.qualityScore,
-                    agentId: result.agentId,
-                },
-            });
-        }
-        catch (error) {
-            // Log but don't fail - memory storage is optional
-            this.emitEvent('queen.memory.error', { error: String(error) });
-        }
-    }
-    formatOutcomeContent(task, result) {
-        return [
-            `Task: ${task.name}`,
-            `Type: ${task.type}`,
-            `Domain: ${result.domain}`,
-            `Agent: ${result.agentId}`,
-            `Success: ${result.success}`,
-            `Duration: ${result.durationMs}ms`,
-            `Quality: ${result.metrics.qualityScore}`,
-            `Description: ${task.description || 'N/A'}`,
-        ].join('\n');
-    }
-    // ===========================================================================
-    // Utility Methods
-    // ===========================================================================
-    /**
-     * Get the last health report
-     */
-    getLastHealthReport() {
-        return this.lastHealthReport;
-    }
-    /**
-     * Get outcome history
-     */
-    getOutcomeHistory() {
-        return [...this.outcomeHistory];
-    }
-    /**
-     * Get analysis cache
-     */
-    getAnalysisCache() {
-        return new Map(this.analysisCache);
-    }
-    /**
-     * Get delegation plans
-     */
-    getDelegationPlans() {
-        return new Map(this.delegationPlans);
-    }
-    /**
-     * Get performance statistics
-     */
-    getPerformanceStats() {
-        const avg = (arr) => arr.length > 0
-            ? arr.reduce((a, b) => a + b, 0) / arr.length
-            : 0;
-        return {
-            avgAnalysisLatencyMs: avg(this.analysisLatencies),
-            avgDelegationLatencyMs: avg(this.delegationLatencies),
-            avgConsensusLatencyMs: avg(this.consensusLatencies),
-            totalAnalyses: this.analysisCounter,
-            totalDelegations: this.planCounter,
-            totalDecisions: this.decisionCounter,
-        };
-    }
-    /**
-     * Check if learning is enabled
-     */
-    isLearningEnabled() {
-        return this.config.enableLearning && !!this.neural;
-    }
-    emitEvent(type, data) {
-        const event = {
-            id: `event_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
-            type,
-            source: 'queen-coordinator',
-            timestamp: new Date(),
-            data,
-        };
-        this.emit(type, event);
-        this.emit('event', event);
-    }
-}
-// =============================================================================
-// Factory Function
-// =============================================================================
-/**
- * Create a Queen Coordinator instance
- */
-export function createQueenCoordinator(swarm, config, neural, memory) {
-    return new QueenCoordinator(swarm, config, neural, memory);
-}
-export default QueenCoordinator;
-//# sourceMappingURL=queen-coordinator.js.map