agentic-qe 3.15.9 → 3.15.11

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

@@ -1,152 +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 { ok, err } from '../shared/types/index.js';
-import { binaryInsert, createdAtComparator } from '../shared/utils/index.js';
+import { toError } from '../shared/error-utils.js';
 import { getTaskDomains } from './queen-types.js';
 import { settleCancelledTask } from './cancelled-task-settlement.js';
 import { findDomainsWithoutHandler, describeMissingHandler } from './task-executability.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 {
-        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') {
-                    settleFailedBeforeRun(ctx, task, undefined, assigned.error.message);
-                }
-                if (ctx.runningTaskCounter >= ctx.config.maxConcurrentTasks) {
-                    return;
-                }
-                // A task that failed without starting gave its slot back; let the
-                // next task of this priority have it.
-                task = ctx.tasks.get(task.id)?.status === 'failed' ? shiftDispatchableTask(ctx, queue) : undefined;
-            }
-        }
-    }
-    finally {
-        const depth = (drainDepth.get(ctx.tasks) ?? 1) - 1;
-        if (depth > 0)
-            drainDepth.set(ctx.tasks, depth);
-        else
-            drainDepth.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();
-/**
- * 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;
-}
+import { processQueue, releaseSlot, settleFailedBeforeRun } from './queen-task-queue.js';
+export { taskComparator, enqueueTask, removeFromQueues, getQueuePosition, processQueue, } from './queen-task-queue.js';
 // ============================================================================
 // Task filtering
 // ============================================================================
@@ -268,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 = [];
@@ -317,25 +181,36 @@ 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);
@@ -348,32 +223,40 @@ export async function assignTaskToDomain(ctx, task, domain) {
  * failed with the reason, its slot is released and the queue moves on.
  */
 async function failUnexecutableTask(ctx, task, domain, reason) {
-    settleFailedBeforeRun(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);
     }
-    // Inside a drain, the drain itself hands the freed slot on.
-    if (!drainDepth.has(ctx.tasks))
-        await processQueue(ctx);
+    await settleFailedBeforeRun(ctx, task, domain, reason);
     return ok(task.id);
 }
-/** Mark a task that never started as failed and release the slot it held. */
-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.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
-    ctx.tasksFailed++;
-    ctx.auditLogger.logFail(task.id, undefined, reason);
+/**
+ * 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)
@@ -445,4 +328,15 @@ export function canDomainHandleTask(domain, task) {
     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

@@ -151,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>>;

package/dist/coordination/queen-work-stealing.d.ts

@@ -14,8 +14,13 @@ export interface QueenWorkStealingContext {
     getIdleDomains(): DomainName[];
     getBusyDomains(): DomainName[];
     getDomainLoad(domain: DomainName): number;
+    /** #1140: free Queen slots; a steal starts a task, so it needs one */
+    availableSlots(): number;
+    /** #1124: the domain is configured for the task and its plugin can execute it */
+    canExecuteInDomain(domain: DomainName, task: QueenTask): boolean;
     removeFromQueues(task: QueenTask): void;
-    assignTaskToDomain(task: QueenTask, domain: DomainName): Promise<void>;
+    /** Dispatch a stolen task; resolves whether it now runs in `domain`. */
+    assignTaskToDomain(task: QueenTask, domain: DomainName): Promise<boolean>;
     publishEvent(type: string, payload: Record<string, unknown>): Promise<void>;
 }
 /**

package/dist/coordination/queen-work-stealing.js

@@ -4,7 +4,6 @@
  * exponential backoff and automatic disable on repeated failures.
  */
 import { toErrorMessage } from '../shared/error-utils.js';
-import { canDomainHandleTask } from './queen-task-management.js';
 // ============================================================================
 // Work stealing algorithm
 // ============================================================================
@@ -26,14 +25,18 @@ export async function triggerWorkStealing(ctx) {
             break;
         const queue = ctx.domainQueues.get(busyDomain) || [];
         const stealCount = Math.min(queue.length, ctx.config.workStealing.stealBatchSize);
-        for (let i = 0; i < stealCount && idleDomains.length > 0; i++) {
-            const task = queue.find(t => canDomainHandleTask(idleDomains[0], t));
+        // #1140: each steal takes a slot, so stop when none is free.
+        for (let i = 0; i < stealCount && idleDomains.length > 0 && ctx.availableSlots() > 0; i++) {
+            const task = queue.find(t => ctx.canExecuteInDomain(idleDomains[0], t));
             if (task) {
                 const stealerDomain = idleDomains.shift();
                 ctx.removeFromQueues(task);
+                // #1124: a task that is not running afterwards (already terminal, or
+                // failed at assignment) was not stolen.
+                if (!await ctx.assignTaskToDomain(task, stealerDomain))
+                    continue;
                 // SEC-003 Simplified: Log work stealing for observability
                 ctx.auditLogger.logSteal(task.id, busyDomain, stealerDomain);
-                await ctx.assignTaskToDomain(task, stealerDomain);
                 stolenCount++;
                 ctx.tasksStolen++;
                 await ctx.publishEvent('TaskStolen', {

package/dist/coordination/result-saver-adapters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * #1125 review: task_orchestrate and `aqe fleet run` now submit the domains'
+ * concrete handler types (sast-scan, analyze-quality) for the abstract types
+ * scan-security and assess-quality. These adapters map those handler results
+ * onto the report shapes ResultSaver already writes, so they are saved by the
+ * security and quality savers rather than as generic JSON. Nothing missing
+ * from a result is filled in: absent values stay absent.
+ */
+import type { TaskType } from './queen-types.js';
+/** The saver type and report for a task result; other types pass through. */
+export declare function resultForSaver(taskType: string, result: unknown): {
+    saveType: TaskType;
+    report: unknown;
+};
+//# sourceMappingURL=result-saver-adapters.d.ts.map

package/dist/coordination/result-saver-adapters.js

@@ -0,0 +1,57 @@
+const asRecord = (value) => value !== null && typeof value === 'object' ? value : {};
+/** sast-scan's SASTResult -> the scan-security report shape. */
+function securityReport(result) {
+    const data = asRecord(result);
+    const summary = asRecord(data.summary);
+    const findings = Array.isArray(data.vulnerabilities) ? data.vulnerabilities : [];
+    const count = (severity) => typeof summary[severity] === 'number' ? summary[severity] : 0;
+    return {
+        vulnerabilities: findings.length,
+        critical: count('critical'),
+        high: count('high'),
+        medium: count('medium'),
+        low: count('low'),
+        topVulnerabilities: findings.slice(0, 10).map(f => ({
+            type: f.title ?? f.category ?? 'finding',
+            severity: f.severity ?? 'unknown',
+            file: f.location?.file ?? '',
+            line: f.location?.line ?? 0,
+        })),
+        findings: findings.map(f => ({
+            title: f.title, type: f.category, severity: f.severity ?? 'unknown', location: f.location?.file
+                ? { file: f.location.file, line: f.location.line } : undefined, description: f.description,
+        })),
+        recommendations: [],
+        evidence: data.evidence,
+        coverage: data.coverage,
+        analysisDepth: 'sast-patterns',
+    };
+}
+/** analyze-quality's analysis -> the assess-quality report shape. No gate runs. */
+function qualityReport(result) {
+    const data = asRecord(result);
+    const score = asRecord(data.score);
+    const metrics = Array.isArray(data.metrics) ? data.metrics : [];
+    const unmeasured = Array.isArray(data.unmeasured)
+        ? data.unmeasured.map(u => u.metric).filter((m) => !!m)
+        : [];
+    return {
+        ...(typeof score.overall === 'number' ? { qualityScore: score.overall } : {}),
+        passed: false,
+        gateEvaluated: false,
+        metrics: Object.fromEntries(metrics.filter(m => m.name && typeof m.value === 'number').map(m => [m.name, m.value])),
+        recommendations: Array.isArray(data.recommendations) ? data.recommendations : [],
+        unmeasured,
+        evidenceStatus: unmeasured.length > 0 ? 'insufficient-evidence' : 'measured',
+        scoreBasis: metrics.map(m => m.name).filter((m) => !!m),
+    };
+}
+/** The saver type and report for a task result; other types pass through. */
+export function resultForSaver(taskType, result) {
+    switch (taskType) {
+        case 'sast-scan': return { saveType: 'scan-security', report: securityReport(result) };
+        case 'analyze-quality': return { saveType: 'assess-quality', report: qualityReport(result) };
+        default: return { saveType: taskType, report: result };
+    }
+}
+//# sourceMappingURL=result-saver-adapters.js.map

package/dist/coordination/result-saver.d.ts

@@ -58,7 +58,7 @@ export declare class ResultSaver {
     /**
      * Save task result in appropriate format(s)
      */
-    save(taskId: string, taskType: TaskType, result: unknown, options?: SaveOptions): Promise<SavedResult>;
+    save(taskId: string, taskType: TaskType, taskResult: unknown, options?: SaveOptions): Promise<SavedResult>;
     private saveTestGeneration;
     private saveCoverage;
     private saveSecurityScan;