@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/coordination/queen-coordinator.ts

@@ -1,1176 +0,0 @@
-/**
- * Agentic QE v3 - Queen Coordinator
- * The sovereign orchestrator of the hierarchical hive operations.
- * Manages 12 domain coordinators, work stealing, and cross-domain workflows.
- *
- * Per Master Plan Section 4.1:
- * - Agent #1 in the hierarchy
- * - Coordinates 47 agents across 12 domains
- * - Implements work stealing for load balancing
- * - Orchestrates cross-domain protocols
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import {
-  DomainName,
-  DomainEvent,
-  ALL_DOMAINS,
-  Result,
-  ok,
-  err,
-  Priority,
-  AgentStatus,
-  Severity,
-} from '../shared/types';
-import {
-  EventBus,
-  AgentCoordinator,
-  AgentInfo,
-  DomainPlugin,
-  DomainHealth,
-  MemoryBackend,
-  QEKernel,
-} from '../kernel/interfaces';
-import { CrossDomainRouter, ProtocolExecutor, WorkflowExecutor } from './interfaces';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-/**
- * Task that can be assigned to domains
- */
-export interface QueenTask {
-  readonly id: string;
-  readonly type: TaskType;
-  readonly priority: Priority;
-  readonly targetDomains: DomainName[];
-  readonly payload: Record<string, unknown>;
-  readonly timeout: number;
-  readonly createdAt: Date;
-  readonly requester?: string;
-  readonly correlationId?: string;
-}
-
-export type TaskType =
-  | 'generate-tests'
-  | 'execute-tests'
-  | 'analyze-coverage'
-  | 'assess-quality'
-  | 'predict-defects'
-  | 'validate-requirements'
-  | 'index-code'
-  | 'scan-security'
-  | 'validate-contracts'
-  | 'test-accessibility'
-  | 'run-chaos'
-  | 'optimize-learning'
-  | 'cross-domain-workflow'
-  | 'protocol-execution';
-
-/**
- * Task execution status
- */
-export interface TaskExecution {
-  readonly taskId: string;
-  readonly task: QueenTask;
-  readonly status: 'queued' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled';
-  readonly assignedDomain?: DomainName;
-  readonly assignedAgents: string[];
-  readonly startedAt?: Date;
-  readonly completedAt?: Date;
-  readonly result?: unknown;
-  readonly error?: string;
-  readonly retryCount: number;
-}
-
-/**
- * Domain group for coordination
- */
-export interface DomainGroup {
-  readonly name: string;
-  readonly domains: DomainName[];
-  readonly priority: Priority;
-  readonly description: string;
-}
-
-/**
- * Work stealing configuration
- */
-export interface WorkStealingConfig {
-  enabled: boolean;
-  idleThreshold: number; // Time in ms before domain is considered idle
-  loadThreshold: number; // Max pending tasks before stealing is triggered
-  stealBatchSize: number; // Number of tasks to steal at once
-  checkInterval: number; // How often to check for work stealing opportunities
-}
-
-/**
- * Queen Coordinator metrics
- */
-export interface QueenMetrics {
-  readonly tasksReceived: number;
-  readonly tasksCompleted: number;
-  readonly tasksFailed: number;
-  readonly tasksStolen: number;
-  readonly averageTaskDuration: number;
-  readonly domainUtilization: Map<DomainName, number>;
-  readonly agentUtilization: number;
-  readonly protocolsExecuted: number;
-  readonly workflowsExecuted: number;
-  readonly uptime: number;
-}
-
-/**
- * Queen Coordinator configuration
- */
-export interface QueenConfig {
-  maxConcurrentTasks: number;
-  defaultTaskTimeout: number;
-  taskRetryLimit: number;
-  workStealing: WorkStealingConfig;
-  enableMetrics: boolean;
-  metricsInterval: number;
-  priorityWeights: Record<Priority, number>;
-}
-
-/**
- * Queen health status
- */
-export interface QueenHealth {
-  status: 'healthy' | 'degraded' | 'unhealthy';
-  domainHealth: Map<DomainName, DomainHealth>;
-  totalAgents: number;
-  activeAgents: number;
-  pendingTasks: number;
-  runningTasks: number;
-  workStealingActive: boolean;
-  lastHealthCheck: Date;
-  issues: HealthIssue[];
-}
-
-export interface HealthIssue {
-  domain?: DomainName;
-  severity: Severity;
-  message: string;
-  timestamp: Date;
-}
-
-/**
- * Queen Coordinator interface
- */
-export interface IQueenCoordinator {
-  // Lifecycle
-  initialize(): Promise<void>;
-  dispose(): Promise<void>;
-
-  // Task Management
-  submitTask(task: Omit<QueenTask, 'id' | 'createdAt'>): Promise<Result<string, Error>>;
-  cancelTask(taskId: string): Promise<Result<void, Error>>;
-  getTaskStatus(taskId: string): TaskExecution | undefined;
-  listTasks(filter?: TaskFilter): TaskExecution[];
-
-  // Domain Coordination
-  getDomainHealth(domain: DomainName): DomainHealth | undefined;
-  getDomainLoad(domain: DomainName): number;
-  getIdleDomains(): DomainName[];
-  getBusyDomains(): DomainName[];
-
-  // Work Stealing
-  enableWorkStealing(): void;
-  disableWorkStealing(): void;
-  triggerWorkStealing(): Promise<number>;
-
-  // Agent Management
-  listAllAgents(): AgentInfo[];
-  getAgentsByDomain(domain: DomainName): AgentInfo[];
-  requestAgentSpawn(domain: DomainName, type: string, capabilities: string[]): Promise<Result<string, Error>>;
-
-  // Health & Metrics
-  getHealth(): QueenHealth;
-  getMetrics(): QueenMetrics;
-
-  // Protocol & Workflow
-  executeProtocol(protocolId: string, params?: Record<string, unknown>): Promise<Result<string, Error>>;
-  executeWorkflow(workflowId: string, params?: Record<string, unknown>): Promise<Result<string, Error>>;
-}
-
-export interface TaskFilter {
-  status?: TaskExecution['status'];
-  domain?: DomainName;
-  priority?: Priority;
-  type?: TaskType;
-  fromDate?: Date;
-  toDate?: Date;
-}
-
-// ============================================================================
-// Domain Groups (per Master Plan Section 4.1)
-// ============================================================================
-
-export const DOMAIN_GROUPS: DomainGroup[] = [
-  {
-    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: Record<TaskType, DomainName[]> = {
-  '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 as unknown as DomainName[],
-  'protocol-execution': ALL_DOMAINS as unknown as DomainName[],
-};
-
-// ============================================================================
-// Default Configuration
-// ============================================================================
-
-const DEFAULT_CONFIG: QueenConfig = {
-  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,
-  },
-};
-
-// ============================================================================
-// Queen Coordinator Implementation
-// ============================================================================
-
-export class QueenCoordinator implements IQueenCoordinator {
-  private readonly config: QueenConfig;
-  private readonly tasks: Map<string, TaskExecution> = new Map();
-  private readonly taskQueue: Map<Priority, QueenTask[]> = new Map();
-  private readonly domainQueues: Map<DomainName, QueenTask[]> = new Map();
-  private readonly domainLastActivity: Map<DomainName, Date> = new Map();
-
-  private initialized = false;
-  private workStealingTimer: NodeJS.Timeout | null = null;
-  private metricsTimer: NodeJS.Timeout | null = null;
-  private startTime: Date = new Date();
-
-  // Metrics counters
-  private tasksReceived = 0;
-  private tasksCompleted = 0;
-  private tasksFailed = 0;
-  private tasksStolen = 0;
-  private taskDurations: number[] = [];
-  private protocolsExecuted = 0;
-  private workflowsExecuted = 0;
-
-  constructor(
-    private readonly eventBus: EventBus,
-    private readonly agentCoordinator: AgentCoordinator,
-    private readonly memory: MemoryBackend,
-    private readonly router: CrossDomainRouter,
-    private readonly protocolExecutor?: ProtocolExecutor,
-    private readonly workflowExecutor?: WorkflowExecutor,
-    private readonly domainPlugins?: Map<DomainName, DomainPlugin>,
-    config: Partial<QueenConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-
-    // Initialize priority queues
-    (['p0', 'p1', 'p2', 'p3'] as Priority[]).forEach(p => {
-      this.taskQueue.set(p, []);
-    });
-
-    // Initialize domain queues
-    ALL_DOMAINS.forEach(domain => {
-      this.domainQueues.set(domain, []);
-      this.domainLastActivity.set(domain, new Date());
-    });
-  }
-
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
-
-    this.startTime = new Date();
-
-    // Initialize cross-domain router
-    await this.router.initialize();
-
-    // Subscribe to domain events for coordination
-    this.subscribeToEvents();
-
-    // Start work stealing if enabled
-    if (this.config.workStealing.enabled) {
-      this.startWorkStealing();
-    }
-
-    // Start metrics collection if enabled
-    if (this.config.enableMetrics) {
-      this.startMetricsCollection();
-    }
-
-    // Load persisted state
-    await this.loadState();
-
-    // Publish initialization event
-    await this.publishEvent('QueenInitialized', {
-      timestamp: new Date(),
-      config: this.config,
-      domains: ALL_DOMAINS,
-    });
-
-    this.initialized = true;
-  }
-
-  async dispose(): Promise<void> {
-    // Stop timers
-    if (this.workStealingTimer) {
-      clearInterval(this.workStealingTimer);
-      this.workStealingTimer = null;
-    }
-    if (this.metricsTimer) {
-      clearInterval(this.metricsTimer);
-      this.metricsTimer = null;
-    }
-
-    // Save state
-    await this.saveState();
-
-    // 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(),
-    });
-
-    // Dispose router
-    await this.router.dispose();
-
-    this.initialized = false;
-  }
-
-  // ============================================================================
-  // Task Management
-  // ============================================================================
-
-  async submitTask(taskInput: Omit<QueenTask, 'id' | 'createdAt'>): Promise<Result<string, Error>> {
-    if (!this.initialized) {
-      return err(new Error('Queen Coordinator not initialized'));
-    }
-
-    const taskId = `task_${uuidv4()}`;
-    const task: QueenTask = {
-      ...taskInput,
-      id: taskId,
-      createdAt: new Date(),
-      timeout: taskInput.timeout || this.config.defaultTaskTimeout,
-    };
-
-    // Check concurrent task limit
-    const runningCount = this.getRunningTaskCount();
-    if (runningCount >= this.config.maxConcurrentTasks) {
-      // Queue the task instead of rejecting
-      this.enqueueTask(task);
-      const execution: TaskExecution = {
-        taskId,
-        task,
-        status: 'queued',
-        assignedAgents: [],
-        retryCount: 0,
-      };
-      this.tasks.set(taskId, execution);
-      this.tasksReceived++;
-
-      await this.publishEvent('TaskQueued', { taskId, task, position: this.getQueuePosition(task) });
-      return ok(taskId);
-    }
-
-    // Assign task to appropriate domain(s)
-    const assignResult = await this.assignTask(task);
-    if (!assignResult.success) {
-      return assignResult;
-    }
-
-    this.tasksReceived++;
-    await this.publishEvent('TaskSubmitted', { taskId, task });
-
-    return ok(taskId);
-  }
-
-  async cancelTask(taskId: string): Promise<Result<void, Error>> {
-    const execution = this.tasks.get(taskId);
-    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}`));
-    }
-
-    // Update status
-    const updated: TaskExecution = {
-      ...execution,
-      status: 'cancelled',
-      completedAt: new Date(),
-    };
-    this.tasks.set(taskId, updated);
-
-    // Remove from queues
-    this.removeFromQueues(execution.task);
-
-    // Stop assigned agents if any
-    for (const agentId of execution.assignedAgents) {
-      await this.agentCoordinator.stop(agentId);
-    }
-
-    await this.publishEvent('TaskCancelled', { taskId });
-
-    return ok(undefined);
-  }
-
-  getTaskStatus(taskId: string): TaskExecution | undefined {
-    return this.tasks.get(taskId);
-  }
-
-  listTasks(filter?: TaskFilter): TaskExecution[] {
-    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;
-  }
-
-  // ============================================================================
-  // Domain Coordination
-  // ============================================================================
-
-  getDomainHealth(domain: DomainName): DomainHealth | undefined {
-    if (this.domainPlugins) {
-      const plugin = this.domainPlugins.get(domain);
-      return plugin?.getHealth();
-    }
-
-    // Fallback: compute from agent coordinator
-    const agents = this.agentCoordinator.listAgents({ domain });
-    return {
-      status: agents.length > 0 ? 'healthy' : 'degraded',
-      agents: {
-        total: agents.length,
-        active: agents.filter(a => a.status === 'running').length,
-        idle: agents.filter(a => a.status === 'idle').length,
-        failed: agents.filter(a => a.status === 'failed').length,
-      },
-      lastActivity: this.domainLastActivity.get(domain),
-      errors: [],
-    };
-  }
-
-  getDomainLoad(domain: DomainName): number {
-    const queue = this.domainQueues.get(domain) || [];
-    const runningTasks = Array.from(this.tasks.values())
-      .filter(t => t.assignedDomain === domain && t.status === 'running');
-    return queue.length + runningTasks.length;
-  }
-
-  getIdleDomains(): DomainName[] {
-    const now = Date.now();
-    const idleThreshold = this.config.workStealing.idleThreshold;
-
-    return ALL_DOMAINS.filter(domain => {
-      const lastActivity = this.domainLastActivity.get(domain);
-      const load = this.getDomainLoad(domain);
-      return load === 0 && lastActivity && (now - lastActivity.getTime()) > idleThreshold;
-    });
-  }
-
-  getBusyDomains(): DomainName[] {
-    const loadThreshold = this.config.workStealing.loadThreshold;
-    return ALL_DOMAINS.filter(domain => this.getDomainLoad(domain) > loadThreshold);
-  }
-
-  // ============================================================================
-  // Work Stealing Algorithm
-  // ============================================================================
-
-  enableWorkStealing(): void {
-    if (!this.workStealingTimer) {
-      this.startWorkStealing();
-    }
-  }
-
-  disableWorkStealing(): void {
-    if (this.workStealingTimer) {
-      clearInterval(this.workStealingTimer);
-      this.workStealingTimer = null;
-    }
-  }
-
-  async triggerWorkStealing(): Promise<number> {
-    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);
-
-          // 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;
-  }
-
-  // ============================================================================
-  // Agent Management
-  // ============================================================================
-
-  listAllAgents(): AgentInfo[] {
-    return this.agentCoordinator.listAgents();
-  }
-
-  getAgentsByDomain(domain: DomainName): AgentInfo[] {
-    return this.agentCoordinator.listAgents({ domain });
-  }
-
-  async requestAgentSpawn(
-    domain: DomainName,
-    type: string,
-    capabilities: string[]
-  ): Promise<Result<string, Error>> {
-    if (!this.agentCoordinator.canSpawn()) {
-      return err(new Error('Maximum concurrent agents reached (15)'));
-    }
-
-    const result = await this.agentCoordinator.spawn({
-      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,
-      });
-    }
-
-    return result;
-  }
-
-  // ============================================================================
-  // Health & Metrics
-  // ============================================================================
-
-  getHealth(): QueenHealth {
-    const domainHealth = new Map<DomainName, DomainHealth>();
-    const issues: HealthIssue[] = [];
-    let unhealthyCount = 0;
-    let degradedCount = 0;
-
-    for (const domain of ALL_DOMAINS) {
-      const health = this.getDomainHealth(domain);
-      if (health) {
-        domainHealth.set(domain, health);
-        if (health.status === 'unhealthy') {
-          unhealthyCount++;
-          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(),
-          });
-        }
-      }
-    }
-
-    const agents = this.agentCoordinator.listAgents();
-    const activeAgents = agents.filter(a => a.status === 'running').length;
-    const pendingTasks = this.getQueuedTaskCount();
-    const runningTasks = this.getRunningTaskCount();
-
-    // Determine overall health
-    let status: QueenHealth['status'] = 'healthy';
-    if (unhealthyCount > 0) {
-      status = 'unhealthy';
-    } else if (degradedCount > ALL_DOMAINS.length / 2) {
-      status = 'degraded';
-    }
-
-    return {
-      status,
-      domainHealth,
-      totalAgents: agents.length,
-      activeAgents,
-      pendingTasks,
-      runningTasks,
-      workStealingActive: this.workStealingTimer !== null,
-      lastHealthCheck: new Date(),
-      issues,
-    };
-  }
-
-  getMetrics(): QueenMetrics {
-    const domainUtilization = new Map<DomainName, number>();
-    let totalLoad = 0;
-
-    for (const domain of ALL_DOMAINS) {
-      const load = this.getDomainLoad(domain);
-      domainUtilization.set(domain, load);
-      totalLoad += load;
-    }
-
-    const agents = this.agentCoordinator.listAgents();
-    const activeAgents = agents.filter(a => a.status === 'running').length;
-    const agentUtilization = agents.length > 0 ? activeAgents / agents.length : 0;
-
-    const avgDuration = this.taskDurations.length > 0
-      ? this.taskDurations.reduce((a, b) => a + b, 0) / this.taskDurations.length
-      : 0;
-
-    return {
-      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(),
-    };
-  }
-
-  // ============================================================================
-  // Protocol & Workflow
-  // ============================================================================
-
-  async executeProtocol(
-    protocolId: string,
-    params?: Record<string, unknown>
-  ): Promise<Result<string, Error>> {
-    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,
-      });
-      return ok(result.value.executionId);
-    }
-
-    return result as Result<string, Error>;
-  }
-
-  async executeWorkflow(
-    workflowId: string,
-    params?: Record<string, unknown>
-  ): Promise<Result<string, Error>> {
-    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,
-      });
-      return ok(result.value.executionId);
-    }
-
-    return result as Result<string, Error>;
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  private subscribeToEvents(): void {
-    // Listen for task completion events from domains
-    for (const domain of ALL_DOMAINS) {
-      this.router.subscribeToDoamin(domain, async (event) => {
-        await this.handleDomainEvent(event);
-      });
-    }
-
-    // Listen for specific coordination events
-    this.router.subscribeToEventType('TaskCompleted', async (event) => {
-      await this.handleTaskCompleted(event);
-    });
-
-    this.router.subscribeToEventType('TaskFailed', async (event) => {
-      await this.handleTaskFailed(event);
-    });
-
-    this.router.subscribeToEventType('AgentStatusChanged', async (event) => {
-      await this.handleAgentStatusChanged(event);
-    });
-  }
-
-  private async handleDomainEvent(event: DomainEvent): Promise<void> {
-    // Update domain activity
-    this.domainLastActivity.set(event.source, new Date());
-
-    // Check if this frees up capacity for queued tasks
-    await this.processQueue();
-  }
-
-  private async handleTaskCompleted(event: DomainEvent): Promise<void> {
-    const { taskId, result } = event.payload as { taskId: string; result: unknown };
-    const execution = this.tasks.get(taskId);
-
-    if (execution) {
-      const duration = execution.startedAt
-        ? Date.now() - execution.startedAt.getTime()
-        : 0;
-
-      this.tasks.set(taskId, {
-        ...execution,
-        status: 'completed',
-        completedAt: new Date(),
-        result,
-      });
-
-      this.tasksCompleted++;
-      this.taskDurations.push(duration);
-
-      // Keep only last 1000 durations for averaging
-      if (this.taskDurations.length > 1000) {
-        this.taskDurations.shift();
-      }
-    }
-
-    // Process queue for next task
-    await this.processQueue();
-  }
-
-  private async handleTaskFailed(event: DomainEvent): Promise<void> {
-    const { taskId, error } = event.payload as { taskId: string; error: string };
-    const execution = this.tasks.get(taskId);
-
-    if (execution) {
-      // Check if we should retry
-      if (execution.retryCount < this.config.taskRetryLimit) {
-        // Retry the task
-        const retried: TaskExecution = {
-          ...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++;
-      }
-    }
-
-    await this.processQueue();
-  }
-
-  private async handleAgentStatusChanged(event: DomainEvent): Promise<void> {
-    const { agentId: _agentId, status, domain } = event.payload as {
-      agentId: string;
-      status: AgentStatus;
-      domain: DomainName;
-    };
-
-    this.domainLastActivity.set(domain, new Date());
-
-    // If agent completed or failed, check for queued tasks
-    if (status === 'completed' || status === 'failed') {
-      await this.processQueue();
-    }
-  }
-
-  private async assignTask(task: QueenTask): Promise<Result<string, Error>> {
-    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: DomainName | undefined;
-    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);
-  }
-
-  private async assignTaskToDomain(task: QueenTask, domain: DomainName): Promise<Result<string, Error>> {
-    // Spawn an agent for this task if needed
-    const spawnResult = await this.requestAgentSpawn(
-      domain,
-      'task-worker',
-      ['task-execution', task.type]
-    );
-
-    const agentIds: string[] = [];
-    if (spawnResult.success) {
-      agentIds.push(spawnResult.value);
-    }
-
-    const execution: TaskExecution = {
-      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());
-
-    await this.publishEvent('TaskAssigned', {
-      taskId: task.id,
-      domain,
-      agentIds,
-    });
-
-    // Invoke domain API if available
-    if (this.domainPlugins) {
-      const plugin = this.domainPlugins.get(domain);
-      if (plugin) {
-        try {
-          await plugin.handleEvent({
-            id: uuidv4(),
-            type: 'TaskAssigned',
-            timestamp: new Date(),
-            source: 'queen-coordinator' as DomainName,
-            correlationId: task.correlationId,
-            payload: { task },
-          });
-        } catch (error) {
-          // Log but don't fail - domain will handle via event bus
-        }
-      }
-    }
-
-    return ok(task.id);
-  }
-
-  private enqueueTask(task: QueenTask): void {
-    const priorityQueue = this.taskQueue.get(task.priority);
-    if (priorityQueue) {
-      priorityQueue.push(task);
-      // Sort by creation time within priority
-      priorityQueue.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-    }
-
-    // Also add to domain-specific queues
-    for (const domain of task.targetDomains) {
-      const domainQueue = this.domainQueues.get(domain);
-      if (domainQueue) {
-        domainQueue.push(task);
-      }
-    }
-  }
-
-  private removeFromQueues(task: QueenTask): void {
-    // 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);
-      }
-    }
-
-    // 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);
-        }
-      }
-    }
-  }
-
-  private async processQueue(): Promise<void> {
-    const runningCount = this.getRunningTaskCount();
-    if (runningCount >= this.config.maxConcurrentTasks) {
-      return;
-    }
-
-    // Process by priority (p0 first)
-    for (const priority of ['p0', 'p1', 'p2', 'p3'] as Priority[]) {
-      const queue = this.taskQueue.get(priority);
-      if (!queue || queue.length === 0) continue;
-
-      const task = queue.shift();
-      if (task) {
-        this.removeFromQueues(task);
-        await this.assignTask(task);
-
-        // Check if we can process more
-        if (this.getRunningTaskCount() >= this.config.maxConcurrentTasks) {
-          return;
-        }
-      }
-    }
-  }
-
-  private getQueuePosition(task: QueenTask): number {
-    let position = 0;
-
-    // Count tasks ahead in higher priority queues
-    for (const p of ['p0', 'p1', 'p2', 'p3'] as Priority[]) {
-      const queue = this.taskQueue.get(p);
-      if (queue) {
-        if (p === task.priority) {
-          position += queue.findIndex(t => t.id === task.id);
-          break;
-        }
-        position += queue.length;
-      }
-    }
-
-    return position;
-  }
-
-  private getRunningTaskCount(): number {
-    return Array.from(this.tasks.values())
-      .filter(t => t.status === 'running' || t.status === 'assigned')
-      .length;
-  }
-
-  private getQueuedTaskCount(): number {
-    return Array.from(this.tasks.values())
-      .filter(t => t.status === 'queued')
-      .length;
-  }
-
-  private canDomainHandleTask(domain: DomainName, task: QueenTask): boolean {
-    const compatibleDomains = TASK_DOMAIN_MAP[task.type] || [];
-    return compatibleDomains.includes(domain);
-  }
-
-  private startWorkStealing(): void {
-    this.workStealingTimer = setInterval(async () => {
-      await this.triggerWorkStealing();
-    }, this.config.workStealing.checkInterval);
-  }
-
-  private startMetricsCollection(): void {
-    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',
-      });
-    }, this.config.metricsInterval);
-  }
-
-  private async loadState(): Promise<void> {
-    try {
-      const state = await this.memory.get<{
-        tasks: [string, TaskExecution][];
-      }>('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);
-          }
-        }
-      }
-    } catch {
-      // Ignore errors loading state
-    }
-  }
-
-  private async saveState(): Promise<void> {
-    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 }
-    );
-  }
-
-  private async publishEvent(type: string, payload: Record<string, unknown>): Promise<void> {
-    await this.eventBus.publish({
-      id: uuidv4(),
-      type: `Queen${type}`,
-      timestamp: new Date(),
-      source: 'queen-coordinator' as DomainName,
-      payload,
-    });
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create a Queen Coordinator from a QE Kernel
- */
-export function createQueenCoordinator(
-  kernel: QEKernel,
-  router: CrossDomainRouter,
-  protocolExecutor?: ProtocolExecutor,
-  workflowExecutor?: WorkflowExecutor,
-  config?: Partial<QueenConfig>
-): QueenCoordinator {
-  return new QueenCoordinator(
-    kernel.eventBus,
-    kernel.coordinator,
-    kernel.memory,
-    router,
-    protocolExecutor,
-    workflowExecutor,
-    undefined,
-    config
-  );
-}