agentic-qe 3.6.7 → 3.6.9

package/v3/dist/coordination/queen-coordinator.js

@@ -8,19 +8,24 @@
  * - Coordinates 47 agents across 12 domains
  * - Implements work stealing for load balancing
  * - Orchestrates cross-domain protocols
+ *
+ * Implementation split across:
+ * - queen-types.ts: Types, interfaces, constants, config
+ * - queen-event-handlers.ts: Domain/task/agent event handling, pattern training
+ * - queen-task-management.ts: Task assignment, queue ops, domain routing
+ * - queen-work-stealing.ts: Work stealing algorithm
+ * - queen-lifecycle.ts: Initialize/dispose, state persistence, cleanup
  */
 import { v4 as uuidv4 } from 'uuid';
 import { ALL_DOMAINS, ok, err, } from '../shared/types';
-import { CircularBuffer, binaryInsert, createdAtComparator } from '../shared/utils/index.js';
+import { CircularBuffer } from '../shared/utils/index.js';
 import { createTaskAuditLogger } from './services';
 import { createQueenMinCutBridge, } from './mincut/queen-integration';
 import { getSharedMinCutGraph } from './mincut/shared-singleton';
 // V3 Integration: TinyDancer intelligent model routing (TD-004, TD-005, TD-006)
 import { QueenRouterAdapter, } from '../routing/queen-integration.js';
-// V3 Integration: Cross-Phase Memory Hooks (QCSD feedback loops)
-import { getCrossPhaseHookExecutor } from '../hooks/cross-phase-hooks.js';
 // V3 Integration: @claude-flow/guidance governance (ADR-058)
-import { queenGovernanceAdapter, } from '../governance/index.js';
+import { queenGovernanceAdapter } from '../governance/index.js';
 // ADR-064 Integration: Agent Teams, Circuit Breakers, Fleet Tiers
 import { createAgentTeamsAdapter } from './agent-teams/index.js';
 import { createDomainTeamManager } from './agent-teams/domain-team-manager.js';
@@ -34,80 +39,16 @@ import { createTraceCollector } from './agent-teams/tracing.js';
 import { createHypothesisManager } from './competing-hypotheses/index.js';
 import { createFederationMailbox } from './federation/index.js';
 import { createDynamicScaler } from './dynamic-scaling/index.js';
-/**
- * Type guard to check if a plugin supports MinCut integration
- * ADR-047: Uses proper typing instead of `as any`
- */
-function isMinCutAwarePlugin(plugin) {
-    return typeof plugin.setMinCutBridge === 'function';
-}
-// ============================================================================
-// Domain Groups (per Master Plan Section 4.1)
-// ============================================================================
-export const DOMAIN_GROUPS = [
-    {
-        name: 'Core Testing',
-        domains: ['test-generation', 'test-execution', 'coverage-analysis', 'quality-assessment'],
-        priority: 'p0',
-        description: 'Core testing workflow domains',
-    },
-    {
-        name: 'Intelligence',
-        domains: ['defect-intelligence', 'code-intelligence', 'requirements-validation', 'security-compliance'],
-        priority: 'p0',
-        description: 'Intelligence and analysis domains',
-    },
-    {
-        name: 'Specialized',
-        domains: ['contract-testing', 'visual-accessibility', 'chaos-resilience', 'learning-optimization'],
-        priority: 'p1',
-        description: 'Specialized testing domains',
-    },
-];
-// Task type to domain mapping
-const TASK_DOMAIN_MAP = {
-    'generate-tests': ['test-generation'],
-    'execute-tests': ['test-execution'],
-    'analyze-coverage': ['coverage-analysis'],
-    'assess-quality': ['quality-assessment'],
-    'predict-defects': ['defect-intelligence'],
-    'validate-requirements': ['requirements-validation'],
-    'index-code': ['code-intelligence'],
-    'scan-security': ['security-compliance'],
-    'validate-contracts': ['contract-testing'],
-    'test-accessibility': ['visual-accessibility'],
-    'run-chaos': ['chaos-resilience'],
-    'optimize-learning': ['learning-optimization'],
-    'cross-domain-workflow': ALL_DOMAINS,
-    'protocol-execution': ALL_DOMAINS,
-    // QCSD Ideation Swarm: requirements-validation is primary, with support from coverage-analysis and security-compliance
-    'ideation-assessment': ['requirements-validation', 'coverage-analysis', 'security-compliance'],
-};
-// ============================================================================
-// Default Configuration
-// ============================================================================
-const DEFAULT_CONFIG = {
-    maxConcurrentTasks: 50,
-    defaultTaskTimeout: 300000, // 5 minutes
-    taskRetryLimit: 3,
-    workStealing: {
-        enabled: true,
-        idleThreshold: 5000, // 5 seconds
-        loadThreshold: 10,
-        stealBatchSize: 3,
-        checkInterval: 10000, // 10 seconds
-    },
-    enableMetrics: true,
-    metricsInterval: 60000, // 1 minute
-    priorityWeights: {
-        p0: 100,
-        p1: 50,
-        p2: 25,
-        p3: 10,
-    },
-    // V3 Integration: Enable intelligent model routing by default
-    enableRouting: true,
-};
+// Types, interfaces, constants, and config
+import { DEFAULT_QUEEN_CONFIG, initializeTaskDomainMap, } from './queen-types.js';
+export { DOMAIN_GROUPS, TASK_DOMAIN_MAP } from './queen-types.js';
+// Extracted modules
+import { subscribeToEvents, computeDomainHealthFromAgents } from './queen-event-handlers.js';
+import { enqueueTask, removeFromQueues, getQueuePosition, processQueue, listTasks as listTasksImpl, assignTask, assignTaskToDomain, } from './queen-task-management.js';
+import { triggerWorkStealing as triggerWorkStealingImpl, startWorkStealingTimer } from './queen-work-stealing.js';
+import { isMinCutAwarePlugin, injectMinCutBridgeIntoPlugins, loadState, saveState, startMetricsCollectionTimer, cleanupCompletedTasks as cleanupCompletedTasksImpl, getEnabledDomains, } from './queen-lifecycle.js';
+// Initialize TASK_DOMAIN_MAP entries that need ALL_DOMAINS
+initializeTaskDomainMap(ALL_DOMAINS);
 // ============================================================================
 // Queen Coordinator Implementation
 // ============================================================================
@@ -129,42 +70,32 @@ export class QueenCoordinator {
     metricsTimer = null;
     cleanupTimer = null;
     startTime = new Date();
-    // Store subscription IDs for proper cleanup (PAP-003 memory leak fix)
-    // These IDs are used to unsubscribe from events during dispose()
+    // PAP-003: Store subscription IDs for proper cleanup
     eventSubscriptionIds = [];
-    // Atomic counter for concurrent task tracking (CC-002 race condition fix)
-    // This counter is incremented/decremented atomically to prevent TOCTOU race conditions
+    // CC-002: Atomic counter for concurrent task tracking
     runningTaskCounter = 0;
     // Metrics counters
     tasksReceived = 0;
     tasksCompleted = 0;
     tasksFailed = 0;
     tasksStolen = 0;
-    // MEM-001 FIX: Use CircularBuffer instead of array to avoid O(n) shift() operations
-    // CircularBuffer provides O(1) push with automatic oldest-entry overwrite
     taskDurations = new CircularBuffer(1000);
     protocolsExecuted = 0;
     workflowsExecuted = 0;
-    // SEC-003 Simplified: Lightweight audit logging for task operations
+    // SEC-003: Lightweight audit logging
     auditLogger;
     // ADR-047: MinCut topology health monitoring
     minCutBridge = null;
-    // V3 Integration: TinyDancer intelligent model routing (TD-004, TD-005, TD-006)
+    // V3: TinyDancer intelligent model routing
     tinyDancerRouter = null;
-    // ADR-064 Integration: Domain-level circuit breakers
+    // ADR-064: Subsystems
     domainBreakerRegistry = null;
-    // ADR-064 Integration: Domain team management
     domainTeamManager = null;
     agentTeamsAdapter = null;
-    // ADR-064 Integration: Fleet tier selector
     tierSelector = null;
-    // ADR-064 Phase 3: TaskCompletedHook for pattern training
     taskCompletedHook = null;
-    // ADR-064 Phase 3: Distributed Tracing
     traceCollector = null;
-    // ADR-064 Phase 3: Track trace contexts for tasks
     taskTraceContexts = new Map();
-    // ADR-064 Phase 4: Advanced Patterns
     hypothesisManager = null;
     federationMailbox = null;
     dynamicScaler = null;
@@ -176,8 +107,7 @@ export class QueenCoordinator {
         this.protocolExecutor = protocolExecutor;
         this.workflowExecutor = workflowExecutor;
         this.domainPlugins = domainPlugins;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // SEC-003 Simplified: Initialize lightweight audit logger
+        this.config = { ...DEFAULT_QUEEN_CONFIG, ...config };
         this.auditLogger = createTaskAuditLogger({
             enableConsoleLog: this.config.enableMetrics,
             maxEntries: 1000,
@@ -187,8 +117,7 @@ export class QueenCoordinator {
         ['p0', 'p1', 'p2', 'p3'].forEach(p => {
             this.taskQueue.set(p, []);
         });
-        // V3 Integration: Initialize TinyDancer intelligent model routing (TD-004, TD-005, TD-006)
-        // Routes tasks to optimal agent tiers (haiku/sonnet/opus) based on complexity
+        // V3: Initialize TinyDancer routing
         if (this.config.enableRouting !== false) {
             this.tinyDancerRouter = new QueenRouterAdapter(this.config.routing);
         }
@@ -205,45 +134,35 @@ export class QueenCoordinator {
         if (this.initialized)
             return;
         this.startTime = new Date();
-        // Initialize cross-domain router
         await this.router.initialize();
-        // Subscribe to domain events for coordination
+        // Subscribe to domain events
         this.subscribeToEvents();
         // Start work stealing if enabled
         if (this.config.workStealing.enabled) {
-            this.startWorkStealing();
+            this.workStealingTimer = startWorkStealingTimer(this.config, () => this.triggerWorkStealing().then(() => { }));
         }
         // Start metrics collection if enabled
         if (this.config.enableMetrics) {
-            this.startMetricsCollection();
+            this.metricsTimer = startMetricsCollectionTimer(this.createMetricsContext());
         }
-        // MEM-002 FIX: Start automatic cleanup of completed/failed tasks to prevent memory leak
-        // Tasks map accumulates indefinitely without cleanup - run every 5 minutes, retain for 1 hour
+        // MEM-002 FIX: Automatic cleanup of completed/failed tasks
         this.cleanupTimer = setInterval(() => {
-            this.cleanupCompletedTasks(3600000); // 1 hour retention
-        }, 300000); // Run every 5 minutes
-        this.cleanupTimer.unref(); // Don't block process exit
+            cleanupCompletedTasksImpl(this.tasks, this.taskTraceContexts, 3600000);
+        }, 300000);
+        this.cleanupTimer.unref();
         // Load persisted state
-        await this.loadState();
+        await loadState(this.memory, this.tasks, (task) => this.enqueueTaskInternal(task));
         // ADR-047: Initialize MinCut topology health monitoring
-        // Use shared graph singleton for proper MCP tools integration
         this.minCutBridge = createQueenMinCutBridge(this.eventBus, this.agentCoordinator, {
             autoUpdateFromEvents: true,
             persistData: true,
             includeInQueenHealth: true,
-            sharedGraph: getSharedMinCutGraph(), // Share graph with MCP tools
+            sharedGraph: getSharedMinCutGraph(),
         });
         await this.minCutBridge.initialize();
-        // ADR-047: Inject MinCut bridge into all domain plugins for topology awareness
-        // This enables domains to access topology health and participate in self-healing
+        // Inject MinCut bridge into domain plugins
         if (this.domainPlugins) {
-            for (const [domainName, plugin] of this.domainPlugins) {
-                // Check if plugin supports MinCut integration (has setMinCutBridge method)
-                if (isMinCutAwarePlugin(plugin)) {
-                    plugin.setMinCutBridge(this.minCutBridge);
-                    console.log(`[QueenCoordinator] MinCut bridge injected into ${domainName}`);
-                }
-            }
+            injectMinCutBridgeIntoPlugins(this.domainPlugins, this.minCutBridge);
         }
         // ADR-058: Initialize governance adapter
         try {
@@ -251,59 +170,10 @@ export class QueenCoordinator {
             console.log('[QueenCoordinator] Governance adapter initialized');
         }
         catch (govError) {
-            // Non-fatal: governance is optional but recommended
             console.warn('[QueenCoordinator] Governance initialization failed (continuing):', govError);
         }
-        // ADR-064: Initialize domain circuit breakers
-        if (this.config.enableCircuitBreakers !== false) {
-            try {
-                this.domainBreakerRegistry = createDomainBreakerRegistry();
-                console.log('[QueenCoordinator] Domain circuit breaker registry initialized');
-            }
-            catch (breakerError) {
-                console.warn('[QueenCoordinator] Circuit breaker initialization failed (continuing):', breakerError);
-            }
-        }
-        // ADR-064: Initialize agent teams and domain team manager
-        if (this.config.enableDomainTeams !== false) {
-            try {
-                this.agentTeamsAdapter = createAgentTeamsAdapter();
-                this.agentTeamsAdapter.initialize();
-                this.domainTeamManager = createDomainTeamManager(this.agentTeamsAdapter);
-                console.log('[QueenCoordinator] Domain team manager initialized');
-            }
-            catch (teamError) {
-                console.warn('[QueenCoordinator] Domain team manager initialization failed (continuing):', teamError);
-            }
-        }
-        // ADR-064: Initialize fleet tier selector
-        if (this.config.enableFleetTiers !== false) {
-            try {
-                this.tierSelector = createTierSelector();
-                console.log('[QueenCoordinator] Fleet tier selector initialized');
-            }
-            catch (tierError) {
-                console.warn('[QueenCoordinator] Tier selector initialization failed (continuing):', tierError);
-            }
-        }
-        // ADR-064 Phase 3: Initialize distributed tracing
-        try {
-            this.traceCollector = createTraceCollector();
-            console.log('[QueenCoordinator] Trace collector initialized');
-        }
-        catch (traceError) {
-            console.warn('[QueenCoordinator] Trace collector initialization failed (continuing):', traceError);
-        }
-        // ADR-064 Phase 4: Initialize advanced patterns
-        try {
-            this.hypothesisManager = createHypothesisManager();
-            this.federationMailbox = createFederationMailbox();
-            this.dynamicScaler = createDynamicScaler();
-            console.log('[QueenCoordinator] Phase 4 modules initialized (hypotheses, federation, scaling)');
-        }
-        catch (phase4Error) {
-            console.warn('[QueenCoordinator] Phase 4 initialization failed (continuing):', phase4Error);
-        }
+        // ADR-064: Initialize subsystems (non-fatal failures)
+        this.initializeSubsystems();
         // Publish initialization event
         await this.publishEvent('QueenInitialized', {
             timestamp: new Date(),
@@ -322,7 +192,6 @@ export class QueenCoordinator {
             clearInterval(this.metricsTimer);
             this.metricsTimer = null;
         }
-        // MEM-002 FIX: Clear the cleanup timer to prevent memory leaks
         if (this.cleanupTimer) {
             clearInterval(this.cleanupTimer);
             this.cleanupTimer = null;
@@ -332,7 +201,7 @@ export class QueenCoordinator {
             await this.minCutBridge.dispose();
             this.minCutBridge = null;
         }
-        // ADR-064: Dispose domain team manager and circuit breakers
+        // ADR-064: Dispose subsystems
         if (this.domainTeamManager) {
             this.domainTeamManager.dispose();
             this.domainTeamManager = null;
@@ -343,7 +212,6 @@ export class QueenCoordinator {
         }
         this.domainBreakerRegistry = null;
         this.tierSelector = null;
-        // ADR-064 Phase 3+4: Dispose tracing and advanced patterns
         if (this.traceCollector) {
             this.traceCollector.dispose();
             this.traceCollector = null;
@@ -360,26 +228,19 @@ export class QueenCoordinator {
             this.dynamicScaler.dispose();
             this.dynamicScaler = null;
         }
-        // Save state
-        await this.saveState();
+        await saveState(this.memory, this.tasks);
         // Cancel all pending tasks
         for (const [taskId, execution] of this.tasks) {
             if (execution.status === 'queued' || execution.status === 'running') {
                 await this.cancelTask(taskId);
             }
         }
-        // Publish shutdown event
-        await this.publishEvent('QueenShutdown', {
-            timestamp: new Date(),
-            metrics: this.getMetrics(),
-        });
-        // PAP-003 FIX: Unsubscribe from all events before disposing router
-        // This prevents memory leaks by removing all event handlers
+        await this.publishEvent('QueenShutdown', { timestamp: new Date(), metrics: this.getMetrics() });
+        // PAP-003: Unsubscribe from all events
         for (const subscriptionId of this.eventSubscriptionIds) {
             this.router.unsubscribe(subscriptionId);
         }
         this.eventSubscriptionIds = [];
-        // Dispose router
         await this.router.dispose();
         this.initialized = false;
     }
@@ -397,8 +258,7 @@ export class QueenCoordinator {
             createdAt: new Date(),
             timeout: taskInput.timeout || this.config.defaultTaskTimeout,
         };
-        // ADR-058: Governance check before task execution
-        // Check if task is allowed by governance gates (ContinueGate, TrustAccumulator, etc.)
+        // ADR-058: Governance check
         const governanceContext = {
             taskId: task.id,
             taskType: task.type,
@@ -410,86 +270,31 @@ export class QueenCoordinator {
         try {
             const governanceDecision = await queenGovernanceAdapter.beforeTaskExecution(governanceContext);
             if (!governanceDecision.allowed) {
-                // SEC-003: Log governance rejection
                 this.auditLogger.logFail(taskId, 'governance', governanceDecision.reason || 'Governance check failed');
                 await this.publishEvent('TaskRejected', {
-                    taskId,
-                    reason: governanceDecision.reason,
-                    escalate: governanceDecision.escalate,
+                    taskId, reason: governanceDecision.reason, escalate: governanceDecision.escalate,
                 });
                 return err(new Error(`Task blocked by governance: ${governanceDecision.reason}`));
             }
         }
         catch (govError) {
-            // Non-fatal: log but continue if governance check fails
             console.warn('[QueenCoordinator] Governance check error (continuing):', govError);
         }
-        // CC-002 FIX: Use atomic increment pattern to prevent TOCTOU race condition
-        // Atomically reserve a slot by incrementing counter BEFORE the check
+        // CC-002: Atomic increment before capacity check
         this.runningTaskCounter++;
         try {
-            // Check if we exceeded the limit (counter was already incremented)
             if (this.runningTaskCounter > this.config.maxConcurrentTasks) {
-                // Release the reserved slot
                 this.runningTaskCounter--;
-                // Queue the task instead of rejecting
-                this.enqueueTask(task);
-                const execution = {
-                    taskId,
-                    task,
-                    status: 'queued',
-                    assignedAgents: [],
-                    retryCount: 0,
-                };
-                this.tasks.set(taskId, execution);
-                this.tasksReceived++;
-                // SEC-003 Simplified: Log task submission and queuing
-                this.auditLogger.logSubmit(taskId, { type: task.type, priority: task.priority });
-                this.auditLogger.logQueue(taskId, this.getQueuePosition(task));
-                await this.publishEvent('TaskQueued', { taskId, task, position: this.getQueuePosition(task) });
-                return ok(taskId);
+                return this.queueTask(task);
             }
-            // SEC-003 Simplified: Log task submission
             this.auditLogger.logSubmit(taskId, { type: task.type, priority: task.priority });
-            // ADR-064: Use fleet tier selector to determine activation scope
-            let selectedTier;
-            if (this.tierSelector) {
-                try {
-                    const tierContext = {
-                        trigger: task.payload?.trigger ?? 'manual',
-                        changedFiles: task.payload?.changedFiles,
-                        affectedDomains: task.targetDomains,
-                        severity: task.priority === 'p0' ? 'critical' : task.priority === 'p1' ? 'high' : undefined,
-                        isHotfix: task.payload?.isHotfix,
-                    };
-                    const tierResult = this.tierSelector.selectTier(tierContext);
-                    selectedTier = tierResult.selectedTier;
-                    console.log(`[Queen] Fleet tier: ${selectedTier} (${tierResult.reason})`);
-                }
-                catch (tierError) {
-                    // Non-fatal: log but continue with default behavior
-                    console.warn('[QueenCoordinator] Tier selection error (continuing):', tierError);
-                }
-            }
-            // ADR-064 Phase 3: Start a trace for this task
-            if (this.traceCollector) {
-                try {
-                    const { context } = this.traceCollector.startTrace({
-                        operationName: task.type,
-                        agentId: task.requester || 'queen',
-                        domain: task.targetDomains[0] || 'test-generation',
-                        tags: { taskId, priority: task.priority, tier: selectedTier || 'unknown' },
-                    });
-                    this.taskTraceContexts.set(taskId, context);
-                }
-                catch (traceError) {
-                    console.warn('[QueenCoordinator] Trace start error (continuing):', traceError);
-                }
-            }
-            // Assign task to appropriate domain(s)
-            const assignResult = await this.assignTask(task);
+            // ADR-064: Fleet tier selection
+            this.selectFleetTier(task);
+            // ADR-064 Phase 3: Start trace
+            this.startTaskTrace(task, taskId);
+            // Assign task to domain
+            const assignResult = await assignTask(this.createTaskContext(), task);
             if (!assignResult.success) {
-                // Release the reserved slot on assignment failure
                 this.runningTaskCounter--;
                 return assignResult;
             }
@@ -498,37 +303,25 @@ export class QueenCoordinator {
             return ok(taskId);
         }
         catch (error) {
-            // Release the reserved slot on any exception
             this.runningTaskCounter--;
             throw error;
         }
     }
     async cancelTask(taskId) {
         const execution = this.tasks.get(taskId);
-        if (!execution) {
+        if (!execution)
             return err(new Error(`Task not found: ${taskId}`));
-        }
         if (execution.status === 'completed' || execution.status === 'failed') {
             return err(new Error(`Task already finished: ${taskId}`));
         }
-        // CC-002 FIX: Decrement the atomic counter when cancelling a running task
         if (execution.status === 'running' || execution.status === 'assigned') {
             this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
         }
-        // Update status
-        const updated = {
-            ...execution,
-            status: 'cancelled',
-            completedAt: new Date(),
-        };
-        this.tasks.set(taskId, updated);
-        // Remove from queues
-        this.removeFromQueues(execution.task);
-        // Stop assigned agents if any
+        this.tasks.set(taskId, { ...execution, status: 'cancelled', completedAt: new Date() });
+        removeFromQueues(this.taskQueue, this.domainQueues, execution.task);
         for (const agentId of execution.assignedAgents) {
             await this.agentCoordinator.stop(agentId);
         }
-        // SEC-003 Simplified: Log task cancellation
         this.auditLogger.logCancel(taskId);
         await this.publishEvent('TaskCancelled', { taskId });
         return ok(undefined);
@@ -537,28 +330,7 @@ export class QueenCoordinator {
         return this.tasks.get(taskId);
     }
     listTasks(filter) {
-        let tasks = Array.from(this.tasks.values());
-        if (filter) {
-            if (filter.status) {
-                tasks = tasks.filter(t => t.status === filter.status);
-            }
-            if (filter.domain) {
-                tasks = tasks.filter(t => t.assignedDomain === filter.domain);
-            }
-            if (filter.priority) {
-                tasks = tasks.filter(t => t.task.priority === filter.priority);
-            }
-            if (filter.type) {
-                tasks = tasks.filter(t => t.task.type === filter.type);
-            }
-            if (filter.fromDate) {
-                tasks = tasks.filter(t => t.task.createdAt >= filter.fromDate);
-            }
-            if (filter.toDate) {
-                tasks = tasks.filter(t => t.task.createdAt <= filter.toDate);
-            }
-        }
-        return tasks;
+        return listTasksImpl(this.tasks, filter);
     }
     // ============================================================================
     // Domain Coordination
@@ -566,40 +338,10 @@ export class QueenCoordinator {
     getDomainHealth(domain) {
         if (this.domainPlugins) {
             const plugin = this.domainPlugins.get(domain);
-            return plugin?.getHealth();
-        }
-        // Fallback: compute from agent coordinator
-        const agents = this.agentCoordinator.listAgents({ domain });
-        const activeAgents = agents.filter(a => a.status === 'running').length;
-        const idleAgents = agents.filter(a => a.status === 'idle').length;
-        const failedAgents = agents.filter(a => a.status === 'failed').length;
-        // Issue #205 fix: Determine status based on agent state
-        // 'idle' is normal for ephemeral agent model (agents spawn on-demand)
-        let status;
-        if (failedAgents > 0 && failedAgents >= agents.length / 2) {
-            status = 'unhealthy';
-        }
-        else if (failedAgents > 0) {
-            status = 'degraded';
-        }
-        else if (activeAgents > 0) {
-            status = 'healthy';
-        }
-        else {
-            // No agents or all idle - normal for ephemeral agent model
-            status = 'idle';
+            if (plugin)
+                return plugin.getHealth();
         }
-        return {
-            status,
-            agents: {
-                total: agents.length,
-                active: activeAgents,
-                idle: idleAgents,
-                failed: failedAgents,
-            },
-            lastActivity: this.domainLastActivity.get(domain),
-            errors: [],
-        };
+        return computeDomainHealthFromAgents(this.agentCoordinator, domain, this.domainLastActivity.get(domain));
     }
     getDomainLoad(domain) {
         const queue = this.domainQueues.get(domain) || [];
@@ -617,15 +359,14 @@ export class QueenCoordinator {
         });
     }
     getBusyDomains() {
-        const loadThreshold = this.config.workStealing.loadThreshold;
-        return ALL_DOMAINS.filter(domain => this.getDomainLoad(domain) > loadThreshold);
+        return ALL_DOMAINS.filter(domain => this.getDomainLoad(domain) > this.config.workStealing.loadThreshold);
     }
     // ============================================================================
-    // Work Stealing Algorithm
+    // Work Stealing
     // ============================================================================
     enableWorkStealing() {
         if (!this.workStealingTimer) {
-            this.startWorkStealing();
+            this.workStealingTimer = startWorkStealingTimer(this.config, () => this.triggerWorkStealing().then(() => { }));
         }
     }
     disableWorkStealing() {
@@ -635,41 +376,7 @@ export class QueenCoordinator {
         }
     }
     async triggerWorkStealing() {
-        let stolenCount = 0;
-        const idleDomains = this.getIdleDomains();
-        const busyDomains = this.getBusyDomains();
-        if (idleDomains.length === 0 || busyDomains.length === 0) {
-            return 0;
-        }
-        // Sort busy domains by load (highest first)
-        busyDomains.sort((a, b) => this.getDomainLoad(b) - this.getDomainLoad(a));
-        for (const busyDomain of busyDomains) {
-            if (idleDomains.length === 0)
-                break;
-            const queue = this.domainQueues.get(busyDomain) || [];
-            const stealCount = Math.min(queue.length, this.config.workStealing.stealBatchSize);
-            for (let i = 0; i < stealCount && idleDomains.length > 0; i++) {
-                // Find a task that can be handled by an idle domain
-                const task = queue.find(t => this.canDomainHandleTask(idleDomains[0], t));
-                if (task) {
-                    // Steal the task
-                    const stealerDomain = idleDomains.shift();
-                    this.removeFromQueues(task);
-                    // SEC-003 Simplified: Log work stealing for observability
-                    this.auditLogger.logSteal(task.id, busyDomain, stealerDomain);
-                    // Reassign to idle domain
-                    await this.assignTaskToDomain(task, stealerDomain);
-                    stolenCount++;
-                    this.tasksStolen++;
-                    await this.publishEvent('TaskStolen', {
-                        taskId: task.id,
-                        fromDomain: busyDomain,
-                        toDomain: stealerDomain,
-                    });
-                }
-            }
-        }
-        return stolenCount;
+        return triggerWorkStealingImpl(this.createWorkStealingContext());
     }
     // ============================================================================
     // Agent Management
@@ -685,19 +392,11 @@ export class QueenCoordinator {
             return err(new Error('Maximum concurrent agents reached (15)'));
         }
         const result = await this.agentCoordinator.spawn({
-            name: `${domain}-${type}-${Date.now()}`,
-            domain,
-            type,
-            capabilities,
+            name: `${domain}-${type}-${Date.now()}`, domain, type, capabilities,
         });
         if (result.success) {
             this.domainLastActivity.set(domain, new Date());
-            await this.publishEvent('AgentSpawned', {
-                agentId: result.value,
-                domain,
-                type,
-                capabilities,
-            });
+            await this.publishEvent('AgentSpawned', { agentId: result.value, domain, type, capabilities });
         }
         return result;
     }
@@ -709,65 +408,36 @@ export class QueenCoordinator {
         const issues = [];
         let unhealthyCount = 0;
         let degradedCount = 0;
-        // Issue #205 fix: Only check enabled domains, not ALL_DOMAINS
-        // This prevents alarming warnings for domains that aren't configured
-        const enabledDomains = this.getEnabledDomains();
+        const enabledDomains = getEnabledDomains(this.domainPlugins, ALL_DOMAINS);
         for (const domain of enabledDomains) {
             const health = this.getDomainHealth(domain);
             if (health) {
                 domainHealth.set(domain, health);
-                // Issue #205 fix: 'idle' status is normal - don't report as issue
                 if (health.status === 'unhealthy') {
                     unhealthyCount++;
-                    issues.push({
-                        domain,
-                        severity: 'high',
-                        message: `Domain ${domain} is unhealthy`,
-                        timestamp: new Date(),
-                    });
+                    issues.push({ domain, severity: 'high', message: `Domain ${domain} is unhealthy`, timestamp: new Date() });
                 }
                 else if (health.status === 'degraded') {
                     degradedCount++;
-                    issues.push({
-                        domain,
-                        severity: 'medium',
-                        message: `Domain ${domain} is degraded`,
-                        timestamp: new Date(),
-                    });
+                    issues.push({ domain, severity: 'medium', message: `Domain ${domain} is degraded`, timestamp: new Date() });
                 }
-                // Note: 'idle' and 'healthy' don't generate issues
             }
         }
         const agents = this.agentCoordinator.listAgents();
         const activeAgents = agents.filter(a => a.status === 'running').length;
-        const pendingTasks = this.getQueuedTaskCount();
-        const runningTasks = this.getRunningTaskCount();
-        // Issue #205 fix: Determine overall health
-        // An idle system (no agents, no tasks) should show 'healthy', not 'degraded'
         let status = 'healthy';
-        if (unhealthyCount > 0) {
+        if (unhealthyCount > 0)
             status = 'unhealthy';
-        }
-        else if (degradedCount > enabledDomains.length / 2) {
+        else if (degradedCount > enabledDomains.length / 2)
             status = 'degraded';
-        }
-        // Note: All domains being 'idle' means system is ready, not degraded
         const baseHealth = {
-            status,
-            domainHealth,
-            totalAgents: agents.length,
-            activeAgents,
-            pendingTasks,
-            runningTasks,
+            status, domainHealth,
+            totalAgents: agents.length, activeAgents,
+            pendingTasks: this.getQueuedTaskCount(), runningTasks: this.getRunningTaskCount(),
             workStealingActive: this.workStealingTimer !== null,
-            lastHealthCheck: new Date(),
-            issues,
+            lastHealthCheck: new Date(), issues,
         };
-        // ADR-047: Extend health with MinCut topology data
-        if (this.minCutBridge) {
-            return this.minCutBridge.extendQueenHealth(baseHealth);
-        }
-        return baseHealth;
+        return this.minCutBridge ? this.minCutBridge.extendQueenHealth(baseHealth) : baseHealth;
     }
     getMetrics() {
         const domainUtilization = new Map();
@@ -780,41 +450,20 @@ export class QueenCoordinator {
         const agents = this.agentCoordinator.listAgents();
         const activeAgents = agents.filter(a => a.status === 'running').length;
         const agentUtilization = agents.length > 0 ? activeAgents / agents.length : 0;
-        // MEM-001 FIX: Use CircularBuffer's average() method for O(n) calculation
-        // instead of array reduce which requires O(n) space for intermediate results
         const avgDuration = this.taskDurations.average();
         const baseMetrics = {
-            tasksReceived: this.tasksReceived,
-            tasksCompleted: this.tasksCompleted,
-            tasksFailed: this.tasksFailed,
-            tasksStolen: this.tasksStolen,
-            averageTaskDuration: avgDuration,
-            domainUtilization,
-            agentUtilization,
-            protocolsExecuted: this.protocolsExecuted,
-            workflowsExecuted: this.workflowsExecuted,
+            tasksReceived: this.tasksReceived, tasksCompleted: this.tasksCompleted,
+            tasksFailed: this.tasksFailed, tasksStolen: this.tasksStolen,
+            averageTaskDuration: avgDuration, domainUtilization, agentUtilization,
+            protocolsExecuted: this.protocolsExecuted, workflowsExecuted: this.workflowsExecuted,
             uptime: Date.now() - this.startTime.getTime(),
         };
-        // ADR-047: Extend metrics with MinCut topology data
-        if (this.minCutBridge) {
-            return this.minCutBridge.extendQueenMetrics(baseMetrics);
-        }
-        return baseMetrics;
-    }
-    /**
-     * Get MinCut bridge for direct topology access
-     * ADR-047: Allows QE agents to access topology health directly
-     */
-    getMinCutBridge() {
-        return this.minCutBridge;
+        return this.minCutBridge ? this.minCutBridge.extendQueenMetrics(baseMetrics) : baseMetrics;
     }
-    /**
-     * Inject MinCut bridge into a specific domain plugin
-     * ADR-047: Enables late-binding for domains registered after Queen initialization
-     *
-     * @param domainName - The domain to inject the bridge into
-     * @returns true if bridge was injected, false if domain not found or bridge unavailable
-     */
+    // ============================================================================
+    // Subsystem Accessors
+    // ============================================================================
+    getMinCutBridge() { return this.minCutBridge; }
     injectMinCutBridgeIntoDomain(domainName) {
         if (!this.minCutBridge) {
             console.warn(`[QueenCoordinator] Cannot inject MinCut bridge: bridge not initialized`);
@@ -837,799 +486,264 @@ export class QueenCoordinator {
         console.warn(`[QueenCoordinator] Domain ${domainName} does not support MinCut integration`);
         return false;
     }
-    /**
-     * Get TinyDancer router for direct routing access
-     * TD-004/TD-005/TD-006: Allows QE agents to query routing decisions directly
-     */
-    getTinyDancerRouter() {
-        return this.tinyDancerRouter;
-    }
-    /**
-     * Get domain circuit breaker registry
-     * ADR-064: Allows external components to query breaker state
-     */
-    getDomainBreakerRegistry() {
-        return this.domainBreakerRegistry;
-    }
-    /**
-     * Get domain team manager
-     * ADR-064: Allows external components to manage domain teams
-     */
-    getDomainTeamManager() {
-        return this.domainTeamManager;
-    }
-    /**
-     * Get fleet tier selector
-     * ADR-064: Allows external components to query/select fleet tiers
-     */
-    getTierSelector() {
-        return this.tierSelector;
-    }
-    /**
-     * Connect a QEReasoningBank for automatic pattern training.
-     * ADR-064 Phase 3: Creates the adapter and TaskCompletedHook pipeline.
-     *
-     * @param bank - The QEReasoningBank to train patterns into
-     */
+    getTinyDancerRouter() { return this.tinyDancerRouter; }
+    getDomainBreakerRegistry() { return this.domainBreakerRegistry; }
+    getDomainTeamManager() { return this.domainTeamManager; }
+    getTierSelector() { return this.tierSelector; }
+    getTraceCollector() { return this.traceCollector; }
+    getHypothesisManager() { return this.hypothesisManager; }
+    getFederationMailbox() { return this.federationMailbox; }
+    getDynamicScaler() { return this.dynamicScaler; }
     connectReasoningBank(bank) {
         const adapter = new ReasoningBankPatternStore(bank);
         this.taskCompletedHook = new TaskCompletedHook({}, adapter);
         console.log('[QueenCoordinator] ReasoningBank connected for pattern training');
     }
-    /**
-     * Get the distributed trace collector
-     * ADR-064 Phase 3: Allows external components to trace agent operations
-     */
-    getTraceCollector() {
-        return this.traceCollector;
-    }
-    /**
-     * Get the competing hypotheses manager
-     * ADR-064 Phase 4A: Multi-agent investigation coordination
-     */
-    getHypothesisManager() {
-        return this.hypothesisManager;
-    }
-    /**
-     * Get the cross-fleet federation mailbox
-     * ADR-064 Phase 4B: Multi-service communication
-     */
-    getFederationMailbox() {
-        return this.federationMailbox;
-    }
-    /**
-     * Get the dynamic agent scaler
-     * ADR-064 Phase 4C: Workload-based auto-scaling
-     */
-    getDynamicScaler() {
-        return this.dynamicScaler;
-    }
     // ============================================================================
     // Protocol & Workflow
     // ============================================================================
     async executeProtocol(protocolId, params) {
-        if (!this.protocolExecutor) {
+        if (!this.protocolExecutor)
             return err(new Error('Protocol executor not configured'));
-        }
         const result = await this.protocolExecutor.execute(protocolId, params);
         if (result.success) {
             this.protocolsExecuted++;
-            await this.publishEvent('ProtocolExecuted', {
-                protocolId,
-                executionId: result.value.executionId,
-            });
+            await this.publishEvent('ProtocolExecuted', { protocolId, executionId: result.value.executionId });
             return ok(result.value.executionId);
         }
         return result;
     }
     async executeWorkflow(workflowId, params) {
-        if (!this.workflowExecutor) {
+        if (!this.workflowExecutor)
             return err(new Error('Workflow executor not configured'));
-        }
         const result = await this.workflowExecutor.execute(workflowId, params);
         if (result.success) {
             this.workflowsExecuted++;
-            await this.publishEvent('WorkflowExecuted', {
-                workflowId,
-                executionId: result.value.executionId,
-            });
+            await this.publishEvent('WorkflowExecuted', { workflowId, executionId: result.value.executionId });
             return ok(result.value.executionId);
         }
         return result;
     }
     // ============================================================================
-    // Private Methods
+    // Public cleanup (also exposed for tests)
     // ============================================================================
-    /**
-     * Get list of enabled domains
-     * Issue #205 fix: Used to only check enabled domains in health reporting
-     */
-    getEnabledDomains() {
-        // If we have domain plugins loaded, use those as the source of truth
-        if (this.domainPlugins && this.domainPlugins.size > 0) {
-            return Array.from(this.domainPlugins.keys());
-        }
-        // Fallback to ALL_DOMAINS if no plugins loaded yet
-        return [...ALL_DOMAINS];
+    cleanupCompletedTasks(retentionMs = 3600000) {
+        return cleanupCompletedTasksImpl(this.tasks, this.taskTraceContexts, retentionMs);
     }
+    // ============================================================================
+    // Private Helpers
+    // ============================================================================
+    /** Kept as a method so tests that cast to `{ subscribeToEvents() }` still work. */
     subscribeToEvents() {
-        // PAP-003 FIX: Store subscription IDs for proper cleanup during dispose()
-        // Clear any existing subscriptions first to prevent duplicates
-        this.eventSubscriptionIds = [];
-        // Listen for task completion events from domains
-        for (const domain of ALL_DOMAINS) {
-            const subscriptionId = this.router.subscribeToDoamin(domain, async (event) => {
-                await this.handleDomainEvent(event);
-            });
-            this.eventSubscriptionIds.push(subscriptionId);
-        }
-        // Listen for specific coordination events
-        const taskCompletedSubId = this.router.subscribeToEventType('TaskCompleted', async (event) => {
-            await this.handleTaskCompleted(event);
-        });
-        this.eventSubscriptionIds.push(taskCompletedSubId);
-        const taskFailedSubId = this.router.subscribeToEventType('TaskFailed', async (event) => {
-            await this.handleTaskFailed(event);
-        });
-        this.eventSubscriptionIds.push(taskFailedSubId);
-        const agentStatusSubId = this.router.subscribeToEventType('AgentStatusChanged', async (event) => {
-            await this.handleAgentStatusChanged(event);
-        });
-        this.eventSubscriptionIds.push(agentStatusSubId);
+        this.eventSubscriptionIds = subscribeToEvents(this.createEventHandlerContext(), ALL_DOMAINS);
     }
-    async handleDomainEvent(event) {
-        // Update domain activity
-        this.domainLastActivity.set(event.source, new Date());
-        // Check if this frees up capacity for queued tasks
-        await this.processQueue();
+    enqueueTaskInternal(task) {
+        enqueueTask(this.taskQueue, this.domainQueues, task);
     }
-    async handleTaskCompleted(event) {
-        const { taskId, result } = event.payload;
-        const execution = this.tasks.get(taskId);
-        if (execution) {
-            // CC-002 FIX: Decrement the atomic counter when task completes
-            // Only decrement if task was running (not queued)
-            if (execution.status === 'running' || execution.status === 'assigned') {
-                this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
-            }
-            const duration = execution.startedAt
-                ? Date.now() - execution.startedAt.getTime()
-                : 0;
-            this.tasks.set(taskId, {
-                ...execution,
-                status: 'completed',
-                completedAt: new Date(),
-                result,
-            });
-            this.tasksCompleted++;
-            // MEM-001 FIX: CircularBuffer automatically handles fixed-size limit
-            // No need for manual shift() - O(1) push vs O(n) shift()
-            this.taskDurations.push(duration);
-            // SEC-003 Simplified: Log task completion
-            this.auditLogger.logComplete(taskId, execution.assignedAgents[0]);
-            // QCSD: Invoke cross-phase hooks on agent completion
-            // This enables feedback loops: Production→Ideation, CI/CD→Development, etc.
-            try {
-                const hookExecutor = getCrossPhaseHookExecutor();
-                const agentName = execution.assignedAgents[0];
-                if (agentName) {
-                    await hookExecutor.onAgentComplete(agentName, {
-                        taskId,
-                        taskType: execution.task.type,
-                        domain: execution.assignedDomain,
-                        result,
-                        duration,
-                    });
-                }
-            }
-            catch (hookError) {
-                // Non-fatal: log but don't fail the task completion
-                console.warn('[QueenCoordinator] Cross-phase hook error:', hookError);
-            }
-            // ADR-058: Record successful task outcome with governance
-            try {
-                await queenGovernanceAdapter.afterTaskExecution({
-                    taskId,
-                    taskType: execution.task.type,
-                    agentId: execution.assignedAgents[0] || 'unknown',
-                    domain: execution.assignedDomain || 'test-generation',
-                    priority: execution.task.priority,
-                }, true, // success
-                0, // cost (not tracked at this level)
-                0 // tokens (not tracked at this level)
-                );
-            }
-            catch (govError) {
-                console.warn('[QueenCoordinator] Governance tracking error:', govError);
-            }
-            // ADR-064: Record success in domain circuit breaker
-            if (this.domainBreakerRegistry && execution.assignedDomain) {
-                this.domainBreakerRegistry.getBreaker(execution.assignedDomain).recordSuccess();
-            }
-            // ADR-064 Phase 3: Complete the trace span for this task
-            if (this.traceCollector) {
-                const traceCtx = this.taskTraceContexts.get(taskId);
-                if (traceCtx) {
-                    this.traceCollector.completeSpan(traceCtx.spanId);
-                    this.taskTraceContexts.delete(taskId);
-                }
-            }
-            // ADR-064 Phase 3: Train patterns from completed tasks
-            if (this.taskCompletedHook) {
-                try {
-                    const resultObj = (typeof result === 'object' && result !== null)
-                        ? result
-                        : null;
-                    if (resultObj === null) {
-                        console.error(`[QueenCoordinator] Pattern training skipped for task ${taskId}: ` +
-                            `result is not an object (got ${typeof result})`);
-                    }
-                    else {
-                        const metrics = this.extractTaskMetrics(resultObj, taskId);
-                        if (metrics) {
-                            const taskResult = {
-                                taskId,
-                                agentId: execution.assignedAgents[0] || 'unknown',
-                                domain: execution.assignedDomain || 'test-generation',
-                                type: execution.task.type,
-                                status: 'completed',
-                                output: resultObj,
-                                metrics,
-                                duration,
-                                timestamp: Date.now(),
-                            };
-                            // Fire-and-forget: don't await to avoid blocking task completion
-                            this.taskCompletedHook.onTaskCompleted(taskResult).catch(hookErr => {
-                                console.warn('[QueenCoordinator] Pattern training error:', hookErr);
-                            });
-                        }
-                    }
-                }
-                catch (hookError) {
-                    console.warn('[QueenCoordinator] Pattern training setup error:', hookError);
-                }
-            }
-        }
-        // Process queue for next task
-        await this.processQueue();
+    async publishEvent(type, payload) {
+        await this.eventBus.publish({
+            id: uuidv4(),
+            type: `Queen${type}`,
+            timestamp: new Date(),
+            source: 'queen-coordinator',
+            payload,
+        });
+    }
+    queueTask(task) {
+        this.enqueueTaskInternal(task);
+        const execution = {
+            taskId: task.id, task, status: 'queued', assignedAgents: [], retryCount: 0,
+        };
+        this.tasks.set(task.id, execution);
+        this.tasksReceived++;
+        this.auditLogger.logSubmit(task.id, { type: task.type, priority: task.priority });
+        this.auditLogger.logQueue(task.id, getQueuePosition(this.taskQueue, task));
+        // Fire-and-forget event (queuing is sync from caller's perspective)
+        this.publishEvent('TaskQueued', { taskId: task.id, task, position: getQueuePosition(this.taskQueue, task) });
+        return ok(task.id);
     }
-    /**
-     * Extract TaskMetrics from a task result object.
-     * Returns null and logs an error if the result shape is unrecognized.
-     */
-    extractTaskMetrics(resultObj, taskId) {
-        // Check for metrics at the top level
-        if ('metrics' in resultObj && typeof resultObj.metrics === 'object' && resultObj.metrics !== null) {
-            const m = resultObj.metrics;
-            return {
-                testsPassed: typeof m.testsPassed === 'number' ? m.testsPassed : undefined,
-                testsFailed: typeof m.testsFailed === 'number' ? m.testsFailed : undefined,
-                coverageChange: typeof m.coverageChange === 'number' ? m.coverageChange : undefined,
-                securityIssues: typeof m.securityIssues === 'number' ? m.securityIssues : undefined,
-                performanceMs: typeof m.performanceMs === 'number' ? m.performanceMs : undefined,
-                linesChanged: typeof m.linesChanged === 'number' ? m.linesChanged : undefined,
+    selectFleetTier(task) {
+        if (!this.tierSelector)
+            return undefined;
+        try {
+            const tierContext = {
+                trigger: task.payload?.trigger ?? 'manual',
+                changedFiles: task.payload?.changedFiles,
+                affectedDomains: task.targetDomains,
+                severity: task.priority === 'p0' ? 'critical' : task.priority === 'p1' ? 'high' : undefined,
+                isHotfix: task.payload?.isHotfix,
             };
+            const tierResult = this.tierSelector.selectTier(tierContext);
+            console.log(`[Queen] Fleet tier: ${tierResult.selectedTier} (${tierResult.reason})`);
+            return tierResult.selectedTier;
         }
-        // Check for flat metric fields directly on the result
-        if ('testsPassed' in resultObj || 'testsFailed' in resultObj) {
-            return {
-                testsPassed: typeof resultObj.testsPassed === 'number' ? resultObj.testsPassed : undefined,
-                testsFailed: typeof resultObj.testsFailed === 'number' ? resultObj.testsFailed : undefined,
-                coverageChange: typeof resultObj.coverageChange === 'number' ? resultObj.coverageChange : undefined,
-                securityIssues: typeof resultObj.securityIssues === 'number' ? resultObj.securityIssues : undefined,
-                performanceMs: typeof resultObj.performanceMs === 'number' ? resultObj.performanceMs : undefined,
-                linesChanged: typeof resultObj.linesChanged === 'number' ? resultObj.linesChanged : undefined,
-            };
+        catch (tierError) {
+            console.warn('[QueenCoordinator] Tier selection error (continuing):', tierError);
+            return undefined;
         }
-        console.error(`[QueenCoordinator] Pattern training skipped for task ${taskId}: ` +
-            `result object has no recognizable metrics shape (keys: ${Object.keys(resultObj).join(', ')})`);
-        return null;
     }
-    async handleTaskFailed(event) {
-        const { taskId, error } = event.payload;
-        const execution = this.tasks.get(taskId);
-        if (execution) {
-            // CC-002 FIX: Decrement the atomic counter when task fails
-            // Only decrement if task was running (not already queued)
-            if (execution.status === 'running' || execution.status === 'assigned') {
-                this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
-            }
-            // ADR-064: Record failure in domain circuit breaker
-            if (this.domainBreakerRegistry && execution.assignedDomain) {
-                this.domainBreakerRegistry.getBreaker(execution.assignedDomain).recordFailure(new Error(error || 'Task failed'));
-            }
-            // ADR-064 Phase 3: Fail the trace span for this task
-            if (this.traceCollector) {
-                const traceCtx = this.taskTraceContexts.get(taskId);
-                if (traceCtx) {
-                    this.traceCollector.failSpan(traceCtx.spanId, error || 'Task failed');
-                    this.taskTraceContexts.delete(taskId);
-                }
-            }
-            // Check if we should retry
-            if (execution.retryCount < this.config.taskRetryLimit) {
-                // SEC-003 Simplified: Log failure for observability
-                this.auditLogger.logFail(taskId, execution.assignedAgents[0], error);
-                // Retry the task
-                const retried = {
-                    ...execution,
-                    status: 'queued',
-                    retryCount: execution.retryCount + 1,
-                    error,
-                };
-                this.tasks.set(taskId, retried);
-                this.enqueueTask(execution.task);
-                await this.publishEvent('TaskRetrying', {
-                    taskId,
-                    retryCount: retried.retryCount,
-                    error,
-                });
-            }
-            else {
-                // Mark as failed
-                this.tasks.set(taskId, {
-                    ...execution,
-                    status: 'failed',
-                    completedAt: new Date(),
-                    error,
-                });
-                this.tasksFailed++;
-                // SEC-003 Simplified: Log permanent failure
-                this.auditLogger.logFail(taskId, execution.assignedAgents[0], error);
-                // ADR-058: Record failed task outcome with governance
-                try {
-                    await queenGovernanceAdapter.afterTaskExecution({
-                        taskId,
-                        taskType: execution.task.type,
-                        agentId: execution.assignedAgents[0] || 'unknown',
-                        domain: execution.assignedDomain || 'test-generation',
-                        priority: execution.task.priority,
-                    }, false, // success = false
-                    0, // cost
-                    0 // tokens
-                    );
-                }
-                catch (govError) {
-                    console.warn('[QueenCoordinator] Governance tracking error:', govError);
-                }
-                // ADR-064 Phase 4A: Create competing hypotheses investigation for
-                // permanent failures in critical domains (p0/p1 priority)
-                if (this.hypothesisManager && (execution.task.priority === 'p0' || execution.task.priority === 'p1')) {
-                    try {
-                        const domain = execution.assignedDomain || 'test-generation';
-                        const investigation = this.hypothesisManager.createInvestigation(taskId, domain, `Root cause analysis for ${execution.task.type} failure: ${error}`);
-                        // Seed with two competing hypotheses
-                        this.hypothesisManager.addHypothesis(investigation.id, `Infrastructure failure in domain '${domain}' caused task ${taskId} to fail`, 'log-analysis', `${domain}-lead`);
-                        this.hypothesisManager.addHypothesis(investigation.id, `Logic/configuration error in task payload caused ${execution.task.type} to fail: ${error}`, 'code-analysis', execution.assignedAgents[0] || 'unknown');
-                        console.log(`[QueenCoordinator] Competing hypotheses investigation created: ${investigation.id}`);
-                    }
-                    catch (hypothesisError) {
-                        console.warn('[QueenCoordinator] Hypothesis creation error:', hypothesisError);
-                    }
-                }
+    startTaskTrace(task, taskId) {
+        if (!this.traceCollector)
+            return;
+        try {
+            const { context } = this.traceCollector.startTrace({
+                operationName: task.type,
+                agentId: task.requester || 'queen',
+                domain: task.targetDomains[0] || 'test-generation',
+                tags: { taskId, priority: task.priority },
+            });
+            const MAX_TRACE_CONTEXTS = 10000;
+            if (this.taskTraceContexts.size >= MAX_TRACE_CONTEXTS) {
+                const oldest = this.taskTraceContexts.keys().next().value;
+                if (oldest !== undefined)
+                    this.taskTraceContexts.delete(oldest);
             }
+            this.taskTraceContexts.set(taskId, context);
         }
-        await this.processQueue();
-    }
-    async handleAgentStatusChanged(event) {
-        const { agentId: _agentId, status, domain } = event.payload;
-        this.domainLastActivity.set(domain, new Date());
-        // If agent completed or failed, check for queued tasks
-        if (status === 'completed' || status === 'failed') {
-            await this.processQueue();
+        catch (traceError) {
+            console.warn('[QueenCoordinator] Trace start error (continuing):', traceError);
         }
     }
-    /**
-     * Handle task completion callback from domain plugin
-     * Queen-Domain Integration Fix: Direct task execution callback handler
-     */
-    async handleTaskCompletion(result) {
-        const execution = this.tasks.get(result.taskId);
-        if (!execution) {
-            console.warn(`[Queen] Received completion for unknown task: ${result.taskId}`);
-            return;
-        }
-        // Update task status
-        const updated = {
-            ...execution,
-            status: result.success ? 'completed' : 'failed',
-            completedAt: new Date(),
-            result: result.data,
-            error: result.error,
-        };
-        this.tasks.set(result.taskId, updated);
-        // Update counters
-        if (result.success) {
-            this.tasksCompleted++;
-            this.taskDurations.push(result.duration);
-            // SEC-003: Log task completion
-            this.auditLogger.logComplete(result.taskId, execution.assignedAgents[0]);
-        }
-        else {
-            this.tasksFailed++;
-            // SEC-003: Log task failure
-            this.auditLogger.logFail(result.taskId, execution.assignedAgents[0], result.error || 'Unknown error');
-        }
-        // CC-002: Decrement running task counter
-        this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
-        // Stop assigned agents
-        for (const agentId of execution.assignedAgents) {
-            await this.agentCoordinator.stop(agentId);
-        }
-        // Publish event
-        await this.publishEvent(result.success ? 'TaskCompleted' : 'TaskFailed', {
-            taskId: result.taskId,
-            domain: execution.assignedDomain,
-            result: result.data,
-            error: result.error,
-            duration: result.duration,
-        });
-        // Process queue for next task
-        await this.processQueue();
+    getRunningTaskCount() {
+        return Array.from(this.tasks.values()).filter(t => t.status === 'running' || t.status === 'assigned').length;
     }
-    async assignTask(task) {
-        const targetDomains = task.targetDomains.length > 0
-            ? task.targetDomains
-            : TASK_DOMAIN_MAP[task.type] || [];
-        if (targetDomains.length === 0) {
-            return err(new Error(`No domains configured for task type: ${task.type}`));
-        }
-        // Find the least loaded domain that can handle this task
-        let bestDomain;
-        let lowestLoad = Infinity;
-        for (const domain of targetDomains) {
-            const load = this.getDomainLoad(domain);
-            const health = this.getDomainHealth(domain);
-            if (health?.status !== 'unhealthy' && load < lowestLoad) {
-                lowestLoad = load;
-                bestDomain = domain;
-            }
-        }
-        if (!bestDomain) {
-            return err(new Error('No healthy domain available for task'));
-        }
-        return this.assignTaskToDomain(task, bestDomain);
+    getQueuedTaskCount() {
+        return Array.from(this.tasks.values()).filter(t => t.status === 'queued').length;
     }
-    async assignTaskToDomain(task, domain) {
-        // V3 Integration: Use TinyDancer for intelligent model routing (TD-004, TD-005, TD-006)
-        // Routes tasks to optimal agent tiers (haiku/sonnet/opus) based on complexity
-        let routeDecision;
-        if (this.tinyDancerRouter) {
-            // Convert Priority to QETask priority format
-            const priorityMap = {
-                p0: 'critical',
-                p1: 'high',
-                p2: 'normal',
-                p3: 'low',
-            };
-            const classifiableTask = {
-                description: `${task.type}: ${JSON.stringify(task.payload).slice(0, 200)}`,
-                type: task.type,
-                domain: domain,
-                priority: priorityMap[task.priority],
-            };
-            routeDecision = await this.tinyDancerRouter.route(classifiableTask);
-            // Log routing decision for observability
-            if (this.config.enableMetrics) {
-                console.log(`[Queen] TinyDancer routing: ${task.type} → tier=${routeDecision.tier}, model=${routeDecision.model}, cost=$${routeDecision.estimatedCost.toFixed(4)}`);
-            }
-        }
-        // ADR-064: Check domain circuit breaker before assigning task
-        if (this.domainBreakerRegistry) {
-            if (!this.domainBreakerRegistry.canExecuteInDomain(domain)) {
-                return err(new Error(`Domain '${domain}' circuit breaker is open — too many recent failures`));
-            }
-        }
-        // ADR-064: Ensure a domain team exists for this domain via DomainTeamManager
-        if (this.domainTeamManager) {
+    /** Initialize ADR-064 subsystems (all non-fatal). */
+    initializeSubsystems() {
+        if (this.config.enableCircuitBreakers !== false) {
             try {
-                const existingTeam = this.domainTeamManager.getDomainTeam(domain);
-                if (!existingTeam) {
-                    // Auto-create a team with a lead agent for this domain
-                    const leadId = `${domain}-lead`;
-                    this.domainTeamManager.createDomainTeam(domain, leadId);
-                }
+                this.domainBreakerRegistry = createDomainBreakerRegistry();
+                console.log('[QueenCoordinator] Domain circuit breaker registry initialized');
             }
-            catch (teamError) {
-                // Non-fatal: domain teams are optional enhancement
-                console.warn(`[Queen] Domain team setup for '${domain}' failed (continuing):`, teamError);
+            catch (e) {
+                console.warn('[QueenCoordinator] Circuit breaker initialization failed (continuing):', e);
             }
         }
-        // Spawn an agent for this task if needed, using TinyDancer-recommended tier
-        const agentType = routeDecision?.tier || 'task-worker';
-        const spawnResult = await this.requestAgentSpawn(domain, agentType, ['task-execution', task.type, ...(routeDecision ? [`model:${routeDecision.model}`] : [])]);
-        const agentIds = [];
-        if (spawnResult.success) {
-            agentIds.push(spawnResult.value);
-        }
-        const execution = {
-            taskId: task.id,
-            task,
-            status: 'running',
-            assignedDomain: domain,
-            assignedAgents: agentIds,
-            startedAt: new Date(),
-            retryCount: 0,
-        };
-        this.tasks.set(task.id, execution);
-        this.domainLastActivity.set(domain, new Date());
-        // SEC-003 Simplified: Log task assignment for observability
-        for (const agentId of agentIds) {
-            this.auditLogger.logAssign(task.id, agentId, domain);
-        }
-        await this.publishEvent('TaskAssigned', {
-            taskId: task.id,
-            domain,
-            agentIds,
-        });
-        // INTEGRATION FIX: Invoke domain plugin directly for task execution
-        if (this.domainPlugins) {
-            const plugin = this.domainPlugins.get(domain);
-            // Check if plugin supports direct task execution
-            if (plugin?.executeTask && plugin.canHandleTask?.(task.type)) {
-                // Build task request
-                const request = {
-                    taskId: task.id,
-                    taskType: task.type,
-                    payload: task.payload,
-                    priority: task.priority,
-                    timeout: task.timeout,
-                    correlationId: task.correlationId,
-                };
-                // Execute task with callback to handleTaskCompletion
-                const execResult = await plugin.executeTask(request, (result) => this.handleTaskCompletion(result));
-                if (!execResult.success) {
-                    // Domain rejected task - update status and decrement counter
-                    this.tasks.set(task.id, {
-                        ...execution,
-                        status: 'failed',
-                        error: execResult.error.message,
-                        completedAt: new Date(),
-                    });
-                    this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
-                    this.tasksFailed++;
-                    // SEC-003: Log rejection
-                    this.auditLogger.logFail(task.id, agentIds[0], execResult.error.message);
-                    return err(execResult.error);
-                }
-                // Task accepted and running - will complete via callback
-                return ok(task.id);
-            }
-            // Fallback: Send event to plugin (for domains not yet updated)
-            if (plugin) {
-                try {
-                    await plugin.handleEvent({
-                        id: uuidv4(),
-                        type: 'TaskAssigned',
-                        timestamp: new Date(),
-                        source: 'queen-coordinator',
-                        correlationId: task.correlationId,
-                        payload: { task },
-                    });
-                    console.warn(`[Queen] Domain ${domain} has no executeTask handler, using event fallback`);
-                }
-                catch (error) {
-                    // Log but don't fail - domain will handle via event bus
-                    console.warn(`[Queen] Failed to invoke domain ${domain} event handler:`, error);
-                }
+        if (this.config.enableDomainTeams !== false) {
+            try {
+                this.agentTeamsAdapter = createAgentTeamsAdapter();
+                this.agentTeamsAdapter.initialize();
+                this.domainTeamManager = createDomainTeamManager(this.agentTeamsAdapter);
+                console.log('[QueenCoordinator] Domain team manager initialized');
             }
-        }
-        return ok(task.id);
-    }
-    /**
-     * PERF-001 FIX: Use binary insertion O(log n) instead of sort O(n log n)
-     * Binary search finds the correct insertion point, then splice inserts at that position.
-     * This is much more efficient for maintaining sorted order with frequent insertions.
-     *
-     * Comparator for tasks: sorted by createdAt ascending (oldest first / FIFO within priority)
-     */
-    static taskComparator = createdAtComparator();
-    enqueueTask(task) {
-        const priorityQueue = this.taskQueue.get(task.priority);
-        if (priorityQueue) {
-            // PERF-001 FIX: O(log n) binary insertion instead of O(n log n) sort
-            // Binary search finds insertion point in O(log n), splice is O(n) but with better
-            // cache locality and lower constant factor than full sort
-            binaryInsert(priorityQueue, task, QueenCoordinator.taskComparator);
-        }
-        // Also add to domain-specific queues (unsorted - just for load tracking)
-        for (const domain of task.targetDomains) {
-            const domainQueue = this.domainQueues.get(domain);
-            if (domainQueue) {
-                domainQueue.push(task);
+            catch (e) {
+                console.warn('[QueenCoordinator] Domain team manager initialization failed (continuing):', e);
             }
         }
-    }
-    removeFromQueues(task) {
-        // Remove from priority queue
-        const priorityQueue = this.taskQueue.get(task.priority);
-        if (priorityQueue) {
-            const idx = priorityQueue.findIndex(t => t.id === task.id);
-            if (idx !== -1) {
-                priorityQueue.splice(idx, 1);
+        if (this.config.enableFleetTiers !== false) {
+            try {
+                this.tierSelector = createTierSelector();
+                console.log('[QueenCoordinator] Fleet tier selector initialized');
             }
-        }
-        // Remove from domain queues
-        for (const domain of ALL_DOMAINS) {
-            const domainQueue = this.domainQueues.get(domain);
-            if (domainQueue) {
-                const idx = domainQueue.findIndex(t => t.id === task.id);
-                if (idx !== -1) {
-                    domainQueue.splice(idx, 1);
-                }
+            catch (e) {
+                console.warn('[QueenCoordinator] Tier selector initialization failed (continuing):', e);
             }
         }
-    }
-    async processQueue() {
-        // CC-002 FIX: Use atomic counter for capacity check
-        if (this.runningTaskCounter >= this.config.maxConcurrentTasks) {
-            return;
-        }
-        // Process by priority (p0 first)
-        for (const priority of ['p0', 'p1', 'p2', 'p3']) {
-            const queue = this.taskQueue.get(priority);
-            if (!queue || queue.length === 0)
-                continue;
-            const task = queue.shift();
-            if (task) {
-                this.removeFromQueues(task);
-                // CC-002 FIX: Increment counter before assigning queued task
-                this.runningTaskCounter++;
-                try {
-                    await this.assignTask(task);
-                }
-                catch (error) {
-                    // Decrement if assignment fails
-                    this.runningTaskCounter--;
-                    throw error;
-                }
-                // Check if we can process more using the atomic counter
-                if (this.runningTaskCounter >= this.config.maxConcurrentTasks) {
-                    return;
-                }
-            }
+        try {
+            this.traceCollector = createTraceCollector();
+            console.log('[QueenCoordinator] Trace collector initialized');
         }
-    }
-    getQueuePosition(task) {
-        let position = 0;
-        // Count tasks ahead in higher priority queues
-        for (const p of ['p0', 'p1', 'p2', 'p3']) {
-            const queue = this.taskQueue.get(p);
-            if (queue) {
-                if (p === task.priority) {
-                    position += queue.findIndex(t => t.id === task.id);
-                    break;
-                }
-                position += queue.length;
-            }
+        catch (e) {
+            console.warn('[QueenCoordinator] Trace collector initialization failed (continuing):', e);
         }
-        return position;
-    }
-    getRunningTaskCount() {
-        return Array.from(this.tasks.values())
-            .filter(t => t.status === 'running' || t.status === 'assigned')
-            .length;
-    }
-    getQueuedTaskCount() {
-        return Array.from(this.tasks.values())
-            .filter(t => t.status === 'queued')
-            .length;
-    }
-    canDomainHandleTask(domain, task) {
-        const compatibleDomains = TASK_DOMAIN_MAP[task.type] || [];
-        return compatibleDomains.includes(domain);
-    }
-    startWorkStealing() {
-        this.workStealingTimer = setInterval(async () => {
-            await this.triggerWorkStealing();
-        }, this.config.workStealing.checkInterval);
-    }
-    startMetricsCollection() {
-        this.metricsTimer = setInterval(async () => {
-            const metrics = this.getMetrics();
-            await this.publishEvent('MetricsCollected', { metrics });
-            // Store metrics in memory for historical analysis
-            await this.memory.set(`queen:metrics:${Date.now()}`, metrics, {
-                ttl: 86400000, // 24 hours
-                namespace: 'queen-coordinator',
-            });
-            // ADR-064 Phase 4C: Feed workload metrics to dynamic scaler
-            if (this.dynamicScaler) {
-                try {
-                    const agents = this.agentCoordinator.listAgents();
-                    const activeAgents = agents.filter(a => a.status === 'running').length;
-                    const idleAgents = agents.filter(a => a.status === 'idle').length;
-                    const avgDuration = this.taskDurations.average();
-                    const workloadMetrics = {
-                        queueDepth: this.getQueuedTaskCount(),
-                        activeAgents,
-                        idleAgents,
-                        avgTaskDurationMs: avgDuration,
-                        errorRate: this.tasksReceived > 0
-                            ? this.tasksFailed / this.tasksReceived
-                            : 0,
-                        throughput: metrics.uptime > 0
-                            ? (this.tasksCompleted / (metrics.uptime / 1000)) // tasks/sec
-                            : 0,
-                        timestamp: Date.now(),
-                    };
-                    this.dynamicScaler.recordMetrics(workloadMetrics);
-                    const decision = this.dynamicScaler.evaluate();
-                    if (decision && decision.action !== 'maintain') {
-                        console.log(`[QueenCoordinator] Dynamic scaler: ${decision.action} to ${decision.targetAgents} agents — ${decision.reason}`);
-                        this.dynamicScaler.execute(decision).catch(scaleErr => {
-                            console.warn('[QueenCoordinator] Dynamic scaling execution error:', scaleErr);
-                        });
-                    }
-                }
-                catch (scaleError) {
-                    console.warn('[QueenCoordinator] Dynamic scaler metrics error:', scaleError);
-                }
-            }
-        }, this.config.metricsInterval);
-    }
-    async loadState() {
         try {
-            const state = await this.memory.get('queen:state');
-            if (state) {
-                for (const [id, execution] of state.tasks) {
-                    // Only restore queued tasks
-                    if (execution.status === 'queued') {
-                        this.tasks.set(id, execution);
-                        this.enqueueTask(execution.task);
-                    }
-                }
-            }
+            this.hypothesisManager = createHypothesisManager();
+            this.federationMailbox = createFederationMailbox();
+            this.dynamicScaler = createDynamicScaler();
+            console.log('[QueenCoordinator] Phase 4 modules initialized (hypotheses, federation, scaling)');
         }
-        catch (error) {
-            // Non-critical: state loading errors - coordinator will start fresh
-            console.debug('[QueenCoordinator] State loading failed:', error instanceof Error ? error.message : error);
+        catch (e) {
+            console.warn('[QueenCoordinator] Phase 4 initialization failed (continuing):', e);
         }
     }
-    async saveState() {
-        const queuedTasks = Array.from(this.tasks.entries())
-            .filter(([, t]) => t.status === 'queued');
-        await this.memory.set('queen:state', { tasks: queuedTasks }, { namespace: 'queen-coordinator', persist: true });
+    // ============================================================================
+    // Context Factories (bridge between class state and extracted modules)
+    // Uses arrow-captured `self` to correctly proxy mutable counters.
+    // ============================================================================
+    createEventHandlerContext() {
+        const self = this;
+        return {
+            config: self.config, tasks: self.tasks,
+            domainLastActivity: self.domainLastActivity,
+            auditLogger: self.auditLogger, router: self.router,
+            agentCoordinator: self.agentCoordinator,
+            get runningTaskCounter() { return self.runningTaskCounter; },
+            set runningTaskCounter(v) { self.runningTaskCounter = v; },
+            get tasksCompleted() { return self.tasksCompleted; },
+            set tasksCompleted(v) { self.tasksCompleted = v; },
+            get tasksFailed() { return self.tasksFailed; },
+            set tasksFailed(v) { self.tasksFailed = v; },
+            taskDurations: self.taskDurations,
+            get domainBreakerRegistry() { return self.domainBreakerRegistry; },
+            get traceCollector() { return self.traceCollector; },
+            taskTraceContexts: self.taskTraceContexts,
+            get taskCompletedHook() { return self.taskCompletedHook; },
+            get hypothesisManager() { return self.hypothesisManager; },
+            processQueue: () => processQueue(self.createTaskContext()),
+            enqueueTask: (task) => self.enqueueTaskInternal(task),
+        };
     }
-    async publishEvent(type, payload) {
-        await this.eventBus.publish({
-            id: uuidv4(),
-            type: `Queen${type}`,
-            timestamp: new Date(),
-            source: 'queen-coordinator',
-            payload,
-        });
+    createTaskContext() {
+        const self = this;
+        return {
+            config: self.config, tasks: self.tasks,
+            taskQueue: self.taskQueue, domainQueues: self.domainQueues,
+            domainLastActivity: self.domainLastActivity,
+            auditLogger: self.auditLogger, agentCoordinator: self.agentCoordinator,
+            domainPlugins: self.domainPlugins,
+            get runningTaskCounter() { return self.runningTaskCounter; },
+            set runningTaskCounter(v) { self.runningTaskCounter = v; },
+            get tasksReceived() { return self.tasksReceived; },
+            set tasksReceived(v) { self.tasksReceived = v; },
+            get tasksCompleted() { return self.tasksCompleted; },
+            set tasksCompleted(v) { self.tasksCompleted = v; },
+            get tasksFailed() { return self.tasksFailed; },
+            set tasksFailed(v) { self.tasksFailed = v; },
+            taskDurations: self.taskDurations,
+            get tinyDancerRouter() { return self.tinyDancerRouter; },
+            get domainBreakerRegistry() { return self.domainBreakerRegistry; },
+            get domainTeamManager() { return self.domainTeamManager; },
+            get tierSelector() { return self.tierSelector; },
+            get traceCollector() { return self.traceCollector; },
+            taskTraceContexts: self.taskTraceContexts,
+            requestAgentSpawn: (d, t, c) => self.requestAgentSpawn(d, t, c),
+            publishEvent: (t, p) => self.publishEvent(t, p),
+            getDomainLoad: (d) => self.getDomainLoad(d),
+            getDomainHealth: (d) => self.getDomainHealth(d),
+        };
     }
-    /**
-     * MEM-002 FIX: Clean up completed/failed/cancelled tasks older than retention period
-     * Prevents memory leak from tasks Map accumulating indefinitely.
-     * Should be called periodically via cleanupTimer or manually for immediate cleanup.
-     *
-     * @param retentionMs - How long to retain completed tasks (default: 1 hour)
-     * @returns Number of tasks cleaned up
-     */
-    cleanupCompletedTasks(retentionMs = 3600000) {
-        const now = Date.now();
-        let cleaned = 0;
-        for (const [taskId, execution] of this.tasks) {
-            // Only clean up terminal states
-            if (execution.status === 'completed' ||
-                execution.status === 'failed' ||
-                execution.status === 'cancelled') {
-                // Use completedAt if available, otherwise startedAt, otherwise skip
-                const completedTime = execution.completedAt?.getTime() ||
-                    execution.startedAt?.getTime() ||
-                    0;
-                if (completedTime > 0 && now - completedTime > retentionMs) {
-                    this.tasks.delete(taskId);
-                    cleaned++;
-                }
-            }
-        }
-        if (cleaned > 0) {
-            console.log(`[QueenCoordinator] Cleaned up ${cleaned} old tasks (retention: ${retentionMs}ms)`);
-        }
-        return cleaned;
+    createWorkStealingContext() {
+        const self = this;
+        return {
+            config: self.config, domainQueues: self.domainQueues,
+            auditLogger: self.auditLogger,
+            get tasksStolen() { return self.tasksStolen; },
+            set tasksStolen(v) { self.tasksStolen = v; },
+            getIdleDomains: () => self.getIdleDomains(),
+            getBusyDomains: () => self.getBusyDomains(),
+            getDomainLoad: (d) => self.getDomainLoad(d),
+            removeFromQueues: (t) => removeFromQueues(self.taskQueue, self.domainQueues, t),
+            assignTaskToDomain: (t, d) => assignTaskToDomain(self.createTaskContext(), t, d).then(() => { }),
+            publishEvent: (t, p) => self.publishEvent(t, p),
+        };
+    }
+    createMetricsContext() {
+        const self = this;
+        return {
+            config: self.config, memory: self.memory,
+            get dynamicScaler() { return self.dynamicScaler; },
+            getMetrics: () => self.getMetrics(),
+            publishEvent: (t, p) => self.publishEvent(t, p),
+            getQueuedTaskCount: () => self.getQueuedTaskCount(),
+            getActiveAgentCount: () => self.agentCoordinator.listAgents().filter(a => a.status === 'running').length,
+            getIdleAgentCount: () => self.agentCoordinator.listAgents().filter(a => a.status === 'idle').length,
+            getAverageTaskDuration: () => self.taskDurations.average(),
+            getTasksReceived: () => self.tasksReceived,
+            getTasksFailed: () => self.tasksFailed,
+            getTasksCompleted: () => self.tasksCompleted,
+        };
     }
 }
 // ============================================================================
@@ -1637,13 +751,6 @@ export class QueenCoordinator {
 // ============================================================================
 /**
  * Create a Queen Coordinator from a QE Kernel
- *
- * @param kernel - The QE Kernel instance
- * @param router - Cross-domain event router
- * @param protocolExecutor - Optional protocol executor for cross-domain protocols
- * @param workflowExecutor - Optional workflow executor
- * @param domainPlugins - Map of domain plugins for direct task execution (Integration Fix)
- * @param config - Optional configuration overrides
  */
 export function createQueenCoordinator(kernel, router, protocolExecutor, workflowExecutor, domainPlugins, config) {
     return new QueenCoordinator(kernel.eventBus, kernel.coordinator, kernel.memory, router, protocolExecutor, workflowExecutor, domainPlugins, config);