agentic-qe 3.15.8 → 3.15.9

package/dist/coordination/index.d.ts

@@ -22,8 +22,8 @@ export { DomainTeamManager, createDomainTeamManager, DEFAULT_DOMAIN_TEAM_MANAGER
 export type { DomainTeamManagerConfig, DomainTeam, DomainTeamHealth, ScaleResult, RebalanceResult, } from './agent-teams/domain-team-manager';
 export { TierSelector, createTierSelector, ALL_USER_FACING_DOMAINS, CORE_PRIORITY_DOMAINS, DEFAULT_DOMAIN_AGENT_MAP, DEFAULT_TIER_CONFIGS, getDefaultTierConfig, validateTierConfig, FLEET_TIER_ORDER, } from './fleet-tiers';
 export type { FleetTier, TierConfig, TierSelectionContext, AgentAllocation, TierSelectionResult, TierSelectionRecord, TierSelectionStats, } from './fleet-tiers';
-export { TaskDAG, DAGScheduler, createTaskDAG, createDAGScheduler, } from './task-dag';
-export type { DAGTaskStatus, DAGTask, AddTaskInput, DAGStats, DAGEventType, DAGEvent, DAGSchedulerConfig, DAGEventHandler, } from './task-dag';
+export { TaskDAG, DAGScheduler, createTaskDAG, createDAGScheduler, PREREQUISITE_RECEIPT_SCHEMA, GraphRevisionConflictError, PrerequisiteWaiverError, } from './task-dag';
+export type { DAGTaskStatus, DAGTask, AddTaskInput, DAGStats, DAGEventType, DAGEvent, DAGSchedulerConfig, DAGEventHandler, PrerequisiteDisposition, PrerequisiteReceiptV1, PrerequisiteEdgeState, WaivePrerequisiteInput, WaiverPolicy, TaskDAGOptions, ObligationSummary, DAGProgress, } from './task-dag';
 export { DomainCircuitBreaker, DomainCircuitOpenError, DEFAULT_DOMAIN_BREAKER_CONFIG, DomainBreakerRegistry, DOMAIN_CRITICALITY_CONFIGS, DOMAIN_CRITICALITY, createDomainCircuitBreaker, createDomainBreakerRegistry, } from './circuit-breaker';
 export type { DomainBreakerState, DomainCircuitBreakerConfig, DomainBreakerStats, DomainBreakerEvent, DomainBreakerStateChangeHandler, DomainCriticalityConfig, DomainCriticalityLevel, DomainBreakerHealthSummary, } from './circuit-breaker';
 export { HypothesisManager, createHypothesisManager, DEFAULT_COMPETING_HYPOTHESES_CONFIG, } from './competing-hypotheses';

package/dist/coordination/index.js

@@ -72,7 +72,7 @@ export { TierSelector, createTierSelector, ALL_USER_FACING_DOMAINS, CORE_PRIORIT
 // ============================================================================
 // Task Dependency DAG (ADR-064: DAG-Based Task Scheduling)
 // ============================================================================
-export { TaskDAG, DAGScheduler, createTaskDAG, createDAGScheduler, } from './task-dag/index.js';
+export { TaskDAG, DAGScheduler, createTaskDAG, createDAGScheduler, PREREQUISITE_RECEIPT_SCHEMA, GraphRevisionConflictError, PrerequisiteWaiverError, } from './task-dag/index.js';
 // ============================================================================
 // Domain Circuit Breakers (ADR-064: Domain-Level Fault Isolation)
 // ============================================================================

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

@@ -0,0 +1,39 @@
+/**
+ * Agentic QE v3 - Learning consolidation: pattern archiving (#1071)
+ *
+ * The consolidation protocol archives patterns it selected for removal.
+ * Archiving is a move inside the `learning-optimization` namespace, where
+ * `LearningCoordinatorService` writes every learned pattern:
+ *
+ *   learning:pattern:<id>  ->  learning:pattern:archived:<id>
+ *
+ * Safety rules:
+ * - Only the active key of a pattern the protocol selected is deleted.
+ * - The active record must still be the selected pattern (same id, and the
+ *   same scores and last use) when the archive runs, or nothing is written or
+ *   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.
+ */
+import type { MemoryBackend } from '../../kernel/interfaces.js';
+import type { LearnedPattern } from '../../domains/learning-optimization/interfaces.js';
+export type ArchiveOutcome = 'archived' | 'missing' | 'failed';
+/** Counts of one consolidation run's archive step, for logs and results. */
+export interface ArchiveCounts {
+    /** Patterns the retention and trim rules selected for removal. */
+    selected: number;
+    /** Selected patterns moved to `:archived:` and removed from the active set. */
+    archived: number;
+    /** Selected patterns whose active record was gone or changed; left alone. */
+    missing: number;
+    /** Selected patterns whose archive copy could not be verified; left active. */
+    failed: number;
+}
+export declare function emptyArchiveCounts(): ArchiveCounts;
+/**
+ * Move one selected pattern to its archive key in the learning namespace.
+ */
+export declare function archiveSelectedPattern(memory: MemoryBackend, pattern: LearnedPattern, archivedAt?: Date): Promise<ArchiveOutcome>;
+/** True when the pattern was created less than `graceDays` days ago. */
+export declare function isWithinRetentionGrace(pattern: LearnedPattern, graceDays: number, now?: number): boolean;
+//# sourceMappingURL=learning-consolidation-archive.d.ts.map

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

@@ -0,0 +1,57 @@
+/**
+ * Agentic QE v3 - Learning consolidation: pattern archiving (#1071)
+ *
+ * The consolidation protocol archives patterns it selected for removal.
+ * Archiving is a move inside the `learning-optimization` namespace, where
+ * `LearningCoordinatorService` writes every learned pattern:
+ *
+ *   learning:pattern:<id>  ->  learning:pattern:archived:<id>
+ *
+ * Safety rules:
+ * - Only the active key of a pattern the protocol selected is deleted.
+ * - The active record must still be the selected pattern (same id, and the
+ *   same scores and last use) when the archive runs, or nothing is written or
+ *   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.
+ */
+import { LEARNING_NS, LEARNING_PATTERN_KEY_PREFIX, isActivePatternKey, } from '../../domains/learning-optimization/active-patterns.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)
+        return false;
+    const created = new Date(pattern.createdAt).getTime();
+    if (!Number.isFinite(created))
+        return false;
+    return now - created < graceDays * 24 * 60 * 60 * 1000;
+}
+//# sourceMappingURL=learning-consolidation-archive.js.map

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

@@ -7,6 +7,7 @@
  */
 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';
 export interface LearningConsolidationConfig {
     /** Minimum patterns per domain to trigger consolidation */
@@ -21,6 +22,18 @@ export interface LearningConsolidationConfig {
     analysisWindowWeeks: number;
     /** Enable cross-project transfer */
     enableCrossProjectTransfer: boolean;
+    /**
+     * Report what would be merged and archived without writing anything
+     * (#1071). On by default: the protocol reads the real learned patterns in
+     * `learning-optimization`, so archiving them is opt-in (`dryRun: false`).
+     */
+    dryRun: boolean;
+    /**
+     * Patterns created less than this many days ago are never archived by the
+     * retention or trim rules, so a new pattern gets time to build confidence
+     * and usage before it is judged (#1071).
+     */
+    retentionGraceDays: number;
 }
 export interface LearningConsolidationStartedEvent extends DomainEvent {
     readonly type: 'LearningConsolidationStarted';
@@ -39,6 +52,7 @@ export interface PatternConsolidatedEvent extends DomainEvent {
         patternsAfterCount: number;
         mergedPatternIds: string[];
         removedPatternIds: string[];
+        dryRun: boolean;
     };
 }
 export interface LearningConsolidationCompletedEvent extends DomainEvent {
@@ -48,6 +62,7 @@ export interface LearningConsolidationCompletedEvent extends DomainEvent {
         stats: ConsolidationStats;
         insights: WeeklyInsight[];
         duration: number;
+        dryRun: boolean;
     };
 }
 export interface TransferReadyEvent extends DomainEvent {
@@ -75,7 +90,10 @@ export interface ConsolidationStats {
     domainsProcessed: number;
     totalPatternsAnalyzed: number;
     patternsMerged: number;
+    /** Patterns selected for removal (in a dry run, the ones that would be). */
     patternsRemoved: number;
+    /** Selected patterns actually archived (always 0 in a dry run). */
+    patternsArchived: number;
     patternsRetained: number;
     knowledgeItemsUpdated: number;
     improvementOpportunities: number;
@@ -99,6 +117,8 @@ export interface TransferablePattern {
 }
 export interface ConsolidationResult {
     consolidationId: string;
+    /** True when nothing was merged, archived or written (#1071). */
+    dryRun: boolean;
     startedAt: Date;
     completedAt: Date;
     stats: ConsolidationStats;
@@ -112,10 +132,13 @@ export interface DomainConsolidationReport {
     patternsAfterCount: number;
     mergedPatterns: MergedPatternInfo[];
     removedPatterns: RemovedPatternInfo[];
+    /** Outcome of archiving `removedPatterns` (all zero but `selected` in a dry run). */
+    archiveCounts: ArchiveCounts;
     topPerformingPatterns: LearnedPattern[];
     improvementAreas: string[];
 }
 export interface MergedPatternInfo {
+    /** Id of the merged pattern; empty in a dry run, where nothing is merged. */
     resultPatternId: string;
     sourcePatternIds: string[];
     mergeReason: string;
@@ -148,7 +171,15 @@ export declare class LearningConsolidationProtocol {
      */
     gatherPatterns(): Promise<Result<DomainPatternGroup[]>>;
     /**
-     * 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.
+     */
+    private readActivePatterns;
+    /**
+     * Patterns of one domain created or used within the analysis window
      */
     private getPatternsForDomain;
     /**
@@ -183,10 +214,14 @@ export declare class LearningConsolidationProtocol {
      * Get reason for pattern removal
      */
     private getRemovalReason;
+    /** True while a pattern is too new for the retention and trim rules. */
+    private isInGracePeriod;
     /**
-     * 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.
      */
-    private archivePattern;
+    private archivePatterns;
     /**
      * Trim patterns to max allowed per domain
      */

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

@@ -9,7 +9,12 @@ 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';
+const logger = LoggerFactory.create('learning-consolidation-protocol');
 const DEFAULT_CONFIG = {
     minPatternsForConsolidation: 5,
     similarityThreshold: 0.85,
@@ -17,6 +22,8 @@ const DEFAULT_CONFIG = {
     minConfidenceThreshold: 0.5,
     analysisWindowWeeks: 4,
     enableCrossProjectTransfer: true,
+    dryRun: true,
+    retentionGraceDays: 7,
 };
 // ============================================================================
 // Learning Consolidation Protocol Implementation
@@ -62,20 +69,29 @@ export class LearningConsolidationProtocol {
             const domainReports = [];
             let totalMerged = 0;
             let totalRemoved = 0;
+            let totalArchived = 0;
             let totalRetained = 0;
+            const dryRun = this.config.dryRun;
             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;
                 }
             }
-            // 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);
+            // 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);
             // Step 5: Generate weekly insights
             const insights = await this.generateInsights(gatheredPatterns.value, domainReports);
             const completedAt = new Date();
@@ -85,6 +101,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 +111,20 @@ export class LearningConsolidationProtocol {
                     ? transferResult.value.length
                     : 0,
             };
+            logger.info('Learning consolidation finished', {
+                consolidationId,
+                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,
                 startedAt,
                 completedAt,
                 stats,
@@ -106,7 +133,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 +152,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 +167,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,10 +240,23 @@ 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)));
             for (const group of similarGroups) {
-                if (group.length >= 2) {
+                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) {
@@ -230,32 +280,34 @@ 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,
                 topPerformingPatterns: this.getTopPerformingPatterns(finalPatterns, 5),
                 improvementAreas: this.identifyImprovementAreas(domainGroup),
             };
@@ -379,17 +431,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 +463,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 +525,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 +764,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 +777,7 @@ export class LearningConsolidationProtocol {
                 patternsAfterCount,
                 mergedPatternIds,
                 removedPatternIds,
+                dryRun,
             },
         };
         await this.eventBus.publish(event);
@@ -722,6 +793,7 @@ export class LearningConsolidationProtocol {
                 stats,
                 insights,
                 duration,
+                dryRun: this.config.dryRun,
             },
         };
         await this.eventBus.publish(event);
@@ -761,15 +833,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;

package/dist/coordination/queen-coordinator.js

@@ -47,10 +47,11 @@ 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 { findDomainsWithoutHandler, describeMissingHandler } from './task-executability.js';
 import { enqueueTask, removeFromQueues, getQueuePosition, processQueue, listTasks as listTasksImpl, assignTask, assignTaskToDomain, } 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';
@@ -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'));

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

@@ -193,7 +193,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,