agentic-qe 3.15.9 → 3.15.10

package/dist/coordination/protocols/learning-consolidation.js

@@ -14,7 +14,29 @@ import { searchAllKeys } from '../../shared/utils/namespaced-search.js';
 import { LoggerFactory } from '../../logging/index.js';
 import { readActivePatterns, LEARNING_NS, } from '../../domains/learning-optimization/active-patterns.js';
 import { archiveSelectedPattern, emptyArchiveCounts, isWithinRetentionGrace, } from './learning-consolidation-archive.js';
+import { buildConsolidatedPattern } from '../../domains/learning-optimization/pattern-consolidation.js';
 const logger = LoggerFactory.create('learning-consolidation-protocol');
+/**
+ * Id of a merged pattern a dry run predicts but never stores (#1106). It only
+ * appears in `removedPatterns` when the predicted merge would itself be trimmed.
+ */
+export const DRY_RUN_MERGE_ID_PREFIX = 'dry-run-merge:';
+/** Failed steps inside one domain's report (#1106). */
+function domainStepErrors(report) {
+    const errors = report.mergeFailures.map((failure) => ({
+        domain: report.domain,
+        step: 'merge',
+        error: `${failure.sourcePatternIds.join(', ')}: ${failure.error}`,
+    }));
+    if (report.archiveCounts.failed > 0) {
+        errors.push({
+            domain: report.domain,
+            step: 'archive',
+            error: `${report.archiveCounts.failed} selected patterns could not be archived (archive copy not verified) and were left active`,
+        });
+    }
+    return errors;
+}
 const DEFAULT_CONFIG = {
     minPatternsForConsolidation: 5,
     similarityThreshold: 0.85,
@@ -72,16 +94,26 @@ export class LearningConsolidationProtocol {
             let totalArchived = 0;
             let totalRetained = 0;
             const dryRun = this.config.dryRun;
+            // #1106: a failed step is recorded, never swallowed.
+            const errors = [];
             for (const domainGroup of gatheredPatterns.value) {
                 const consolidationResult = await this.consolidatePatterns(consolidationId, domainGroup);
                 if (consolidationResult.success) {
-                    domainReports.push(consolidationResult.value);
-                    totalMerged += consolidationResult.value.mergedPatterns.length;
-                    totalRemoved += consolidationResult.value.removedPatterns.length;
-                    totalArchived += consolidationResult.value.archiveCounts.archived;
-                    totalRetained += consolidationResult.value.patternsAfterCount;
+                    const report = consolidationResult.value;
+                    domainReports.push(report);
+                    totalMerged += report.mergedPatterns.length;
+                    totalRemoved += report.removedPatterns.length;
+                    totalArchived += report.archiveCounts.archived;
+                    totalRetained += report.patternsAfterCount;
+                    errors.push(...domainStepErrors(report));
+                }
+                else {
+                    errors.push({ domain: domainGroup.domain, step: 'consolidate', error: consolidationResult.error.message });
                 }
             }
+            if (gatheredPatterns.value.length > 0 && domainReports.length === 0) {
+                return err(new Error(`Learning consolidation failed in every domain: ${errors.map((e) => `${e.domain}: ${e.error}`).join('; ')}`));
+            }
             // Step 3: Update knowledge base with consolidated patterns (writes, so
             // skipped in a dry run)
             const knowledgeUpdateResult = dryRun
@@ -92,6 +124,12 @@ export class LearningConsolidationProtocol {
             const transferResult = dryRun
                 ? ok([])
                 : await this.prepareTransfer(consolidationId, domainReports);
+            if (!knowledgeUpdateResult.success) {
+                errors.push({ step: 'knowledge-update', error: knowledgeUpdateResult.error.message });
+            }
+            if (!transferResult.success) {
+                errors.push({ step: 'transfer', error: transferResult.error.message });
+            }
             // Step 5: Generate weekly insights
             const insights = await this.generateInsights(gatheredPatterns.value, domainReports);
             const completedAt = new Date();
@@ -111,8 +149,13 @@ export class LearningConsolidationProtocol {
                     ? transferResult.value.length
                     : 0,
             };
+            const status = errors.length > 0 ? 'partial' : 'completed';
+            if (errors.length > 0) {
+                logger.warn('Learning consolidation finished with errors', { consolidationId, dryRun, errors });
+            }
             logger.info('Learning consolidation finished', {
                 consolidationId,
+                status,
                 dryRun,
                 analyzed: stats.totalPatternsAnalyzed,
                 merged: totalMerged,
@@ -125,6 +168,8 @@ export class LearningConsolidationProtocol {
             const result = {
                 consolidationId,
                 dryRun,
+                status,
+                errors,
                 startedAt,
                 completedAt,
                 stats,
@@ -246,26 +291,29 @@ export class LearningConsolidationProtocol {
             retainedPatterns.push(...patterns.filter((p) => this.isInGracePeriod(p)));
             // Group similar patterns for merging
             const similarGroups = this.groupSimilarPatterns(patterns.filter((p) => !this.isInGracePeriod(p)));
+            const mergeFailures = [];
+            const mergeReason = 'Similar pattern context and template';
             for (const group of similarGroups) {
-                if (group.length >= 2 && this.config.dryRun) {
-                    // Dry run: report the merge, keep every source pattern
-                    mergedPatterns.push({
-                        resultPatternId: '',
-                        sourcePatternIds: group.map((p) => p.id),
-                        mergeReason: 'Similar pattern context and template',
-                    });
-                    retainedPatterns.push(...group);
-                }
-                else if (group.length >= 2) {
-                    // Merge similar patterns
-                    const mergeResult = await this.mergePatternGroup(group);
-                    if (mergeResult.success) {
+                if (group.length >= 2) {
+                    const sourcePatternIds = group.map((p) => p.id);
+                    // #1106: both runs carry the same set into the trim step. A dry run
+                    // keeps the merged pattern the real run would store (built by the
+                    // same function, never written); a real run keeps the stored one, or
+                    // the sources themselves when the merge failed and left them active.
+                    const merged = this.config.dryRun
+                        ? ok(buildConsolidatedPattern(group, `${DRY_RUN_MERGE_ID_PREFIX}${sourcePatternIds.join('+')}`))
+                        : await this.mergePatternGroup(group);
+                    if (merged.success) {
                         mergedPatterns.push({
-                            resultPatternId: mergeResult.value.id,
-                            sourcePatternIds: group.map((p) => p.id),
-                            mergeReason: 'Similar pattern context and template',
+                            resultPatternId: this.config.dryRun ? '' : merged.value.id,
+                            sourcePatternIds,
+                            mergeReason,
                         });
-                        retainedPatterns.push(mergeResult.value);
+                        retainedPatterns.push(merged.value);
+                    }
+                    else {
+                        mergeFailures.push({ sourcePatternIds, error: merged.error.message });
+                        retainedPatterns.push(...group);
                     }
                 }
                 else {
@@ -308,6 +356,7 @@ export class LearningConsolidationProtocol {
                 mergedPatterns,
                 removedPatterns,
                 archiveCounts,
+                mergeFailures,
                 topPerformingPatterns: this.getTopPerformingPatterns(finalPatterns, 5),
                 improvementAreas: this.identifyImprovementAreas(domainGroup),
             };

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

@@ -113,7 +113,7 @@ export declare class QueenCoordinator implements 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;
     getMinCutBridge(): QueenMinCutBridge | null;

package/dist/coordination/queen-coordinator.js

@@ -52,7 +52,7 @@ export { DOMAIN_GROUPS, TASK_DOMAIN_MAP } from './queen-types.js';
 // Extracted modules
 import { subscribeToEvents, computeDomainHealthFromAgents } from './queen-event-handlers.js';
 import { findDomainsWithoutHandler, describeMissingHandler } from './task-executability.js';
-import { enqueueTask, removeFromQueues, getQueuePosition, processQueue, listTasks as listTasksImpl, assignTask, assignTaskToDomain, } from './queen-task-management.js';
+import { enqueueTask, removeFromQueues, getQueuePosition, processQueue, listTasks as listTasksImpl, assignTask, dispatchStolenTask, canDomainExecuteTask, } from './queen-task-management.js';
 import { triggerWorkStealing as triggerWorkStealingImpl, startWorkStealingTimer } from './queen-work-stealing.js';
 import { isMinCutAwarePlugin, injectMinCutBridgeIntoPlugins, loadState, saveState, startMetricsCollectionTimer, cleanupCompletedTasks as cleanupCompletedTasksImpl, getEnabledDomains, } from './queen-lifecycle.js';
 // Initialize TASK_DOMAIN_MAP entries that need ALL_DOMAINS
@@ -358,7 +358,11 @@ export class QueenCoordinator {
             // Assign task to domain
             const assignResult = await assignTask(this.createTaskContext(), task);
             if (!assignResult.success) {
-                this.runningTaskCounter--;
+                // A task the Queen already settled (refused by its plugin, or reported
+                // failed through onComplete) gave its slot back (#1140).
+                if (!this.tasks.has(taskId)) {
+                    this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
+                }
                 return assignResult;
             }
             this.tasksReceived++;
@@ -366,7 +370,8 @@ export class QueenCoordinator {
             return ok(taskId);
         }
         catch (error) {
-            this.runningTaskCounter--;
+            // The task's own slot may already be released when the throw comes later.
+            this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
             throw error;
         }
     }
@@ -474,7 +479,7 @@ export class QueenCoordinator {
     getAgentsByDomain(domain) {
         return this.agentCoordinator.listAgents({ domain });
     }
-    async requestAgentSpawn(domain, type, capabilities) {
+    async requestAgentSpawn(domain, type, capabilities, taskId) {
         if (!this.agentCoordinator.canSpawn()) {
             return err(new Error('Maximum concurrent agents reached (15)'));
         }
@@ -532,7 +537,10 @@ export class QueenCoordinator {
                     logger.warn(`Auto-team-wiring failed for ${result.value}`, { error: err });
                 }
             }
-            await this.publishEvent('AgentSpawned', { agentId: result.value, domain, type, capabilities });
+            // #1130: taskId marks an agent that lives only as long as its task.
+            await this.publishEvent('AgentSpawned', {
+                agentId: result.value, domain, type, capabilities, ...(taskId ? { taskId } : {}),
+            });
         }
         return result;
     }
@@ -846,7 +854,7 @@ export class QueenCoordinator {
             get traceCollector() { return self.traceCollector; },
             taskTraceContexts: self.taskTraceContexts,
             get coExecutionRepo() { return self.coExecutionRepo; },
-            requestAgentSpawn: (d, t, c) => self.requestAgentSpawn(d, t, c),
+            requestAgentSpawn: (d, t, c, id) => self.requestAgentSpawn(d, t, c, id),
             publishEvent: (t, p) => self.publishEvent(t, p),
             getDomainLoad: (d) => self.getDomainLoad(d),
             getDomainHealth: (d) => self.getDomainHealth(d),
@@ -863,8 +871,12 @@ export class QueenCoordinator {
             getIdleDomains: () => self.getIdleDomains(),
             getBusyDomains: () => self.getBusyDomains(),
             getDomainLoad: (d) => self.getDomainLoad(d),
+            // A queued entry can already be terminal (#1070); only a waiting task is stolen.
+            availableSlots: () => self.config.maxConcurrentTasks - self.runningTaskCounter,
+            canExecuteInDomain: (d, t) => (self.tasks.get(t.id)?.status ?? 'queued') === 'queued'
+                && canDomainExecuteTask(self.domainPlugins, d, t),
             removeFromQueues: (t) => removeFromQueues(self.taskQueue, self.domainQueues, t),
-            assignTaskToDomain: (t, d) => assignTaskToDomain(self.createTaskContext(), t, d).then(() => { }),
+            assignTaskToDomain: (t, d) => dispatchStolenTask(self.createTaskContext(), t, d),
             publishEvent: (t, p) => self.publishEvent(t, p),
         };
     }

package/dist/coordination/queen-event-handlers.js

@@ -50,6 +50,17 @@ async function handleDomainEvent(ctx, event) {
 // ============================================================================
 // Task completed handler
 // ============================================================================
+/**
+ * #1130: a caller-owned task finishes through these events, not through the
+ * plugin completion callback that stops a task's agents, so its agent stayed
+ * "running" after the task ended. A retried task spawns a new agent. Stopping
+ * an agent that is already stopped is a no-op.
+ */
+async function stopTaskAgents(ctx, execution) {
+    for (const agentId of execution.assignedAgents) {
+        await ctx.agentCoordinator.stop(agentId);
+    }
+}
 export async function handleTaskCompleted(ctx, event) {
     const { taskId, result } = event.payload;
     const cancelled = settleCancelledTask(ctx.tasks, taskId);
@@ -62,6 +73,7 @@ export async function handleTaskCompleted(ctx, event) {
     }
     const execution = ctx.tasks.get(taskId);
     if (execution) {
+        await stopTaskAgents(ctx, execution);
         // CC-002 FIX: Decrement the atomic counter when task completes
         if (execution.status === 'running' || execution.status === 'assigned') {
             ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
@@ -173,6 +185,7 @@ export async function handleTaskFailed(ctx, event) {
     }
     const execution = ctx.tasks.get(taskId);
     if (execution) {
+        await stopTaskAgents(ctx, execution);
         // CC-002 FIX: Decrement the atomic counter when task fails
         if (execution.status === 'running' || execution.status === 'assigned') {
             ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);

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,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