agentic-qe 3.6.8 → 3.6.9

package/v3/dist/coordination/queen-lifecycle.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Agentic QE v3 - Queen Lifecycle & State Management
+ * Extracted from queen-coordinator.ts - Initialize/dispose subsystems,
+ * state persistence, metrics collection, and task cleanup.
+ */
+import type { DomainName } from '../shared/types';
+import type { DomainPlugin, MemoryBackend } from '../kernel/interfaces';
+import type { QueenMinCutBridge } from './mincut/queen-integration';
+import type { IMinCutAwareDomain } from './mixins/mincut-aware-domain.js';
+import type { TraceContext } from './agent-teams/tracing.js';
+import type { TaskExecution, QueenConfig, QueenTask, QueenMetrics } from './queen-types.js';
+/**
+ * Type guard to check if a plugin supports MinCut integration
+ * ADR-047: Uses proper typing instead of `as any`
+ */
+export declare function isMinCutAwarePlugin(plugin: DomainPlugin): plugin is DomainPlugin & IMinCutAwareDomain;
+/**
+ * Inject MinCut bridge into all domain plugins that support it.
+ * ADR-047: Enables domains to access topology health and participate in self-healing.
+ */
+export declare function injectMinCutBridgeIntoPlugins(domainPlugins: Map<DomainName, DomainPlugin>, bridge: QueenMinCutBridge): void;
+/**
+ * Load persisted state (queued tasks) from memory backend.
+ */
+export declare function loadState(memory: MemoryBackend, tasks: Map<string, TaskExecution>, enqueueTask: (task: QueenTask) => void): Promise<void>;
+/**
+ * Save current state (queued tasks) to memory backend.
+ */
+export declare function saveState(memory: MemoryBackend, tasks: Map<string, TaskExecution>): Promise<void>;
+export interface MetricsCollectionContext {
+    readonly config: QueenConfig;
+    readonly memory: MemoryBackend;
+    readonly dynamicScaler: import('./dynamic-scaling/index.js').DynamicScaler | null;
+    getMetrics(): QueenMetrics;
+    publishEvent(type: string, payload: Record<string, unknown>): Promise<void>;
+    getQueuedTaskCount(): number;
+    getActiveAgentCount(): number;
+    getIdleAgentCount(): number;
+    getAverageTaskDuration(): number;
+    getTasksReceived(): number;
+    getTasksFailed(): number;
+    getTasksCompleted(): number;
+}
+/**
+ * Start the metrics collection interval timer.
+ * ADR-064 Phase 4C: Also feeds workload metrics to dynamic scaler.
+ */
+export declare function startMetricsCollectionTimer(ctx: MetricsCollectionContext): NodeJS.Timeout;
+/**
+ * MEM-002 FIX: Clean up completed/failed/cancelled tasks older than retention period.
+ * MEM-003 FIX: Also enforces max-size guard on taskTraceContexts.
+ *
+ * @returns Number of tasks cleaned up
+ */
+export declare function cleanupCompletedTasks(tasks: Map<string, TaskExecution>, taskTraceContexts: Map<string, TraceContext>, retentionMs?: number): number;
+/**
+ * Get list of enabled domains.
+ * Issue #205 fix: Used to only check enabled domains in health reporting.
+ */
+export declare function getEnabledDomains(domainPlugins: Map<DomainName, DomainPlugin> | undefined, allDomains: readonly DomainName[]): DomainName[];
+//# sourceMappingURL=queen-lifecycle.d.ts.map

package/v3/dist/coordination/queen-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queen-lifecycle.d.ts","sourceRoot":"","sources":["../../src/coordination/queen-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACd,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,SAAS,EACT,YAAY,EACb,MAAM,kBAAkB,CAAC;AAM1B;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,IAAI,YAAY,GAAG,kBAAkB,CAErG;AAMD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,EAC5C,MAAM,EAAE,iBAAiB,GACxB,IAAI,CAON;AAMD;;GAEG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EACjC,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,GACrC,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC,CASf;AAMD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAG/B,QAAQ,CAAC,aAAa,EAAE,OAAO,4BAA4B,EAAE,aAAa,GAAG,IAAI,CAAC;IAGlF,UAAU,IAAI,YAAY,CAAC;IAC3B,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,kBAAkB,IAAI,MAAM,CAAC;IAC7B,mBAAmB,IAAI,MAAM,CAAC;IAC9B,iBAAiB,IAAI,MAAM,CAAC;IAC5B,sBAAsB,IAAI,MAAM,CAAC;IACjC,gBAAgB,IAAI,MAAM,CAAC;IAC3B,cAAc,IAAI,MAAM,CAAC;IACzB,iBAAiB,IAAI,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,wBAAwB,GAAG,MAAM,CAAC,OAAO,CA0CzF;AAMD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EACjC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,WAAW,GAAE,MAAgB,GAC5B,MAAM,CAyCR;AAMD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,GAAG,SAAS,EACxD,UAAU,EAAE,SAAS,UAAU,EAAE,GAChC,UAAU,EAAE,CAKd"}

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

@@ -0,0 +1,162 @@
+/**
+ * Agentic QE v3 - Queen Lifecycle & State Management
+ * Extracted from queen-coordinator.ts - Initialize/dispose subsystems,
+ * state persistence, metrics collection, and task cleanup.
+ */
+// ============================================================================
+// MinCut type guard
+// ============================================================================
+/**
+ * Type guard to check if a plugin supports MinCut integration
+ * ADR-047: Uses proper typing instead of `as any`
+ */
+export function isMinCutAwarePlugin(plugin) {
+    return typeof plugin.setMinCutBridge === 'function';
+}
+// ============================================================================
+// MinCut injection
+// ============================================================================
+/**
+ * Inject MinCut bridge into all domain plugins that support it.
+ * ADR-047: Enables domains to access topology health and participate in self-healing.
+ */
+export function injectMinCutBridgeIntoPlugins(domainPlugins, bridge) {
+    for (const [domainName, plugin] of domainPlugins) {
+        if (isMinCutAwarePlugin(plugin)) {
+            plugin.setMinCutBridge(bridge);
+            console.log(`[QueenCoordinator] MinCut bridge injected into ${domainName}`);
+        }
+    }
+}
+// ============================================================================
+// State persistence
+// ============================================================================
+/**
+ * Load persisted state (queued tasks) from memory backend.
+ */
+export async function loadState(memory, tasks, enqueueTask) {
+    try {
+        const state = await memory.get('queen:state');
+        if (state) {
+            for (const [id, execution] of state.tasks) {
+                if (execution.status === 'queued') {
+                    tasks.set(id, execution);
+                    enqueueTask(execution.task);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.debug('[QueenCoordinator] State loading failed:', error instanceof Error ? error.message : error);
+    }
+}
+/**
+ * Save current state (queued tasks) to memory backend.
+ */
+export async function saveState(memory, tasks) {
+    const queuedTasks = Array.from(tasks.entries())
+        .filter(([, t]) => t.status === 'queued');
+    await memory.set('queen:state', { tasks: queuedTasks }, { namespace: 'queen-coordinator', persist: true });
+}
+/**
+ * Start the metrics collection interval timer.
+ * ADR-064 Phase 4C: Also feeds workload metrics to dynamic scaler.
+ */
+export function startMetricsCollectionTimer(ctx) {
+    return setInterval(async () => {
+        const metrics = ctx.getMetrics();
+        await ctx.publishEvent('MetricsCollected', { metrics });
+        await ctx.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 (ctx.dynamicScaler) {
+            try {
+                const avgDuration = ctx.getAverageTaskDuration();
+                const workloadMetrics = {
+                    queueDepth: ctx.getQueuedTaskCount(),
+                    activeAgents: ctx.getActiveAgentCount(),
+                    idleAgents: ctx.getIdleAgentCount(),
+                    avgTaskDurationMs: avgDuration,
+                    errorRate: ctx.getTasksReceived() > 0
+                        ? ctx.getTasksFailed() / ctx.getTasksReceived()
+                        : 0,
+                    throughput: metrics.uptime > 0
+                        ? (ctx.getTasksCompleted() / (metrics.uptime / 1000))
+                        : 0,
+                    timestamp: Date.now(),
+                };
+                ctx.dynamicScaler.recordMetrics(workloadMetrics);
+                const decision = ctx.dynamicScaler.evaluate();
+                if (decision && decision.action !== 'maintain') {
+                    console.log(`[QueenCoordinator] Dynamic scaler: ${decision.action} to ${decision.targetAgents} agents — ${decision.reason}`);
+                    ctx.dynamicScaler.execute(decision).catch(scaleErr => {
+                        console.warn('[QueenCoordinator] Dynamic scaling execution error:', scaleErr);
+                    });
+                }
+            }
+            catch (scaleError) {
+                console.warn('[QueenCoordinator] Dynamic scaler metrics error:', scaleError);
+            }
+        }
+    }, ctx.config.metricsInterval);
+}
+// ============================================================================
+// Task cleanup
+// ============================================================================
+/**
+ * MEM-002 FIX: Clean up completed/failed/cancelled tasks older than retention period.
+ * MEM-003 FIX: Also enforces max-size guard on taskTraceContexts.
+ *
+ * @returns Number of tasks cleaned up
+ */
+export function cleanupCompletedTasks(tasks, taskTraceContexts, retentionMs = 3600000) {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [taskId, execution] of tasks) {
+        if (execution.status === 'completed' ||
+            execution.status === 'failed' ||
+            execution.status === 'cancelled') {
+            const completedTime = execution.completedAt?.getTime() ||
+                execution.startedAt?.getTime() ||
+                0;
+            if (completedTime > 0 && now - completedTime > retentionMs) {
+                tasks.delete(taskId);
+                taskTraceContexts.delete(taskId);
+                cleaned++;
+            }
+        }
+    }
+    // MEM-003 FIX: Enforce max-size guard on taskTraceContexts (FIFO eviction)
+    const MAX_TRACE_CONTEXTS = 10000;
+    if (taskTraceContexts.size > MAX_TRACE_CONTEXTS) {
+        const excess = taskTraceContexts.size - MAX_TRACE_CONTEXTS;
+        const keysIterator = taskTraceContexts.keys();
+        for (let i = 0; i < excess; i++) {
+            const oldest = keysIterator.next().value;
+            if (oldest !== undefined) {
+                taskTraceContexts.delete(oldest);
+            }
+        }
+        console.log(`[QueenCoordinator] Evicted ${excess} oldest trace contexts (max: ${MAX_TRACE_CONTEXTS})`);
+    }
+    if (cleaned > 0) {
+        console.log(`[QueenCoordinator] Cleaned up ${cleaned} old tasks (retention: ${retentionMs}ms)`);
+    }
+    return cleaned;
+}
+// ============================================================================
+// Enabled domains helper
+// ============================================================================
+/**
+ * Get list of enabled domains.
+ * Issue #205 fix: Used to only check enabled domains in health reporting.
+ */
+export function getEnabledDomains(domainPlugins, allDomains) {
+    if (domainPlugins && domainPlugins.size > 0) {
+        return Array.from(domainPlugins.keys());
+    }
+    return [...allDomains];
+}
+//# sourceMappingURL=queen-lifecycle.js.map

package/v3/dist/coordination/queen-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queen-lifecycle.js","sourceRoot":"","sources":["../../src/coordination/queen-lifecycle.ts"],"names":[],"mappings":"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"}

package/v3/dist/coordination/queen-task-management.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Agentic QE v3 - Queen Task Management
+ * Extracted from queen-coordinator.ts - Task assignment, domain routing,
+ * TinyDancer integration, queue operations, and domain plugin execution.
+ */
+import type { DomainName, Priority, Result } from '../shared/types';
+import type { AgentCoordinator, DomainPlugin } from '../kernel/interfaces';
+import type { TaskAuditLogger } from './services';
+import type { QueenRouterAdapter } from '../routing/queen-integration.js';
+import type { DomainBreakerRegistry } from './circuit-breaker/index.js';
+import type { DomainTeamManager } from './agent-teams/domain-team-manager.js';
+import type { TierSelector } from './fleet-tiers/index.js';
+import type { TraceCollector, TraceContext } from './agent-teams/tracing.js';
+import type { QueenTask, TaskExecution, QueenConfig, TaskFilter } from './queen-types.js';
+/**
+ * PERF-001 FIX: Comparator for tasks - sorted by createdAt ascending (oldest first / FIFO within priority)
+ */
+export declare const taskComparator: import("../shared/utils/binary-insert").Comparator<QueenTask>;
+/**
+ * Interface exposing QueenCoordinator internals needed by task management functions.
+ */
+export interface QueenTaskContext {
+    readonly config: QueenConfig;
+    readonly tasks: Map<string, TaskExecution>;
+    readonly taskQueue: Map<Priority, QueenTask[]>;
+    readonly domainQueues: Map<DomainName, QueenTask[]>;
+    readonly domainLastActivity: Map<DomainName, Date>;
+    readonly auditLogger: TaskAuditLogger;
+    readonly agentCoordinator: AgentCoordinator;
+    readonly domainPlugins?: Map<DomainName, DomainPlugin>;
+    runningTaskCounter: number;
+    tasksReceived: number;
+    tasksCompleted: number;
+    tasksFailed: number;
+    taskDurations: {
+        push(v: number): void;
+    };
+    readonly tinyDancerRouter: QueenRouterAdapter | null;
+    readonly domainBreakerRegistry: DomainBreakerRegistry | null;
+    readonly domainTeamManager: DomainTeamManager | null;
+    readonly tierSelector: TierSelector | null;
+    readonly traceCollector: TraceCollector | null;
+    readonly taskTraceContexts: Map<string, TraceContext>;
+    requestAgentSpawn(domain: DomainName, type: string, capabilities: string[]): Promise<Result<string, Error>>;
+    publishEvent(type: string, payload: Record<string, unknown>): Promise<void>;
+    getDomainLoad(domain: DomainName): number;
+    getDomainHealth(domain: DomainName): import('../kernel/interfaces').DomainHealth | undefined;
+}
+/**
+ * PERF-001 FIX: Use binary insertion O(log n) instead of sort O(n log n)
+ */
+export declare function enqueueTask(taskQueue: Map<Priority, QueenTask[]>, domainQueues: Map<DomainName, QueenTask[]>, task: QueenTask): void;
+/**
+ * Remove a task from all queues.
+ * PERF-008: Only iterate the task's targetDomains instead of ALL_DOMAINS.
+ */
+export declare function removeFromQueues(taskQueue: Map<Priority, QueenTask[]>, domainQueues: Map<DomainName, QueenTask[]>, task: QueenTask): void;
+/**
+ * Get the position of a task within the priority queues.
+ */
+export declare function getQueuePosition(taskQueue: Map<Priority, QueenTask[]>, task: QueenTask): number;
+/**
+ * Process the queue: dequeue highest-priority tasks and assign them.
+ * CC-002 FIX: Uses atomic counter for capacity check.
+ */
+export declare function processQueue(ctx: QueenTaskContext): Promise<void>;
+/**
+ * List tasks with optional filtering.
+ */
+export declare function listTasks(tasks: Map<string, TaskExecution>, filter?: TaskFilter): TaskExecution[];
+/**
+ * Assign a task to the least-loaded healthy domain.
+ */
+export declare function assignTask(ctx: QueenTaskContext, task: QueenTask): Promise<Result<string, Error>>;
+/**
+ * Assign a task to a specific domain, including TinyDancer routing,
+ * circuit breaker checks, team management, and domain plugin execution.
+ */
+export declare function assignTaskToDomain(ctx: QueenTaskContext, task: QueenTask, domain: DomainName): Promise<Result<string, Error>>;
+/**
+ * Check if a domain can handle a given task type.
+ */
+export declare function canDomainHandleTask(domain: DomainName, task: QueenTask): boolean;
+//# sourceMappingURL=queen-task-management.d.ts.map

package/v3/dist/coordination/queen-task-management.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queen-task-management.d.ts","sourceRoot":"","sources":["../../src/coordination/queen-task-management.ts"],"names":[],"mappings":"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"}

package/v3/dist/coordination/queen-task-management.js

@@ -0,0 +1,333 @@
+/**
+ * Agentic QE v3 - Queen Task Management
+ * Extracted from queen-coordinator.ts - Task assignment, domain routing,
+ * TinyDancer integration, queue operations, and domain plugin execution.
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { ok, err } from '../shared/types';
+import { binaryInsert, createdAtComparator } from '../shared/utils/index.js';
+import { TASK_DOMAIN_MAP } from './queen-types.js';
+// ============================================================================
+// Task comparator for priority queue binary insertion
+// ============================================================================
+/**
+ * PERF-001 FIX: Comparator for tasks - sorted by createdAt ascending (oldest first / FIFO within priority)
+ */
+export const taskComparator = createdAtComparator();
+// ============================================================================
+// Queue operations
+// ============================================================================
+/**
+ * PERF-001 FIX: Use binary insertion O(log n) instead of sort O(n log n)
+ */
+export function enqueueTask(taskQueue, domainQueues, task) {
+    const priorityQueue = taskQueue.get(task.priority);
+    if (priorityQueue) {
+        binaryInsert(priorityQueue, task, taskComparator);
+    }
+    // Also add to domain-specific queues (unsorted - just for load tracking)
+    for (const domain of task.targetDomains) {
+        const domainQueue = domainQueues.get(domain);
+        if (domainQueue) {
+            domainQueue.push(task);
+        }
+    }
+}
+/**
+ * Remove a task from all queues.
+ * PERF-008: Only iterate the task's targetDomains instead of ALL_DOMAINS.
+ */
+export function removeFromQueues(taskQueue, domainQueues, task) {
+    const priorityQueue = taskQueue.get(task.priority);
+    if (priorityQueue) {
+        const idx = priorityQueue.findIndex(t => t.id === task.id);
+        if (idx !== -1) {
+            priorityQueue.splice(idx, 1);
+        }
+    }
+    for (const domain of task.targetDomains) {
+        const domainQueue = domainQueues.get(domain);
+        if (domainQueue) {
+            const idx = domainQueue.findIndex(t => t.id === task.id);
+            if (idx !== -1) {
+                domainQueue.splice(idx, 1);
+            }
+        }
+    }
+}
+/**
+ * Get the position of a task within the priority queues.
+ */
+export function getQueuePosition(taskQueue, task) {
+    let position = 0;
+    for (const p of ['p0', 'p1', 'p2', 'p3']) {
+        const queue = taskQueue.get(p);
+        if (queue) {
+            if (p === task.priority) {
+                position += queue.findIndex(t => t.id === task.id);
+                break;
+            }
+            position += queue.length;
+        }
+    }
+    return position;
+}
+/**
+ * Process the queue: dequeue highest-priority tasks and assign them.
+ * CC-002 FIX: Uses atomic counter for capacity check.
+ */
+export async function processQueue(ctx) {
+    if (ctx.runningTaskCounter >= ctx.config.maxConcurrentTasks) {
+        return;
+    }
+    for (const priority of ['p0', 'p1', 'p2', 'p3']) {
+        const queue = ctx.taskQueue.get(priority);
+        if (!queue || queue.length === 0)
+            continue;
+        const task = queue.shift();
+        if (task) {
+            removeFromQueues(ctx.taskQueue, ctx.domainQueues, task);
+            // CC-002 FIX: Increment counter before assigning queued task
+            ctx.runningTaskCounter++;
+            try {
+                await assignTask(ctx, task);
+            }
+            catch (error) {
+                ctx.runningTaskCounter--;
+                throw error;
+            }
+            if (ctx.runningTaskCounter >= ctx.config.maxConcurrentTasks) {
+                return;
+            }
+        }
+    }
+}
+// ============================================================================
+// Task filtering
+// ============================================================================
+/**
+ * List tasks with optional filtering.
+ */
+export function listTasks(tasks, filter) {
+    let result = Array.from(tasks.values());
+    if (filter) {
+        if (filter.status) {
+            result = result.filter(t => t.status === filter.status);
+        }
+        if (filter.domain) {
+            result = result.filter(t => t.assignedDomain === filter.domain);
+        }
+        if (filter.priority) {
+            result = result.filter(t => t.task.priority === filter.priority);
+        }
+        if (filter.type) {
+            result = result.filter(t => t.task.type === filter.type);
+        }
+        if (filter.fromDate) {
+            result = result.filter(t => t.task.createdAt >= filter.fromDate);
+        }
+        if (filter.toDate) {
+            result = result.filter(t => t.task.createdAt <= filter.toDate);
+        }
+    }
+    return result;
+}
+// ============================================================================
+// Task assignment
+// ============================================================================
+/**
+ * Assign a task to the least-loaded healthy domain.
+ */
+export async function assignTask(ctx, 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}`));
+    }
+    let bestDomain;
+    let lowestLoad = Infinity;
+    for (const domain of targetDomains) {
+        const load = ctx.getDomainLoad(domain);
+        const health = ctx.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 assignTaskToDomain(ctx, task, bestDomain);
+}
+/**
+ * Assign a task to a specific domain, including TinyDancer routing,
+ * circuit breaker checks, team management, and domain plugin execution.
+ */
+export async function assignTaskToDomain(ctx, task, domain) {
+    // V3 Integration: Use TinyDancer for intelligent model routing
+    let routeDecision;
+    if (ctx.tinyDancerRouter) {
+        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 ctx.tinyDancerRouter.route(classifiableTask);
+        if (ctx.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 (ctx.domainBreakerRegistry) {
+        if (!ctx.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
+    if (ctx.domainTeamManager) {
+        try {
+            const existingTeam = ctx.domainTeamManager.getDomainTeam(domain);
+            if (!existingTeam) {
+                const leadId = `${domain}-lead`;
+                ctx.domainTeamManager.createDomainTeam(domain, leadId);
+            }
+        }
+        catch (teamError) {
+            console.warn(`[Queen] Domain team setup for '${domain}' failed (continuing):`, teamError);
+        }
+    }
+    // Spawn an agent for this task if needed, using TinyDancer-recommended tier
+    const agentType = routeDecision?.tier || 'task-worker';
+    const spawnResult = await ctx.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,
+    };
+    ctx.tasks.set(task.id, execution);
+    ctx.domainLastActivity.set(domain, new Date());
+    // SEC-003 Simplified: Log task assignment
+    for (const agentId of agentIds) {
+        ctx.auditLogger.logAssign(task.id, agentId, domain);
+    }
+    await ctx.publishEvent('TaskAssigned', {
+        taskId: task.id,
+        domain,
+        agentIds,
+    });
+    // INTEGRATION FIX: Invoke domain plugin directly for task execution
+    if (ctx.domainPlugins) {
+        const plugin = ctx.domainPlugins.get(domain);
+        if (plugin?.executeTask && plugin.canHandleTask?.(task.type)) {
+            const request = {
+                taskId: task.id,
+                taskType: task.type,
+                payload: task.payload,
+                priority: task.priority,
+                timeout: task.timeout,
+                correlationId: task.correlationId,
+            };
+            const execResult = await plugin.executeTask(request, (result) => handleTaskCompletionCallback(ctx, result));
+            if (!execResult.success) {
+                ctx.tasks.set(task.id, {
+                    ...execution,
+                    status: 'failed',
+                    error: execResult.error.message,
+                    completedAt: new Date(),
+                });
+                ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
+                ctx.tasksFailed++;
+                ctx.auditLogger.logFail(task.id, agentIds[0], execResult.error.message);
+                return err(execResult.error);
+            }
+            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) {
+                console.warn(`[Queen] Failed to invoke domain ${domain} event handler:`, error);
+            }
+        }
+    }
+    return ok(task.id);
+}
+// ============================================================================
+// Task completion callback (from domain plugin)
+// ============================================================================
+/**
+ * Handle task completion callback from domain plugin.
+ * Queen-Domain Integration Fix: Direct task execution callback handler.
+ */
+async function handleTaskCompletionCallback(ctx, result) {
+    const execution = ctx.tasks.get(result.taskId);
+    if (!execution) {
+        console.warn(`[Queen] Received completion for unknown task: ${result.taskId}`);
+        return;
+    }
+    const updated = {
+        ...execution,
+        status: result.success ? 'completed' : 'failed',
+        completedAt: new Date(),
+        result: result.data,
+        error: result.error,
+    };
+    ctx.tasks.set(result.taskId, updated);
+    if (result.success) {
+        ctx.tasksCompleted++;
+        ctx.taskDurations.push(result.duration);
+        ctx.auditLogger.logComplete(result.taskId, execution.assignedAgents[0]);
+    }
+    else {
+        ctx.tasksFailed++;
+        ctx.auditLogger.logFail(result.taskId, execution.assignedAgents[0], result.error || 'Unknown error');
+    }
+    // CC-002: Decrement running task counter
+    ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
+    // Stop assigned agents
+    for (const agentId of execution.assignedAgents) {
+        await ctx.agentCoordinator.stop(agentId);
+    }
+    await ctx.publishEvent(result.success ? 'TaskCompleted' : 'TaskFailed', {
+        taskId: result.taskId,
+        domain: execution.assignedDomain,
+        result: result.data,
+        error: result.error,
+        duration: result.duration,
+    });
+    await processQueue(ctx);
+}
+/**
+ * Check if a domain can handle a given task type.
+ */
+export function canDomainHandleTask(domain, task) {
+    const compatibleDomains = TASK_DOMAIN_MAP[task.type] || [];
+    return compatibleDomains.includes(domain);
+}
+//# sourceMappingURL=queen-task-management.js.map