agentic-qe 3.15.9 → 3.15.11

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

@@ -14,37 +14,14 @@
  *   deleted. A pattern used or re-scored since it was selected is left active.
  * - The archive copy is read back before the active key is deleted, so a
  *   failed write never loses the pattern.
+ * The move is implemented in domains/learning-optimization/pattern-archive.ts.
  */
-import { LEARNING_NS, LEARNING_PATTERN_KEY_PREFIX, isActivePatternKey, } from '../../domains/learning-optimization/active-patterns.js';
+// The move itself lives with the patterns, so the merge path in
+// LearningCoordinatorService uses the same read-back rule (#1106).
+export { archiveSelectedPattern } from '../../domains/learning-optimization/pattern-archive.js';
 export function emptyArchiveCounts() {
     return { selected: 0, archived: 0, missing: 0, failed: 0 };
 }
-/**
- * Move one selected pattern to its archive key in the learning namespace.
- */
-export async function archiveSelectedPattern(memory, pattern, archivedAt = new Date()) {
-    const activeKey = `${LEARNING_PATTERN_KEY_PREFIX}${pattern.id}`;
-    if (!isActivePatternKey(activeKey))
-        return 'missing';
-    const current = await memory.get(activeKey, LEARNING_NS);
-    if (!current || current.id !== pattern.id || changedSinceSelection(current, pattern))
-        return 'missing';
-    const archiveKey = `${LEARNING_PATTERN_KEY_PREFIX}archived:${pattern.id}`;
-    await memory.set(archiveKey, { ...pattern, archivedAt }, { ...LEARNING_NS, persist: true });
-    const copy = await memory.get(archiveKey, LEARNING_NS);
-    if (!copy || copy.id !== pattern.id)
-        return 'failed';
-    await memory.delete(activeKey, LEARNING_NS);
-    return 'archived';
-}
-/** True when the stored record's scores or last use differ from the selected snapshot. */
-function changedSinceSelection(current, selected) {
-    const time = (value) => new Date(value).getTime();
-    return (!Object.is(current.usageCount, selected.usageCount) ||
-        !Object.is(current.confidence, selected.confidence) ||
-        !Object.is(current.successRate, selected.successRate) ||
-        !Object.is(time(current.lastUsedAt), time(selected.lastUsedAt)));
-}
 /** True when the pattern was created less than `graceDays` days ago. */
 export function isWithinRetentionGrace(pattern, graceDays, now = Date.now()) {
     if (graceDays <= 0)

package/dist/coordination/protocols/learning-consolidation.d.ts

@@ -9,6 +9,11 @@ import { Result, DomainName, DomainEvent } from '../../shared/types/index.js';
 import { EventBus, MemoryBackend } from '../../kernel/interfaces.js';
 import { type ArchiveCounts } from './learning-consolidation-archive.js';
 import type { LearnedPattern, PatternType, IPatternLearningService, IKnowledgeSynthesisService } from '../../domains/learning-optimization/interfaces.js';
+/**
+ * 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 declare const DRY_RUN_MERGE_ID_PREFIX = "dry-run-merge:";
 export interface LearningConsolidationConfig {
     /** Minimum patterns per domain to trigger consolidation */
     minPatternsForConsolidation: number;
@@ -115,10 +120,24 @@ export interface TransferablePattern {
     transferConfidence: number;
     reason: string;
 }
+/** One step of a run that did not complete (#1106). */
+export interface ConsolidationError {
+    /** Domain the step ran for; absent for run-wide steps. */
+    domain?: DomainName;
+    step: 'consolidate' | 'merge' | 'archive' | 'knowledge-update' | 'transfer';
+    error: string;
+}
 export interface ConsolidationResult {
     consolidationId: string;
     /** True when nothing was merged, archived or written (#1071). */
     dryRun: boolean;
+    /**
+     * #1106: `completed` only when every step of every domain succeeded;
+     * `partial` when some failed (see `errors`). When every domain fails,
+     * `execute()` returns an error instead of a result.
+     */
+    status: 'completed' | 'partial';
+    errors: ConsolidationError[];
     startedAt: Date;
     completedAt: Date;
     stats: ConsolidationStats;
@@ -134,6 +153,11 @@ export interface DomainConsolidationReport {
     removedPatterns: RemovedPatternInfo[];
     /** Outcome of archiving `removedPatterns` (all zero but `selected` in a dry run). */
     archiveCounts: ArchiveCounts;
+    /** #1106: merges that failed; their source patterns were left active and kept. */
+    mergeFailures: Array<{
+        sourcePatternIds: string[];
+        error: string;
+    }>;
     topPerformingPatterns: LearnedPattern[];
     improvementAreas: string[];
 }

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

@@ -51,8 +51,8 @@ import { DEFAULT_QUEEN_CONFIG, getTaskDomains, initializeTaskDomainMap, } from '
 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 { findDomainsWithoutHandler, resolveTaskDomains, describeMissingHandler } from './task-executability.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
@@ -296,9 +296,9 @@ export class QueenCoordinator {
      * accept the type unchanged.
      */
     validateTaskExecutable(type, targetDomains = []) {
-        const candidates = targetDomains.length > 0 ? targetDomains : getTaskDomains(type);
+        const candidates = resolveTaskDomains(type, targetDomains, this.domainPlugins);
         if (candidates.length === 0) {
-            return err(new Error(`Unknown task type '${type}': no domain is configured for it. Pass a target domain.`));
+            return err(new Error(`Unknown task type '${type}': no domain is configured for it and no loaded domain handles it. Pass a target domain.`));
         }
         if (!this.domainPlugins)
             return ok(undefined);
@@ -314,6 +314,11 @@ export class QueenCoordinator {
         const taskId = `task_${uuidv4()}`;
         const task = {
             ...taskInput,
+            // #1170: a plugin task type with no configured domain (e.g. sast-scan)
+            // runs in the domains that handle it, so routing and queueing see them.
+            targetDomains: getTaskDomains(taskInput.type).length > 0
+                ? taskInput.targetDomains
+                : [...resolveTaskDomains(taskInput.type, taskInput.targetDomains, this.domainPlugins)],
             id: taskId,
             createdAt: new Date(),
             timeout: taskInput.timeout || this.config.defaultTaskTimeout,
@@ -358,7 +363,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 +375,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 +484,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 +542,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 +859,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 +876,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