agentic-qe 3.15.8 → 3.15.10

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

@@ -1,7 +1,8 @@
 /**
  * Agentic QE v3 - Queen Task Management
  * Extracted from queen-coordinator.ts - Task assignment, domain routing,
- * TinyDancer integration, queue operations, and domain plugin execution.
+ * TinyDancer integration, and domain plugin execution. Queue operations and
+ * the drain live in queen-task-queue.ts.
  */
 import type { DomainName, Priority, Result } from '../shared/types';
 import type { AgentCoordinator, DomainPlugin } from '../kernel/interfaces';
@@ -13,10 +14,7 @@ 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>;
+export { taskComparator, enqueueTask, removeFromQueues, getQueuePosition, processQueue, } from './queen-task-queue.js';
 /**
  * Interface exposing QueenCoordinator internals needed by task management functions.
  */
@@ -43,29 +41,11 @@ export interface QueenTaskContext {
     readonly traceCollector: TraceCollector | null;
     readonly taskTraceContexts: Map<string, TraceContext>;
     readonly coExecutionRepo: CoExecutionRepository | null;
-    requestAgentSpawn(domain: DomainName, type: string, capabilities: string[]): Promise<Result<string, Error>>;
+    requestAgentSpawn(domain: DomainName, type: string, capabilities: string[], taskId?: 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.
  */
@@ -79,8 +59,22 @@ export declare function assignTask(ctx: QueenTaskContext, task: QueenTask): Prom
  * circuit breaker checks, team management, and domain plugin execution.
  */
 export declare function assignTaskToDomain(ctx: QueenTaskContext, task: QueenTask, domain: DomainName): Promise<Result<string, Error>>;
+/**
+ * Work stealing: dispatch a queued task to another domain. It takes a slot
+ * like any dispatched task, so its settle leaves the counter balanced, and it
+ * is failed with the reason if it cannot be assigned (#1124).
+ *
+ * Returns whether the task is now running in `domain`. An entry that reached a
+ * terminal state while still queued (#1070) is not dispatched at all.
+ */
+export declare function dispatchStolenTask(ctx: QueenTaskContext, task: QueenTask, domain: DomainName): Promise<boolean>;
 /**
  * Check if a domain can handle a given task type.
  */
 export declare function canDomainHandleTask(domain: DomainName, task: QueenTask): boolean;
+/**
+ * #1124: whether a task can run in a domain, i.e. the domain is configured for
+ * its type and, for a Queen-owned task, the domain's plugin has a handler.
+ */
+export declare function canDomainExecuteTask(domainPlugins: ReadonlyMap<DomainName, DomainPlugin> | undefined, domain: DomainName, task: QueenTask): boolean;
 //# sourceMappingURL=queen-task-management.d.ts.map

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

@@ -1,108 +1,16 @@
 /**
  * Agentic QE v3 - Queen Task Management
  * Extracted from queen-coordinator.ts - Task assignment, domain routing,
- * TinyDancer integration, queue operations, and domain plugin execution.
+ * TinyDancer integration, and domain plugin execution. Queue operations and
+ * the drain live in queen-task-queue.ts.
  */
-import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../shared/types/index.js';
-import { binaryInsert, createdAtComparator } from '../shared/utils/index.js';
-import { TASK_DOMAIN_MAP } from './queen-types.js';
+import { toError } from '../shared/error-utils.js';
+import { getTaskDomains } from './queen-types.js';
 import { settleCancelledTask } from './cancelled-task-settlement.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;
-            }
-        }
-    }
-}
+import { findDomainsWithoutHandler, describeMissingHandler } from './task-executability.js';
+import { processQueue, releaseSlot, settleFailedBeforeRun } from './queen-task-queue.js';
+export { taskComparator, enqueueTask, removeFromQueues, getQueuePosition, processQueue, } from './queen-task-queue.js';
 // ============================================================================
 // Task filtering
 // ============================================================================
@@ -142,7 +50,7 @@ export function listTasks(tasks, filter) {
 export async function assignTask(ctx, task) {
     const targetDomains = task.targetDomains.length > 0
         ? task.targetDomains
-        : TASK_DOMAIN_MAP[task.type] || [];
+        : getTaskDomains(task.type);
     if (targetDomains.length === 0) {
         return err(new Error(`No domains configured for task type: ${task.type}`));
     }
@@ -166,6 +74,16 @@ export async function assignTask(ctx, task) {
  * circuit breaker checks, team management, and domain plugin execution.
  */
 export async function assignTaskToDomain(ctx, task, domain) {
+    // #1081: a Queen-owned task runs only through its domain plugin's handler.
+    // Without one nothing would ever report a result, so fail it now with the
+    // reason instead of leaving it running on a held slot. Caller-owned tasks
+    // are executed by their caller (#1065) and need no handler here.
+    if (task.executionOwner !== 'caller' && ctx.domainPlugins) {
+        const gaps = findDomainsWithoutHandler(ctx.domainPlugins, task.type, [domain]);
+        if (gaps.length > 0) {
+            return failUnexecutableTask(ctx, task, domain, describeMissingHandler(task.type, gaps));
+        }
+    }
     // V3 Integration: Use TinyDancer for intelligent model routing
     let routeDecision;
     if (ctx.tinyDancerRouter) {
@@ -179,7 +97,7 @@ export async function assignTaskToDomain(ctx, task, domain) {
             description: `${task.type}: ${JSON.stringify(task.payload).slice(0, 200)}`,
             type: task.type,
             domain: domain,
-            priority: priorityMap[task.priority],
+            priority: Object.hasOwn(priorityMap, task.priority) ? priorityMap[task.priority] : 'normal',
         };
         routeDecision = await ctx.tinyDancerRouter.route(classifiableTask);
         if (ctx.config.enableMetrics) {
@@ -214,13 +132,13 @@ export async function assignTaskToDomain(ctx, task, domain) {
         // preamble can instruct it to call `aqe llm advise` before substantive work
         ...(routeDecision?.triggerMultiModel ? ['advisor:triggerMultiModel'] : []),
     ];
-    const spawnResult = await ctx.requestAgentSpawn(domain, agentType, spawnCapabilities);
+    const spawnResult = await ctx.requestAgentSpawn(domain, agentType, spawnCapabilities, task.id);
     // A queued task can be cancelled while routing or agent spawn is awaiting.
     // Do not recreate it as running or dispatch its plugin afterward.
     if (ctx.tasks.get(task.id)?.status === 'cancelled') {
         if (spawnResult.success)
             await ctx.agentCoordinator.stop(spawnResult.value);
-        ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
+        await releaseSlot(ctx);
         return ok(task.id);
     }
     const agentIds = [];
@@ -247,6 +165,10 @@ export async function assignTaskToDomain(ctx, task, domain) {
         domain,
         agentIds,
     });
+    // The MCP factory executes caller-owned tasks itself and publishes their result.
+    // Dispatching the plugin here as well would run the same workload twice.
+    if (task.executionOwner === 'caller')
+        return ok(task.id);
     // INTEGRATION FIX: Invoke domain plugin directly for task execution
     if (ctx.domainPlugins) {
         const plugin = ctx.domainPlugins.get(domain);
@@ -259,49 +181,83 @@ export async function assignTaskToDomain(ctx, task, domain) {
                 timeout: task.timeout,
                 correlationId: task.correlationId,
             };
-            const execResult = await plugin.executeTask(request, (result) => handleTaskCompletionCallback(ctx, result));
+            // #1140: a plugin that throws is treated like one that returns err, so
+            // the task is settled here instead of left running on a released slot.
+            let execResult;
+            try {
+                execResult = await plugin.executeTask(request, (result) => handleTaskCompletionCallback(ctx, result));
+            }
+            catch (error) {
+                execResult = err(toError(error));
+            }
             if (!execResult.success) {
                 const cancelled = settleCancelledTask(ctx.tasks, task.id);
                 if (cancelled.ignored) {
-                    if (cancelled.settledNow) {
-                        ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
-                        await processQueue(ctx);
-                    }
+                    if (cancelled.settledNow)
+                        await releaseSlot(ctx);
                     return ok(task.id);
                 }
+                // #1140: the plugin already reported this task through onComplete,
+                // which settled it and released its slot.
+                if (ctx.tasks.get(task.id)?.status !== 'running')
+                    return err(execResult.error);
                 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);
+                await ctx.publishEvent('TaskFailed', { taskId: task.id, domain, error: execResult.error.message });
+                await releaseSlot(ctx);
                 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);
 }
+/**
+ * #1081: settle a Queen-owned task that no handler will execute. It is marked
+ * failed with the reason, its slot is released and the queue moves on.
+ */
+async function failUnexecutableTask(ctx, task, domain, reason) {
+    const traceCtx = ctx.taskTraceContexts.get(task.id);
+    if (ctx.traceCollector && traceCtx) {
+        ctx.traceCollector.failSpan(traceCtx.spanId, reason);
+        ctx.taskTraceContexts.delete(task.id);
+    }
+    await settleFailedBeforeRun(ctx, task, domain, reason);
+    return ok(task.id);
+}
+/**
+ * Work stealing: dispatch a queued task to another domain. It takes a slot
+ * like any dispatched task, so its settle leaves the counter balanced, and it
+ * is failed with the reason if it cannot be assigned (#1124).
+ *
+ * Returns whether the task is now running in `domain`. An entry that reached a
+ * terminal state while still queued (#1070) is not dispatched at all.
+ */
+export async function dispatchStolenTask(ctx, task, domain) {
+    const status = ctx.tasks.get(task.id)?.status;
+    if (status !== undefined && status !== 'queued')
+        return false;
+    ctx.runningTaskCounter++;
+    let assigned;
+    try {
+        assigned = await assignTaskToDomain(ctx, task, domain);
+    }
+    catch (error) {
+        ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
+        throw error;
+    }
+    if (!assigned.success && (ctx.tasks.get(task.id)?.status ?? 'queued') === 'queued') {
+        await settleFailedBeforeRun(ctx, task, domain, assigned.error.message);
+    }
+    const after = ctx.tasks.get(task.id);
+    return after?.assignedDomain === domain && (after.status === 'running' || after.status === 'completed');
+}
 // ============================================================================
 // Task completion callback (from domain plugin)
 // ============================================================================
@@ -369,7 +325,18 @@ async function handleTaskCompletionCallback(ctx, result) {
  * Check if a domain can handle a given task type.
  */
 export function canDomainHandleTask(domain, task) {
-    const compatibleDomains = TASK_DOMAIN_MAP[task.type] || [];
+    const compatibleDomains = getTaskDomains(task.type);
     return compatibleDomains.includes(domain);
 }
+/**
+ * #1124: whether a task can run in a domain, i.e. the domain is configured for
+ * its type and, for a Queen-owned task, the domain's plugin has a handler.
+ */
+export function canDomainExecuteTask(domainPlugins, domain, task) {
+    if (!canDomainHandleTask(domain, task))
+        return false;
+    if (task.executionOwner === 'caller' || !domainPlugins)
+        return true;
+    return findDomainsWithoutHandler(domainPlugins, task.type, [domain]).length === 0;
+}
 //# sourceMappingURL=queen-task-management.js.map

package/dist/coordination/queen-task-queue.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Agentic QE v3 - Queen Task Queue
+ * Extracted from queen-task-management.ts - priority queue operations, the
+ * queue drain, and handing a released slot back to the queue.
+ */
+import type { DomainName, Priority } from '../shared/types';
+import type { QueenTask } from './queen-types.js';
+import { type QueenTaskContext } from './queen-task-management.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>;
+/**
+ * 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>;
+/**
+ * Give back the slot a task held and hand it to the queue: a running drain
+ * picks it up on its next scan, otherwise a new drain starts.
+ */
+export declare function releaseSlot(ctx: QueenTaskContext): Promise<void>;
+/**
+ * Mark a task that never started as failed, publish QueenTaskFailed (#1124)
+ * and hand the slot it held to the queue.
+ */
+export declare function settleFailedBeforeRun(ctx: QueenTaskContext, task: QueenTask, domain: DomainName | undefined, reason: string): Promise<void>;
+//# sourceMappingURL=queen-task-queue.d.ts.map

package/dist/coordination/queen-task-queue.js

@@ -0,0 +1,194 @@
+/**
+ * Agentic QE v3 - Queen Task Queue
+ * Extracted from queen-task-management.ts - priority queue operations, the
+ * queue drain, and handing a released slot back to the queue.
+ */
+import { binaryInsert, createdAtComparator } from '../shared/utils/index.js';
+import { toErrorMessage } from '../shared/error-utils.js';
+import { assignTask } from './queen-task-management.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;
+    }
+    // #1081: while this drain runs, a task failed at dispatch frees its slot
+    // here instead of starting a nested drain (one stack frame per failed task).
+    drainDepth.set(ctx.tasks, (drainDepth.get(ctx.tasks) ?? 0) + 1);
+    try {
+        // #1127: a slot released elsewhere while this drain awaits marks it dirty,
+        // so it scans again from p0 rather than leaving the slot unused.
+        do {
+            drainDirty.delete(ctx.tasks);
+            for (const priority of ['p0', 'p1', 'p2', 'p3']) {
+                const queue = ctx.taskQueue.get(priority);
+                if (!queue || queue.length === 0)
+                    continue;
+                let task = shiftDispatchableTask(ctx, queue);
+                while (task) {
+                    removeFromQueues(ctx.taskQueue, ctx.domainQueues, task);
+                    // CC-002 FIX: Increment counter before assigning queued task
+                    ctx.runningTaskCounter++;
+                    let assigned;
+                    try {
+                        assigned = await assignTask(ctx, task);
+                    }
+                    catch (error) {
+                        ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
+                        throw error;
+                    }
+                    // #1081: a queued task that cannot be assigned (no healthy domain, open
+                    // breaker) has no caller waiting on the result. Fail it with the reason
+                    // rather than leave it queued forever on a held slot.
+                    if (!assigned.success && (ctx.tasks.get(task.id)?.status ?? 'queued') === 'queued') {
+                        await settleFailedBeforeRun(ctx, task, undefined, assigned.error.message);
+                    }
+                    if (ctx.runningTaskCounter >= ctx.config.maxConcurrentTasks) {
+                        return;
+                    }
+                    // #1127: fill every free slot, whether this task started, failed
+                    // before running or was cancelled while it was being assigned.
+                    task = shiftDispatchableTask(ctx, queue);
+                }
+            }
+        } while (drainDirty.has(ctx.tasks) && ctx.runningTaskCounter < ctx.config.maxConcurrentTasks);
+    }
+    finally {
+        const depth = (drainDepth.get(ctx.tasks) ?? 1) - 1;
+        if (depth > 0)
+            drainDepth.set(ctx.tasks, depth);
+        else {
+            drainDepth.delete(ctx.tasks);
+            drainDirty.delete(ctx.tasks);
+        }
+    }
+}
+/**
+ * Drains in progress per Queen, keyed by its task map (the task context
+ * object is rebuilt for every call).
+ */
+const drainDepth = new WeakMap();
+/** #1127: Queens with a slot released while a drain was running. */
+const drainDirty = new WeakSet();
+/**
+ * Give back the slot a task held and hand it to the queue: a running drain
+ * picks it up on its next scan, otherwise a new drain starts.
+ */
+export async function releaseSlot(ctx) {
+    ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
+    if (drainDepth.has(ctx.tasks)) {
+        drainDirty.add(ctx.tasks);
+        return;
+    }
+    // The drain dispatches other tasks. The caller whose task released this
+    // slot does not wait for it (#1140), and its failure belongs to none of
+    // them, so it must not reach that caller.
+    void processQueue(ctx).catch(error => {
+        console.warn('[Queen] Queue drain after a released slot failed:', toErrorMessage(error));
+    });
+}
+/**
+ * Take the next task that is still waiting to run. A queued task can reach a
+ * terminal state without being dequeued, e.g. when its caller executes it
+ * directly (#1070). Dispatching it again would flip it back to running and
+ * leak a capacity slot, so such entries are dropped from the queues instead.
+ */
+function shiftDispatchableTask(ctx, queue) {
+    let task = queue.shift();
+    while (task) {
+        const status = ctx.tasks.get(task.id)?.status;
+        if (status === undefined || status === 'queued')
+            return task;
+        removeFromQueues(ctx.taskQueue, ctx.domainQueues, task);
+        task = queue.shift();
+    }
+    return undefined;
+}
+/**
+ * Mark a task that never started as failed, publish QueenTaskFailed (#1124)
+ * and hand the slot it held to the queue.
+ */
+export async function settleFailedBeforeRun(ctx, task, domain, reason) {
+    ctx.tasks.set(task.id, {
+        taskId: task.id,
+        task,
+        status: 'failed',
+        assignedDomain: domain,
+        assignedAgents: [],
+        retryCount: ctx.tasks.get(task.id)?.retryCount ?? 0,
+        error: reason,
+        completedAt: new Date(),
+    });
+    ctx.tasksFailed++;
+    ctx.auditLogger.logFail(task.id, undefined, reason);
+    await ctx.publishEvent('TaskFailed', { taskId: task.id, domain, error: reason });
+    await releaseSlot(ctx);
+}
+//# sourceMappingURL=queen-task-queue.js.map

package/dist/coordination/queen-types.d.ts

@@ -29,6 +29,8 @@ export interface QueenTask {
     readonly createdAt: Date;
     readonly requester?: string;
     readonly correlationId?: string;
+    /** Trusted caller executes and reports results; Queen still tracks assignment. */
+    readonly executionOwner?: 'queen' | 'caller';
 }
 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' | 'ideation-assessment';
 /**
@@ -134,6 +136,8 @@ export interface HealthIssue {
 export interface IQueenCoordinator {
     initialize(): Promise<void>;
     dispose(): Promise<void>;
+    /** #1075: reject a task type that no candidate domain plugin executes. */
+    validateTaskExecutable(type: TaskType, targetDomains?: readonly DomainName[]): Result<void, Error>;
     submitTask(task: Omit<QueenTask, 'id' | 'createdAt'>): Promise<Result<string, Error>>;
     cancelTask(taskId: string): Promise<Result<void, Error>>;
     getTaskStatus(taskId: string): TaskExecution | undefined;
@@ -147,7 +151,7 @@ export interface IQueenCoordinator {
     triggerWorkStealing(): Promise<number>;
     listAllAgents(): AgentInfo[];
     getAgentsByDomain(domain: DomainName): AgentInfo[];
-    requestAgentSpawn(domain: DomainName, type: string, capabilities: string[]): Promise<Result<string, Error>>;
+    requestAgentSpawn(domain: DomainName, type: string, capabilities: string[], taskId?: string): Promise<Result<string, Error>>;
     getHealth(): QueenHealth;
     getMetrics(): QueenMetrics;
     executeProtocol(protocolId: string, params?: Record<string, unknown>): Promise<Result<string, Error>>;
@@ -176,6 +180,12 @@ export interface TaskFilter {
 export declare const DOMAIN_GROUPS: DomainGroup[];
 export declare const TASK_DOMAIN_MAP: Record<TaskType, DomainName[]>;
 export declare const DEFAULT_QUEEN_CONFIG: QueenConfig;
+/**
+ * Domains configured for a task type, or [] when the type is unknown.
+ * Task types arrive from MCP/CLI callers, so the lookup uses own properties
+ * only: `constructor` or `__proto__` must not resolve through Object.prototype.
+ */
+export declare function getTaskDomains(type: string): readonly DomainName[];
 /**
  * Initialize the TASK_DOMAIN_MAP entries that need ALL_DOMAINS at runtime.
  * Must be called once ALL_DOMAINS is available.

package/dist/coordination/queen-types.js

@@ -69,6 +69,14 @@ export const DEFAULT_QUEEN_CONFIG = {
     // V3 Integration: Enable intelligent model routing by default
     enableRouting: true,
 };
+/**
+ * Domains configured for a task type, or [] when the type is unknown.
+ * Task types arrive from MCP/CLI callers, so the lookup uses own properties
+ * only: `constructor` or `__proto__` must not resolve through Object.prototype.
+ */
+export function getTaskDomains(type) {
+    return Object.hasOwn(TASK_DOMAIN_MAP, type) ? TASK_DOMAIN_MAP[type] : [];
+}
 /**
  * Initialize the TASK_DOMAIN_MAP entries that need ALL_DOMAINS at runtime.
  * Must be called once ALL_DOMAINS is available.