agentic-qe 3.15.8 → 3.15.10

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

@@ -9,7 +9,34 @@ import { v4 as uuidv4 } from 'uuid';
 import { ok, err, ALL_DOMAINS, } from '../../shared/types/index.js';
 import { TimeRange } from '../../shared/value-objects/index.js';
 import { toError } from '../../shared/error-utils.js';
-import { readActivePatterns } from '../../domains/learning-optimization/active-patterns.js';
+import { rehydrateDates } from '../../shared/utils/kv-date-rehydrate.js';
+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,
@@ -17,6 +44,8 @@ const DEFAULT_CONFIG = {
     minConfidenceThreshold: 0.5,
     analysisWindowWeeks: 4,
     enableCrossProjectTransfer: true,
+    dryRun: true,
+    retentionGraceDays: 7,
 };
 // ============================================================================
 // Learning Consolidation Protocol Implementation
@@ -62,20 +91,45 @@ export class LearningConsolidationProtocol {
             const domainReports = [];
             let totalMerged = 0;
             let totalRemoved = 0;
+            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;
-                    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 });
                 }
             }
-            // Step 3: Update knowledge base with consolidated patterns
-            const knowledgeUpdateResult = await this.updateKnowledgeBase(domainReports);
-            // Step 4: Prepare patterns for cross-project transfer
-            const transferResult = await this.prepareTransfer(consolidationId, domainReports);
+            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
+                ? ok(0)
+                : await this.updateKnowledgeBase(domainReports);
+            // Step 4: Prepare patterns for cross-project transfer (a dry run does
+            // not announce transfers for patterns it did not consolidate)
+            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();
@@ -85,6 +139,7 @@ export class LearningConsolidationProtocol {
                 totalPatternsAnalyzed: gatheredPatterns.value.reduce((sum, g) => sum + g.patterns.length, 0),
                 patternsMerged: totalMerged,
                 patternsRemoved: totalRemoved,
+                patternsArchived: totalArchived,
                 patternsRetained: totalRetained,
                 knowledgeItemsUpdated: knowledgeUpdateResult.success
                     ? knowledgeUpdateResult.value
@@ -94,10 +149,27 @@ 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,
+                selectedForRemoval: totalRemoved,
+                archived: totalArchived,
+                retained: totalRetained,
+            });
             // Publish completion event
             await this.publishCompletedEvent(consolidationId, stats, insights, duration);
             const result = {
                 consolidationId,
+                dryRun,
+                status,
+                errors,
                 startedAt,
                 completedAt,
                 stats,
@@ -106,7 +178,9 @@ export class LearningConsolidationProtocol {
                 domainReports,
             };
             // Store result for historical analysis
-            await this.storeConsolidationResult(result);
+            if (!dryRun) {
+                await this.storeConsolidationResult(result);
+            }
             return ok(result);
         }
         catch (error) {
@@ -123,8 +197,9 @@ export class LearningConsolidationProtocol {
         try {
             const domainGroups = [];
             const timeRange = TimeRange.lastNDays(this.config.analysisWindowWeeks * 7);
+            const activePatterns = await this.readActivePatterns();
             for (const domain of ALL_DOMAINS) {
-                const patterns = await this.getPatternsForDomain(domain, timeRange);
+                const patterns = this.getPatternsForDomain(activePatterns, domain, timeRange);
                 if (patterns.length > 0) {
                     const stats = this.calculateDomainStats(patterns, timeRange);
                     domainGroups.push({ domain, patterns, stats });
@@ -137,12 +212,19 @@ export class LearningConsolidationProtocol {
         }
     }
     /**
-     * Get patterns for a specific domain
+     * Every active learned pattern, read once per run.
+     *
+     * #1055: active patterns only, excluding `:creation:` provenance and
+     * `:archived:` records. #1071: read from `learning-optimization`, where
+     * LearningCoordinatorService writes them, not the backend default.
+     */
+    readActivePatterns() {
+        return readActivePatterns(this.memory, { retrieve: LEARNING_NS });
+    }
+    /**
+     * Patterns of one domain created or used within the analysis window
      */
-    async getPatternsForDomain(domain, timeRange) {
-        // #1055: active patterns only — excludes `:creation:` provenance as well
-        // as `:archived:` records, before get() and before the scan cap applies.
-        const patterns = await readActivePatterns(this.memory);
+    getPatternsForDomain(patterns, domain, timeRange) {
         return patterns.filter((pattern) => pattern.domain === domain &&
             (timeRange.contains(pattern.createdAt) || timeRange.contains(pattern.lastUsedAt)));
     }
@@ -203,19 +285,35 @@ export class LearningConsolidationProtocol {
             const mergedPatterns = [];
             const removedPatterns = [];
             const retainedPatterns = [];
+            const toArchive = [];
+            // Patterns in their grace period are never merged either: a merge
+            // archives every source pattern (#1071).
+            retainedPatterns.push(...patterns.filter((p) => this.isInGracePeriod(p)));
             // Group similar patterns for merging
-            const similarGroups = this.groupSimilarPatterns(patterns);
+            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) {
-                    // Merge similar patterns
-                    const mergeResult = await this.mergePatternGroup(group);
-                    if (mergeResult.success) {
+                    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 {
@@ -230,32 +328,35 @@ export class LearningConsolidationProtocol {
                             name: pattern.name,
                             removalReason: this.getRemovalReason(pattern),
                         });
-                        await this.archivePattern(pattern);
+                        toArchive.push(pattern);
                     }
                 }
             }
-            // Trim to max patterns if needed
+            // Trim to max patterns if needed. Patterns in their grace period are
+            // never trimmed; they stay on top of the kept set.
             const finalPatterns = this.trimToMaxPatterns(retainedPatterns, domain);
-            const trimmedCount = retainedPatterns.length - finalPatterns.length;
-            if (trimmedCount > 0) {
-                const trimmed = retainedPatterns.slice(finalPatterns.length);
-                for (const p of trimmed) {
-                    removedPatterns.push({
-                        patternId: p.id,
-                        name: p.name,
-                        removalReason: 'Exceeded max patterns per domain limit',
-                    });
-                    await this.archivePattern(p);
-                }
+            const kept = new Set(finalPatterns.map((p) => p.id));
+            for (const p of retainedPatterns) {
+                if (kept.has(p.id))
+                    continue;
+                removedPatterns.push({
+                    patternId: p.id,
+                    name: p.name,
+                    removalReason: 'Exceeded max patterns per domain limit',
+                });
+                toArchive.push(p);
             }
+            const archiveCounts = await this.archivePatterns(domain, toArchive);
             // Publish domain consolidation event
-            await this.publishPatternConsolidatedEvent(consolidationId, domain, patterns.length, finalPatterns.length, mergedPatterns.map((m) => m.resultPatternId), removedPatterns.map((r) => r.patternId));
+            await this.publishPatternConsolidatedEvent(consolidationId, domain, patterns.length, finalPatterns.length, mergedPatterns.map((m) => m.resultPatternId), removedPatterns.map((r) => r.patternId), this.config.dryRun);
             const report = {
                 domain,
                 patternsBeforeCount: patterns.length,
                 patternsAfterCount: finalPatterns.length,
                 mergedPatterns,
                 removedPatterns,
+                archiveCounts,
+                mergeFailures,
                 topPerformingPatterns: this.getTopPerformingPatterns(finalPatterns, 5),
                 improvementAreas: this.identifyImprovementAreas(domainGroup),
             };
@@ -379,17 +480,30 @@ export class LearningConsolidationProtocol {
         }
         return 'Below retention threshold';
     }
+    /** True while a pattern is too new for the retention and trim rules. */
+    isInGracePeriod(pattern) {
+        return isWithinRetentionGrace(pattern, this.config.retentionGraceDays);
+    }
     /**
-     * Archive a pattern (soft delete)
+     * Archive the selected patterns (soft delete in `learning-optimization`,
+     * #1071). Only the selected patterns are touched, and a dry run touches
+     * none. Counts are logged per domain.
      */
-    async archivePattern(pattern) {
-        // Move to archived namespace
-        await this.memory.set(`learning:pattern:archived:${pattern.id}`, {
-            ...pattern,
-            archivedAt: new Date(),
-        }, { namespace: 'learning-optimization', persist: true });
-        // Delete from active patterns
-        await this.memory.delete(`learning:pattern:${pattern.id}`);
+    async archivePatterns(domain, selected) {
+        const counts = emptyArchiveCounts();
+        counts.selected = selected.length;
+        if (!this.config.dryRun) {
+            for (const pattern of selected) {
+                counts[await archiveSelectedPattern(this.memory, pattern)]++;
+            }
+        }
+        if (counts.selected > 0) {
+            logger.info('Learning consolidation archive step', { domain, dryRun: this.config.dryRun, ...counts });
+        }
+        if (counts.failed > 0) {
+            logger.warn('Some selected patterns could not be archived and were left active', { domain, failed: counts.failed });
+        }
+        return counts;
     }
     /**
      * Trim patterns to max allowed per domain
@@ -398,14 +512,18 @@ export class LearningConsolidationProtocol {
         if (patterns.length <= this.config.maxPatternsPerDomain) {
             return patterns;
         }
-        // Sort by effectiveness score and keep top N
-        return patterns
-            .sort((a, b) => {
-            const scoreA = a.confidence * 0.4 + a.successRate * 0.4 + Math.min(a.usageCount / 100, 0.2);
-            const scoreB = b.confidence * 0.4 + b.successRate * 0.4 + Math.min(b.usageCount / 100, 0.2);
-            return scoreB - scoreA;
-        })
-            .slice(0, this.config.maxPatternsPerDomain);
+        // Patterns in their grace period are always kept; the rest compete for
+        // the remaining places by effectiveness score.
+        const young = patterns.filter((p) => this.isInGracePeriod(p));
+        const eligible = patterns.filter((p) => !this.isInGracePeriod(p));
+        const places = Math.max(0, this.config.maxPatternsPerDomain - young.length);
+        return [...young, ...eligible
+                .sort((a, b) => {
+                const scoreA = a.confidence * 0.4 + a.successRate * 0.4 + Math.min(a.usageCount / 100, 0.2);
+                const scoreB = b.confidence * 0.4 + b.successRate * 0.4 + Math.min(b.usageCount / 100, 0.2);
+                return scoreB - scoreA;
+            })
+                .slice(0, places)];
     }
     /**
      * Get top performing patterns
@@ -456,7 +574,8 @@ export class LearningConsolidationProtocol {
                         updatedCount++;
                         // Share high-performing pattern knowledge with related domains
                         if (pattern.successRate >= 0.8) {
-                            const knowledge = await this.memory.get(`learning:knowledge:pattern:${pattern.id}`);
+                            // #1071: read where createKnowledgeFromPattern() writes it.
+                            const knowledge = await this.memory.get(`learning:knowledge:pattern:${pattern.id}`, LEARNING_NS);
                             if (knowledge) {
                                 // Use knowledgeService to share across domains
                                 await this.knowledgeService.shareKnowledge(knowledge, [
@@ -694,7 +813,7 @@ export class LearningConsolidationProtocol {
         };
         await this.eventBus.publish(event);
     }
-    async publishPatternConsolidatedEvent(consolidationId, domain, patternsBeforeCount, patternsAfterCount, mergedPatternIds, removedPatternIds) {
+    async publishPatternConsolidatedEvent(consolidationId, domain, patternsBeforeCount, patternsAfterCount, mergedPatternIds, removedPatternIds, dryRun) {
         const event = {
             id: uuidv4(),
             type: 'PatternConsolidated',
@@ -707,6 +826,7 @@ export class LearningConsolidationProtocol {
                 patternsAfterCount,
                 mergedPatternIds,
                 removedPatternIds,
+                dryRun,
             },
         };
         await this.eventBus.publish(event);
@@ -722,6 +842,7 @@ export class LearningConsolidationProtocol {
                 stats,
                 insights,
                 duration,
+                dryRun: this.config.dryRun,
             },
         };
         await this.eventBus.publish(event);
@@ -761,15 +882,21 @@ export class LearningConsolidationProtocol {
      * Get previous consolidation results for trend analysis
      */
     async getPreviousConsolidations(count) {
-        const keys = await this.memory.search('learning:consolidation:result:*', count);
+        // #1071: results are stored in `learning-optimization`. Read every one
+        // so the newest `count` are returned, not an arbitrary first page.
+        const keys = await searchAllKeys(this.memory, 'learning:consolidation:result:*', {
+            retrieve: LEARNING_NS,
+        });
         const results = [];
         for (const key of keys) {
-            const result = await this.memory.get(key);
+            const result = rehydrateDates(await this.memory.get(key, LEARNING_NS), ['startedAt', 'completedAt']);
             if (result) {
                 results.push(result);
             }
         }
-        return results.sort((a, b) => b.completedAt.getTime() - a.completedAt.getTime());
+        return results
+            .sort((a, b) => b.completedAt.getTime() - a.completedAt.getTime())
+            .slice(0, count);
     }
     /**
      * Get consolidation history summary

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

@@ -33,7 +33,7 @@ import { FederationMailbox } from './federation/index.js';
 import { DynamicScaler } from './dynamic-scaling/index.js';
 export type { QueenTask, TaskType, TaskExecution, DomainGroup, WorkStealingConfig, QueenMetrics, QueenConfig, QueenHealth, HealthIssue, IQueenCoordinator, TaskFilter, } from './queen-types.js';
 export { DOMAIN_GROUPS, TASK_DOMAIN_MAP } from './queen-types.js';
-import type { QueenTask, TaskExecution, QueenMetrics, QueenConfig, QueenHealth, IQueenCoordinator, TaskFilter } from './queen-types.js';
+import type { QueenTask, TaskType, TaskExecution, QueenMetrics, QueenConfig, QueenHealth, IQueenCoordinator, TaskFilter } from './queen-types.js';
 export declare class QueenCoordinator implements IQueenCoordinator {
     private readonly eventBus;
     private readonly agentCoordinator;
@@ -80,6 +80,17 @@ export declare class QueenCoordinator implements IQueenCoordinator {
     constructor(eventBus: EventBus, agentCoordinator: AgentCoordinator, memory: MemoryBackend, router: CrossDomainRouter, protocolExecutor?: ProtocolExecutor | undefined, workflowExecutor?: WorkflowExecutor | undefined, domainPlugins?: Map<DomainName, DomainPlugin> | undefined, config?: Partial<QueenConfig>);
     initialize(): Promise<void>;
     dispose(): Promise<void>;
+    /**
+     * #1075: check that a domain plugin will actually execute this task type
+     * before an external caller submits it, so the caller gets the reason as a
+     * rejection. A type that no candidate domain handles would otherwise only
+     * be failed at dispatch by `assignTaskToDomain` (#1081).
+     *
+     * Every candidate domain must handle the type, because `assignTask` may pick
+     * any of them. Queens built without domain plugins cannot be checked and
+     * accept the type unchanged.
+     */
+    validateTaskExecutable(type: TaskType, targetDomains?: readonly DomainName[]): Result<void, Error>;
     submitTask(taskInput: Omit<QueenTask, 'id' | 'createdAt'>): Promise<Result<string, Error>>;
     cancelTask(taskId: string): Promise<Result<void, Error>>;
     getTaskStatus(taskId: string): TaskExecution | undefined;
@@ -102,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

@@ -47,11 +47,12 @@ import { createHypothesisManager } from './competing-hypotheses/index.js';
 import { createFederationMailbox } from './federation/index.js';
 import { createDynamicScaler } from './dynamic-scaling/index.js';
 // Types, interfaces, constants, and config
-import { DEFAULT_QUEEN_CONFIG, initializeTaskDomainMap, } from './queen-types.js';
+import { DEFAULT_QUEEN_CONFIG, getTaskDomains, initializeTaskDomainMap, } from './queen-types.js';
 export { DOMAIN_GROUPS, TASK_DOMAIN_MAP } from './queen-types.js';
 // Extracted modules
 import { subscribeToEvents, computeDomainHealthFromAgents } from './queen-event-handlers.js';
-import { enqueueTask, removeFromQueues, getQueuePosition, processQueue, listTasks as listTasksImpl, assignTask, assignTaskToDomain, } from './queen-task-management.js';
+import { findDomainsWithoutHandler, 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
@@ -284,6 +285,28 @@ export class QueenCoordinator {
     // ============================================================================
     // Task Management
     // ============================================================================
+    /**
+     * #1075: check that a domain plugin will actually execute this task type
+     * before an external caller submits it, so the caller gets the reason as a
+     * rejection. A type that no candidate domain handles would otherwise only
+     * be failed at dispatch by `assignTaskToDomain` (#1081).
+     *
+     * Every candidate domain must handle the type, because `assignTask` may pick
+     * any of them. Queens built without domain plugins cannot be checked and
+     * accept the type unchanged.
+     */
+    validateTaskExecutable(type, targetDomains = []) {
+        const candidates = targetDomains.length > 0 ? targetDomains : getTaskDomains(type);
+        if (candidates.length === 0) {
+            return err(new Error(`Unknown task type '${type}': no domain is configured for it. Pass a target domain.`));
+        }
+        if (!this.domainPlugins)
+            return ok(undefined);
+        const gaps = findDomainsWithoutHandler(this.domainPlugins, type, candidates);
+        if (gaps.length === 0)
+            return ok(undefined);
+        return err(new Error(describeMissingHandler(type, gaps)));
+    }
     async submitTask(taskInput) {
         if (!this.initialized) {
             return err(new Error('Queen Coordinator not initialized'));
@@ -335,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++;
@@ -343,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;
         }
     }
@@ -451,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)'));
         }
@@ -509,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;
     }
@@ -823,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),
@@ -840,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);
@@ -193,7 +206,8 @@ export async function handleTaskFailed(ctx, event) {
         }
         // Check if we should retry. Caller-input errors are deterministic, so a
         // retry would fail the same way.
-        if (!callerError && execution.retryCount < ctx.config.taskRetryLimit) {
+        const callerOwned = execution.task.executionOwner === 'caller';
+        if (!callerError && !callerOwned && execution.retryCount < ctx.config.taskRetryLimit) {
             ctx.auditLogger.logFail(taskId, execution.assignedAgents[0], error);
             const retried = {
                 ...execution,

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);
                 }