agentic-qe 3.15.8 → 3.15.9

package/dist/coordination/queen-lifecycle.js

@@ -40,6 +40,15 @@ export async function loadState(memory, tasks, enqueueTask) {
         if (state) {
             for (const [id, execution] of state.tasks) {
                 if (execution.status === 'queued') {
+                    if (execution.task.executionOwner === 'caller') {
+                        tasks.set(id, {
+                            ...execution,
+                            status: 'failed',
+                            error: 'Caller-owned task was interrupted before completion; submit a new request.',
+                            completedAt: new Date(),
+                        });
+                        continue;
+                    }
                     tasks.set(id, execution);
                     enqueueTask(execution.task);
                 }

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

@@ -3,11 +3,11 @@
  * Extracted from queen-coordinator.ts - Task assignment, domain routing,
  * TinyDancer integration, queue operations, and domain plugin execution.
  */
-import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../shared/types/index.js';
 import { binaryInsert, createdAtComparator } from '../shared/utils/index.js';
-import { TASK_DOMAIN_MAP } from './queen-types.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
 // ============================================================================
@@ -81,27 +81,71 @@ 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;
+    // #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;
 }
 // ============================================================================
 // Task filtering
@@ -142,7 +186,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 +210,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 +233,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) {
@@ -247,6 +301,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);
@@ -282,26 +340,41 @@ export async function assignTaskToDomain(ctx, task, domain) {
             }
             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) {
+    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);
+    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);
+}
 // ============================================================================
 // Task completion callback (from domain plugin)
 // ============================================================================
@@ -369,7 +442,7 @@ 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);
 }
 //# sourceMappingURL=queen-task-management.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;
@@ -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.

package/dist/coordination/task-dag/dag-algorithms.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agentic QE v3 - Task DAG Graph Algorithms
+ * ADR-064 Phase 1E: topological sort (Kahn), cycle detection (DFS
+ * coloring) and critical path (longest-path DP) over a TaskDAG's edges.
+ *
+ * Edges that point at IDs not present in `nodes` (missing or removed
+ * prerequisites) are ignored for ordering purposes.
+ */
+import type { DAGTask } from './types.js';
+/** Read-only view of the graph used by the algorithms */
+export interface DAGGraphView {
+    readonly nodes: ReadonlyMap<string, DAGTask>;
+    /** taskId -> prerequisite IDs */
+    readonly forwardEdges: ReadonlyMap<string, ReadonlySet<string>>;
+    /** prerequisiteId -> dependent IDs */
+    readonly reverseEdges: ReadonlyMap<string, ReadonlySet<string>>;
+}
+/**
+ * Topological sort using Kahn's algorithm.
+ * @throws Error if cycles exist
+ */
+export declare function topologicalSort(graph: DAGGraphView): DAGTask[];
+/**
+ * Detect cycles using DFS with white/gray/black coloring.
+ * @returns Array of cycles (empty if acyclic)
+ */
+export declare function findCycles(graph: DAGGraphView): string[][];
+/**
+ * Find the critical path (longest path through the DAG).
+ * @returns Tasks on the critical path in execution order
+ */
+export declare function criticalPath(graph: DAGGraphView): DAGTask[];
+//# sourceMappingURL=dag-algorithms.d.ts.map

package/dist/coordination/task-dag/dag-algorithms.js

@@ -0,0 +1,162 @@
+/**
+ * Agentic QE v3 - Task DAG Graph Algorithms
+ * ADR-064 Phase 1E: topological sort (Kahn), cycle detection (DFS
+ * coloring) and critical path (longest-path DP) over a TaskDAG's edges.
+ *
+ * Edges that point at IDs not present in `nodes` (missing or removed
+ * prerequisites) are ignored for ordering purposes.
+ */
+/** DFS node coloring for cycle detection */
+var NodeColor;
+(function (NodeColor) {
+    NodeColor[NodeColor["White"] = 0] = "White";
+    NodeColor[NodeColor["Gray"] = 1] = "Gray";
+    NodeColor[NodeColor["Black"] = 2] = "Black";
+})(NodeColor || (NodeColor = {}));
+/**
+ * Topological sort using Kahn's algorithm.
+ * @throws Error if cycles exist
+ */
+export function topologicalSort(graph) {
+    const { nodes, forwardEdges, reverseEdges } = graph;
+    const inDegree = new Map();
+    for (const nodeId of nodes.keys()) {
+        let count = 0;
+        const fwd = forwardEdges.get(nodeId);
+        if (fwd) {
+            for (const dep of fwd) {
+                if (nodes.has(dep))
+                    count++;
+            }
+        }
+        inDegree.set(nodeId, count);
+    }
+    const queue = [];
+    for (const [id, deg] of inDegree) {
+        if (deg === 0)
+            queue.push(id);
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        const task = nodes.get(nodeId);
+        if (task)
+            sorted.push(task);
+        const dependents = reverseEdges.get(nodeId);
+        if (dependents) {
+            for (const depId of dependents) {
+                if (!nodes.has(depId))
+                    continue;
+                const newDeg = (inDegree.get(depId) ?? 0) - 1;
+                inDegree.set(depId, newDeg);
+                if (newDeg === 0)
+                    queue.push(depId);
+            }
+        }
+    }
+    if (sorted.length !== nodes.size) {
+        throw new Error(`Cycle detected: sorted ${sorted.length} of ${nodes.size} tasks`);
+    }
+    return sorted;
+}
+/**
+ * Detect cycles using DFS with white/gray/black coloring.
+ * @returns Array of cycles (empty if acyclic)
+ */
+export function findCycles(graph) {
+    const color = new Map();
+    const parent = new Map();
+    const cycles = [];
+    for (const id of graph.nodes.keys())
+        color.set(id, NodeColor.White);
+    for (const id of graph.nodes.keys()) {
+        if (color.get(id) === NodeColor.White) {
+            dfsCycles(graph, id, color, parent, cycles);
+        }
+    }
+    return cycles;
+}
+/**
+ * Find the critical path (longest path through the DAG).
+ * @returns Tasks on the critical path in execution order
+ */
+export function criticalPath(graph) {
+    const { nodes, reverseEdges } = graph;
+    if (nodes.size === 0)
+        return [];
+    let sorted;
+    try {
+        sorted = topologicalSort(graph);
+    }
+    catch {
+        return [];
+    }
+    const dist = new Map();
+    const pred = new Map();
+    for (const t of sorted) {
+        dist.set(t.id, 1);
+        pred.set(t.id, null);
+    }
+    for (const task of sorted) {
+        const d = dist.get(task.id);
+        const deps = reverseEdges.get(task.id);
+        if (deps) {
+            for (const depId of deps) {
+                if (!nodes.has(depId))
+                    continue;
+                if (d + 1 > (dist.get(depId) ?? 1)) {
+                    dist.set(depId, d + 1);
+                    pred.set(depId, task.id);
+                }
+            }
+        }
+    }
+    let maxDist = 0;
+    let endNode = null;
+    for (const [id, d] of dist) {
+        if (d > maxDist) {
+            maxDist = d;
+            endNode = id;
+        }
+    }
+    if (!endNode)
+        return [];
+    const path = [];
+    let cur = endNode;
+    while (cur !== null) {
+        const t = nodes.get(cur);
+        if (t)
+            path.unshift(t);
+        cur = pred.get(cur) ?? null;
+    }
+    return path;
+}
+function dfsCycles(graph, nodeId, color, parent, cycles) {
+    color.set(nodeId, NodeColor.Gray);
+    const dependencies = graph.forwardEdges.get(nodeId);
+    if (dependencies) {
+        for (const depId of dependencies) {
+            if (!graph.nodes.has(depId))
+                continue;
+            const c = color.get(depId);
+            if (c === NodeColor.White) {
+                parent.set(depId, nodeId);
+                dfsCycles(graph, depId, color, parent, cycles);
+            }
+            else if (c === NodeColor.Gray) {
+                const cycle = [depId, nodeId];
+                let cur = nodeId;
+                while (cur !== depId) {
+                    const p = parent.get(cur);
+                    if (p === null || p === undefined || p === depId)
+                        break;
+                    cycle.push(p);
+                    cur = p;
+                }
+                cycles.push(cycle);
+            }
+        }
+    }
+    color.set(nodeId, NodeColor.Black);
+}
+//# sourceMappingURL=dag-algorithms.js.map

package/dist/coordination/task-dag/dag-obligations.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Agentic QE v3 - Task DAG Obligation Helpers
+ * Issue #1069: pure helpers for initial edge dispositions, waiver
+ * authorization and status counting, kept out of dag.ts for size.
+ */
+import type { DAGStats, DAGTask, PrerequisiteDisposition, WaivePrerequisiteInput, WaiverPolicy } from './types.js';
+import { type PrerequisiteLedger } from './prerequisite-ledger.js';
+/** Disposition of a new edge given the prerequisite's current state. */
+export declare function initialDisposition(blocker: DAGTask | undefined, tombstoned: boolean): PrerequisiteDisposition;
+/**
+ * Check that a validated waiver may be applied: the revision guard holds,
+ * the dependent exists and is not terminal, the edge exists and is
+ * unresolved, and the optional policy approves.
+ * @throws PrerequisiteWaiverError or GraphRevisionConflictError
+ */
+export declare function authorizeWaiver(ledger: PrerequisiteLedger, policy: WaiverPolicy | undefined, req: WaivePrerequisiteInput, task: DAGTask | undefined, prerequisites: ReadonlySet<string> | undefined): asserts task is DAGTask;
+type StatusCounts = Pick<DAGStats, 'pending' | 'ready' | 'inProgress' | 'completed' | 'failed' | 'blocked' | 'cancelled'>;
+/** Count tasks by execution status. */
+export declare function countStatuses(tasks: Iterable<DAGTask>): StatusCounts;
+export {};
+//# sourceMappingURL=dag-obligations.d.ts.map

package/dist/coordination/task-dag/dag-obligations.js

@@ -0,0 +1,83 @@
+/**
+ * Agentic QE v3 - Task DAG Obligation Helpers
+ * Issue #1069: pure helpers for initial edge dispositions, waiver
+ * authorization and status counting, kept out of dag.ts for size.
+ */
+import { PrerequisiteWaiverError, TERMINAL_STATUSES, } from './prerequisite-ledger.js';
+/** Disposition of a new edge given the prerequisite's current state. */
+export function initialDisposition(blocker, tombstoned) {
+    if (!blocker)
+        return tombstoned ? 'REMOVED' : 'MISSING';
+    switch (blocker.status) {
+        case 'completed': return 'SATISFIED';
+        case 'failed': return 'FAILED';
+        case 'cancelled': return 'CANCELLED';
+        default: return 'UNRESOLVED';
+    }
+}
+/**
+ * Check that a validated waiver may be applied: the revision guard holds,
+ * the dependent exists and is not terminal, the edge exists and is
+ * unresolved, and the optional policy approves.
+ * @throws PrerequisiteWaiverError or GraphRevisionConflictError
+ */
+export function authorizeWaiver(ledger, policy, req, task, prerequisites) {
+    ledger.checkRevision(req.expectedRevision);
+    if (!task)
+        throw new PrerequisiteWaiverError(`Task '${req.taskId}' not found in the DAG`);
+    if (!prerequisites?.has(req.prerequisiteId)) {
+        throw new PrerequisiteWaiverError(`Task '${req.taskId}' has no prerequisite '${req.prerequisiteId}'`);
+    }
+    if (TERMINAL_STATUSES.has(task.status)) {
+        throw new PrerequisiteWaiverError(`Cannot waive for '${req.taskId}': status '${task.status}' is terminal`);
+    }
+    const current = ledger.disposition(req.taskId, req.prerequisiteId) ?? 'UNRESOLVED';
+    if (current === 'SATISFIED' || current === 'WAIVED') {
+        throw new PrerequisiteWaiverError(`Prerequisite '${req.prerequisiteId}' of '${req.taskId}' is already ${current}`);
+    }
+    // Only a literal `true` approves; a truthy non-boolean (e.g. a Promise) fails closed
+    if (policy && policy({
+        graphId: ledger.graphId,
+        graphRevision: ledger.graphRevision,
+        taskId: req.taskId,
+        prerequisiteId: req.prerequisiteId,
+        actor: req.actor,
+        reason: req.reason,
+        authorityRef: req.authorityRef,
+        currentDisposition: current,
+    }) !== true) {
+        throw new PrerequisiteWaiverError(`Waiver of '${req.prerequisiteId}' for '${req.taskId}' by '${req.actor}' rejected by policy`);
+    }
+}
+/** Count tasks by execution status. */
+export function countStatuses(tasks) {
+    let pending = 0, ready = 0, inProgress = 0, completed = 0;
+    let failed = 0, blocked = 0, cancelled = 0;
+    for (const task of tasks) {
+        switch (task.status) {
+            case 'pending':
+                pending++;
+                break;
+            case 'ready':
+                ready++;
+                break;
+            case 'in_progress':
+                inProgress++;
+                break;
+            case 'completed':
+                completed++;
+                break;
+            case 'failed':
+                failed++;
+                break;
+            case 'blocked':
+                blocked++;
+                break;
+            case 'cancelled':
+                cancelled++;
+                break;
+        }
+    }
+    return { pending, ready, inProgress, completed, failed, blocked, cancelled };
+}
+//# sourceMappingURL=dag-obligations.js.map