agentic-qe 3.15.8 → 3.15.10

package/dist/domains/learning-optimization/coordinator.js

@@ -3,7 +3,9 @@
  * Orchestrates learning workflows across all QE domains
  */
 import { LoggerFactory } from '../../logging/index.js';
-import { readActivePatterns } from './active-patterns.js';
+import { readActivePatterns, LEARNING_NS } from './active-patterns.js';
+import { partitionByRewardSource } from './reward-source.js';
+import { searchAllKeys } from '../../shared/utils/namespaced-search.js';
 import { v4 as uuidv4 } from 'uuid';
 import { toError } from '../../shared/error-utils.js';
 import { rehydrateDates } from '../../shared/utils/kv-date-rehydrate.js';
@@ -19,7 +21,6 @@ import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 // CQ-004: Extracted modules
 import * as LearningHelpers from './coordinator-helpers.js';
 import * as ConsensusHelpers from './coordinator-consensus.js';
-import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 3,
     defaultTimeout: 120000, // 2 minutes
@@ -200,7 +201,10 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             // Get experiences from the last cycle
             const timeRange = TimeRange.lastNDays(1);
             const experiencesResult = await this.getExperiencesForDomain(domain, timeRange);
-            const experiences = experiencesResult.success ? experiencesResult.value : [];
+            // #1109: the reported `before` value and the optimizer use measured outcomes only.
+            const experiences = experiencesResult.success
+                ? partitionByRewardSource(experiencesResult.value).measured
+                : [];
             this.updateWorkflowProgress(workflowId, 20);
             // Mine experiences for patterns
             const insightsResult = await this.learningService.mineExperiences(domain, timeRange);
@@ -221,12 +225,19 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 const optimizationResult = await this.optimizerService.optimizeStrategy(currentStrategy, objective, experiences);
                 if (optimizationResult.success) {
                     strategiesOptimized = 1;
-                    improvements.push({
-                        metric: objective.metric,
-                        before: this.calculateMetricValue(experiences, objective.metric),
-                        after: optimizationResult.value.optimizedStrategy.expectedOutcome[objective.metric] || 0,
-                        percentChange: optimizationResult.value.improvement * 100,
-                    });
+                    // #1099: `after` is the fitted expectation and `percentChange` the
+                    // optimizer's estimate; neither was observed. Report no improvement
+                    // rather than a 0 stand-in when the metric was never predicted.
+                    const after = optimizationResult.value.optimizedStrategy.expectedOutcome[objective.metric];
+                    if (typeof after === 'number') {
+                        improvements.push({
+                            metric: objective.metric,
+                            before: this.calculateMetricValue(experiences, objective.metric),
+                            after,
+                            percentChange: optimizationResult.value.improvement * 100,
+                            estimated: true,
+                        });
+                    }
                 }
             }
             this.updateWorkflowProgress(workflowId, 80);
@@ -319,6 +330,7 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 domainsOptimized,
                 totalStrategies,
                 avgImprovement: totalStrategies > 0 ? totalImprovement / totalStrategies : 0,
+                improvementEstimated: true,
                 byDomain,
             };
             // Publish event
@@ -400,7 +412,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             const report = {
                 knowledgeShared,
                 domainsUpdated,
-                transferSuccessRate: totalTransfers > 0 ? successfulTransfers / totalTransfers : 1,
+                // #1121: with no transfer attempted there is no rate, not 100%.
+                transferSuccessRate: totalTransfers > 0 ? successfulTransfers / totalTransfers : null,
                 newPatternsCreated,
             };
             // Publish event
@@ -448,10 +461,12 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             const recentMilestones = milestonesResult.success
                 ? milestonesResult.value
                 : [];
-            // Calculate overall learning rate
-            const overallLearningRate = patternStats
+            // Calculate overall learning rate. #1121: when pattern stats cannot be
+            // read, or no measured pattern exists, there is no rate to report; the
+            // former 0.5 fallback was an invented value.
+            const overallLearningRate = patternStats && patternStats.totalPatterns > 0
                 ? patternStats.avgSuccessRate * 0.6 + (patternStats.avgConfidence * 0.4)
-                : 0.5;
+                : null;
             // Determine top performing domains
             const topPerformingDomains = [];
             if (patternStats) {
@@ -743,19 +758,18 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             // Export patterns (#1055: active patterns only — creation provenance
             // and archives share the `learning:pattern:` prefix). One read covers
             // every target domain; the previous per-domain loop exported each
-            // pattern once per target domain.
-            const activePatterns = await readActivePatterns(this.memory, {
-                onTruncated: (scanned) => logger.warn('Pattern export key scan hit its cap; export may be incomplete', { scanned }),
-            });
+            // pattern once per target domain. #1071: every key is read, no cap.
+            const activePatterns = await readActivePatterns(this.memory, { retrieve: LEARNING_NS });
             for (const pattern of activePatterns) {
                 if (targetDomains.includes(pattern.domain)) {
                     patterns.push(pattern);
                 }
             }
             this.updateWorkflowProgress(workflowId, 30);
-            // Export knowledge
+            // Export knowledge. #1071: no result cap; queryKnowledge reads every
+            // shared item before filtering, so other domains cannot crowd these out.
             const knowledgeResult = await this.transferService.queryKnowledge({
-                limit: 1000,
+                limit: Number.POSITIVE_INFINITY,
             });
             if (knowledgeResult.success) {
                 for (const item of knowledgeResult.value) {
@@ -765,10 +779,13 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 }
             }
             this.updateWorkflowProgress(workflowId, 60);
-            // Export strategies
-            const strategyKeys = await this.memory.search(`learning:strategy:optimized:*`, 200);
+            // Export strategies from the namespace their writers use (#1071), every
+            // key, in key order.
+            const strategyKeys = await searchAllKeys(this.memory, 'learning:strategy:optimized:*', {
+                retrieve: LEARNING_NS,
+            });
             for (const key of strategyKeys) {
-                const strategy = await this.memory.get(key);
+                const strategy = await this.memory.get(key, LEARNING_NS);
                 if (strategy && targetDomains.includes(strategy.domain)) {
                     strategies.push(strategy);
                 }
@@ -811,7 +828,7 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             const conflicts = [];
             // Import patterns
             for (const pattern of modelExport.patterns) {
-                const existing = await this.memory.get(`learning:pattern:${pattern.id}`);
+                const existing = await this.memory.get(`learning:pattern:${pattern.id}`, { namespace: 'learning-optimization' });
                 if (existing) {
                     if (existing.confidence < pattern.confidence) {
                         // Overwrite with better pattern
@@ -847,7 +864,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             }
             // Import knowledge
             for (const item of modelExport.knowledge) {
-                const existing = await this.memory.get(`learning:knowledge:shared:${item.id}`);
+                // #1071: compare against the record in the namespace written below.
+                const existing = await this.memory.get(`learning:knowledge:shared:${item.id}`, LEARNING_NS);
                 if (existing) {
                     if (item.version > existing.version) {
                         await this.memory.set(`learning:knowledge:shared:${item.id}`, item, {
@@ -882,7 +900,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             }
             // Import strategies
             for (const strategy of modelExport.strategies) {
-                const existing = await this.memory.get(`learning:strategy:optimized:${strategy.id}`);
+                // #1071: compare against the record in the namespace written below.
+                const existing = await this.memory.get(`learning:strategy:optimized:${strategy.id}`, LEARNING_NS);
                 if (existing) {
                     if (strategy.confidence > existing.confidence) {
                         await this.memory.set(`learning:strategy:optimized:${strategy.id}`, strategy, { namespace: 'learning-optimization', persist: true });
@@ -928,87 +947,13 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
     // Event Handling
     // ============================================================================
     subscribeToEvents() {
-        // Subscribe to test execution events for learning
-        this.eventBus.subscribe('test-execution.TestRunCompleted', this.handleTestRunCompleted.bind(this));
-        // Subscribe to coverage gap events
-        this.eventBus.subscribe('coverage-analysis.CoverageGapDetected', this.handleCoverageGap.bind(this));
-        // Subscribe to quality assessment events
-        this.eventBus.subscribe('quality-assessment.QualityGateEvaluated', this.handleQualityGate.bind(this));
+        // #1110: TestRunCompleted, CoverageGapDetected and QualityGateEvaluated are
+        // recorded by LearningOptimizationPlugin, which owns this coordinator and
+        // also records the test-run production metric. Subscribing here as well
+        // stored every such event twice.
         // Subscribe to experience capture events (Phase 4 integration)
         this.eventBus.subscribe('learning.ExperienceCaptured', this.handleExperienceCaptured.bind(this));
     }
-    async handleTestRunCompleted(event) {
-        // Record experience from test run
-        const { runId, passed, failed, duration } = event.payload;
-        const successRate = (passed + failed) > 0 ? passed / (passed + failed) : 0;
-        await this.learningService.recordExperience({
-            agentId: {
-                value: 'test-execution',
-                domain: 'test-execution',
-                type: 'tester',
-            },
-            domain: 'test-execution',
-            action: 'test-run',
-            state: {
-                context: { runId },
-                metrics: { passed, failed, duration },
-            },
-            result: {
-                success: successRate > 0.8,
-                outcome: { success_rate: successRate, passed, failed },
-                duration,
-            },
-            reward: successRate,
-        });
-    }
-    async handleCoverageGap(event) {
-        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
-        if (!isMeasuredGapPayload(event.payload))
-            return;
-        // Record as experience for learning
-        const { gapId, file, riskScore } = event.payload;
-        await this.learningService.recordExperience({
-            agentId: {
-                value: 'coverage-analysis',
-                domain: 'coverage-analysis',
-                type: 'analyzer',
-            },
-            domain: 'coverage-analysis',
-            action: 'gap-detection',
-            state: {
-                context: { gapId, file },
-                metrics: { riskScore },
-            },
-            result: {
-                success: true,
-                outcome: { risk_score: riskScore },
-                duration: 0,
-            },
-            reward: 1 - riskScore, // Lower risk = higher reward
-        });
-    }
-    async handleQualityGate(event) {
-        const { gateId, passed } = event.payload;
-        await this.learningService.recordExperience({
-            agentId: {
-                value: 'quality-assessment',
-                domain: 'quality-assessment',
-                type: 'validator',
-            },
-            domain: 'quality-assessment',
-            action: 'gate-evaluation',
-            state: {
-                context: { gateId },
-                metrics: { passed: passed ? 1 : 0 },
-            },
-            result: {
-                success: passed,
-                outcome: { gate_passed: passed ? 1 : 0 },
-                duration: 0,
-            },
-            reward: passed ? 1 : 0,
-        });
-    }
     /**
      * Handle experience captured from ExperienceCaptureService
      * This is the bridge between Phase 4 experience capture and the coordinator
@@ -1120,7 +1065,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             sourceProject: 'current',
             targetProject: 'current',
             patternsTransferred: report.knowledgeShared,
-            successRate: report.transferSuccessRate,
+            // Published only after a transfer succeeded, so the rate is measured.
+            successRate: report.transferSuccessRate ?? 0,
         };
         const event = createEvent(LearningOptimizationEvents.TransferCompleted, 'learning-optimization', payload);
         await this.eventBus.publish(event);
@@ -1232,9 +1178,8 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 retryCount: 3,
                 concurrency: 4,
             },
-            expectedOutcome: {
-                success_rate: 0.8,
-            },
+            // #1099: the default strategy has never run, so no outcome is expected.
+            expectedOutcome: {},
         };
     }
     async storeStrategy(domain, strategy) {

package/dist/domains/learning-optimization/index.d.ts

@@ -10,5 +10,5 @@ export { LearningCoordinatorService, type LearningCoordinatorConfig as LearningS
 export { TransferSpecialistService, type TransferSpecialistConfig, type TransferResult, } from './services/transfer-specialist.js';
 export { MetricsOptimizerService, type MetricsOptimizerConfig, type MetricsSnapshot, } from './services/metrics-optimizer.js';
 export { ProductionIntelService, type ProductionIntelConfig, type ProductionMetric, type ProductionIncident, type ProductionHealth, } from './services/production-intel.js';
-export type { ILearningOptimizationCoordinator, LearningCycleReport, OptimizationReport, CrossDomainSharingReport, LearningDashboard, ModelExport, ImportReport, ImportConflict, Improvement, DomainOptimizationResult, TrendPoint, Milestone, LearnedPattern, PatternType, PatternContext, PatternTemplate, TemplateVariable, PatternStats, IPatternLearningService, Experience, ExperienceResult, StateSnapshot, ResourceUsage, MinedInsights, ExperienceCluster, ExperienceAnomaly, IExperienceMiningService, Knowledge, KnowledgeType, KnowledgeContent, KnowledgeQuery, IKnowledgeSynthesisService, Strategy, OptimizedStrategy, OptimizationObjective, Constraint, ValidationResult, ABTestConfig, ABTestResult, StrategyEvaluation, IStrategyOptimizerService, IPatternRepository, IExperienceRepository, IKnowledgeRepository, IStrategyRepository, PatternLearnedEvent, KnowledgeSharedEvent, StrategyOptimizedEvent, ExperienceRecordedEvent, LearningMilestoneReachedEvent, } from './interfaces.js';
+export type { ILearningOptimizationCoordinator, LearningCycleReport, OptimizationReport, CrossDomainSharingReport, LearningDashboard, ModelExport, ImportReport, ImportConflict, Improvement, DomainOptimizationResult, TrendPoint, Milestone, LearnedPattern, PatternType, PatternContext, PatternTemplate, TemplateVariable, PatternStats, IPatternLearningService, Experience, ExperienceResult, StateSnapshot, ResourceUsage, MinedInsights, ExperienceCluster, ExperienceAnomaly, IExperienceMiningService, Knowledge, KnowledgeType, KnowledgeContent, KnowledgeQuery, IKnowledgeSynthesisService, Strategy, OptimizedStrategy, OptimizationEvaluation, OptimizationObjective, Constraint, ValidationResult, ABTestConfig, ABTestResult, StrategyEvaluation, IStrategyOptimizerService, IPatternRepository, IExperienceRepository, IKnowledgeRepository, IStrategyRepository, PatternLearnedEvent, KnowledgeSharedEvent, StrategyOptimizedEvent, ExperienceRecordedEvent, LearningMilestoneReachedEvent, } from './interfaces.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/domains/learning-optimization/interfaces.d.ts

@@ -23,6 +23,11 @@ export interface LearnedPattern {
     readonly template: PatternTemplate;
     readonly createdAt: Date;
     readonly lastUsedAt: Date;
+    /**
+     * #1109: 'assigned' when the pattern's rates were learned from assigned
+     * rewards. Untagged patterns are read by `patternRewardSourceOf`.
+     */
+    readonly rewardSource?: 'measured' | 'assigned';
 }
 export type PatternType = 'test-pattern' | 'fix-pattern' | 'optimization-pattern' | 'detection-pattern' | 'workflow-pattern' | 'failure-pattern';
 export interface PatternContext {
@@ -63,6 +68,13 @@ export interface Experience {
      * when real matched-pattern data exists, never a placeholder.
      */
     readonly appliedPatternIds?: readonly string[];
+    /**
+     * #1109: whether `result.success` and `reward` come from an observed
+     * outcome ('measured') or were assigned by the recorder before any outcome
+     * existed ('assigned'). Assigned experiences are kept but excluded from
+     * every reported rate. Untagged rows are read by `rewardSourceOf`.
+     */
+    readonly rewardSource?: 'measured' | 'assigned';
 }
 export interface StateSnapshot {
     readonly context: Record<string, unknown>;
@@ -110,9 +122,25 @@ export interface OptimizedStrategy {
     readonly objective: OptimizationObjective;
     readonly currentStrategy: Strategy;
     readonly optimizedStrategy: Strategy;
+    /** Relative improvement; an estimate, see `evaluation.estimated` (#1099). */
     readonly improvement: number;
+    /** Share of held-out experiences matching the fitted expectation. */
     readonly confidence: number;
     readonly validationResults: ValidationResult[];
+    readonly evaluation?: OptimizationEvaluation;
+}
+/**
+ * How an optimization's figures were derived (#1099). The optimizer fits on
+ * the older experiences and validates on the most recent ones it never saw.
+ */
+export interface OptimizationEvaluation {
+    readonly method: 'held-out';
+    readonly trainingSamples: number;
+    readonly heldOutSamples: number;
+    /** Figures that were modelled, not observed: the optimized strategy never ran. */
+    readonly estimated: string[];
+    /** Figures that could not be computed from the experiences given. */
+    readonly unmeasured?: string[];
 }
 export interface OptimizationObjective {
     readonly metric: string;
@@ -205,6 +233,10 @@ export interface PatternStats {
     readonly avgConfidence: number;
     readonly avgSuccessRate: number;
     readonly topPatterns: LearnedPattern[];
+    /** #1109: patterns left out of every figure because they were learned from assigned rewards. */
+    readonly assignedPatternsExcluded?: number;
+    /** #1121: untagged patterns mined before #1120 (rate selected over successes); left out likewise. */
+    readonly legacyPatternsExcluded?: number;
 }
 /**
  * Experience Mining Service
@@ -233,9 +265,16 @@ export interface IExperienceMiningService {
     clusterExperiences(experiences: Experience[]): Promise<Result<ExperienceCluster[]>>;
 }
 export interface MinedInsights {
+    /** Every experience recorded in the range, measured or assigned. */
     readonly experienceCount: number;
-    readonly successRate: number;
-    readonly avgReward: number;
+    /** #1109: experiences with a measured outcome; the rates below use only these. */
+    readonly measuredExperienceCount?: number;
+    /** #1109: experiences left out of the rates because their reward was assigned. */
+    readonly assignedRewardsExcluded?: number;
+    /** Set when no measured experience exists; the rates are then null. */
+    readonly evidenceStatus?: 'insufficient-evidence';
+    readonly successRate: number | null;
+    readonly avgReward: number | null;
     readonly patterns: LearnedPattern[];
     readonly anomalies: ExperienceAnomaly[];
     readonly recommendations: string[];
@@ -245,7 +284,8 @@ export interface ExperienceCluster {
     readonly centroid: StateSnapshot;
     readonly experiences: Experience[];
     readonly commonActions: string[];
-    readonly avgReward: number;
+    /** Over members with a measured outcome; null when every member's reward was assigned. */
+    readonly avgReward: number | null;
 }
 export interface ExperienceAnomaly {
     readonly experienceId: string;
@@ -283,9 +323,15 @@ export interface ABTestConfig {
 }
 export interface ABTestResult {
     readonly winner: 'A' | 'B' | 'inconclusive';
+    /** Set when either strategy has fewer recorded samples than `minSamples`. */
+    readonly evidenceStatus?: 'insufficient-evidence';
+    readonly unmeasured?: string[];
     readonly strategyAMetrics: Record<string, number>;
     readonly strategyBMetrics: Record<string, number>;
-    readonly pValue: number;
+    /** Absent when there was not enough recorded evidence to test. */
+    readonly pValue?: number;
+    /** Why pValue is absent although both arms had enough samples. */
+    readonly pValueUnavailableReason?: 'zero-variance';
     readonly sampleSizeA: number;
     readonly sampleSizeB: number;
 }
@@ -295,6 +341,9 @@ export interface StrategyEvaluation {
     readonly strengths: string[];
     readonly weaknesses: string[];
     readonly improvementAreas: string[];
+    /** #1109: no measured experience was available, so no metric is reported. */
+    readonly evidenceStatus?: 'insufficient-evidence';
+    readonly assignedRewardsExcluded?: number;
 }
 /**
  * Knowledge Synthesis Service
@@ -419,26 +468,33 @@ export interface Improvement {
     readonly before: number;
     readonly after: number;
     readonly percentChange: number;
+    /** True when `after` and `percentChange` were modelled, not observed (#1099). */
+    readonly estimated?: boolean;
 }
 export interface OptimizationReport {
     readonly domainsOptimized: number;
     readonly totalStrategies: number;
+    /** Mean of the optimizers' estimated improvements (#1099). */
     readonly avgImprovement: number;
+    readonly improvementEstimated?: boolean;
     readonly byDomain: Record<DomainName, DomainOptimizationResult>;
 }
 export interface DomainOptimizationResult {
     readonly strategiesOptimized: number;
+    /** Estimated, see OptimizedStrategy.evaluation (#1099). */
     readonly avgImprovement: number;
     readonly bestStrategy: Strategy;
 }
 export interface CrossDomainSharingReport {
     readonly knowledgeShared: number;
     readonly domainsUpdated: DomainName[];
-    readonly transferSuccessRate: number;
+    /** Null when no transfer was attempted (#1121). */
+    readonly transferSuccessRate: number | null;
     readonly newPatternsCreated: number;
 }
 export interface LearningDashboard {
-    readonly overallLearningRate: number;
+    /** Null when pattern stats are unavailable or no measured pattern exists (#1121). */
+    readonly overallLearningRate: number | null;
     readonly totalPatterns: number;
     readonly totalKnowledge: number;
     readonly experiencesLast24h: number;

package/dist/domains/learning-optimization/pattern-archive.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Agentic QE v3 - Archiving one learned pattern (#1071, #1106)
+ *
+ * Archiving is a move inside the `learning-optimization` namespace:
+ *
+ *   learning:pattern:<id>  ->  learning:pattern:archived:<id>
+ *
+ * Both callers use it: the consolidation protocol's trim path (#1071) and the
+ * merge path in `LearningCoordinatorService.consolidatePatterns` (#1106).
+ *
+ * Safety rules:
+ * - Only the active key of the given pattern is deleted.
+ * - The active record must still be that pattern (same id, and the same scores
+ *   and last use) when the archive runs, or nothing is written or deleted.
+ * - The archive copy is read back before the active key is deleted, so a
+ *   failed or partial write never loses the pattern.
+ */
+import type { MemoryBackend } from '../../kernel/interfaces.js';
+import type { LearnedPattern } from './interfaces.js';
+export type ArchiveOutcome = 'archived' | 'missing' | 'failed';
+/**
+ * Write the archive copy of one pattern and read it back, without touching
+ * the active key. `copied` means the copy is verified and the active record
+ * is still the given pattern.
+ */
+export declare function copyPatternToArchive(memory: MemoryBackend, pattern: LearnedPattern, archivedAt?: Date): Promise<'copied' | Exclude<ArchiveOutcome, 'archived'>>;
+/** Remove the active key of a pattern whose archive copy was verified. */
+export declare function removeArchivedPattern(memory: MemoryBackend, pattern: LearnedPattern): Promise<void>;
+/** Move one pattern to its archive key in the learning namespace. */
+export declare function archiveSelectedPattern(memory: MemoryBackend, pattern: LearnedPattern, archivedAt?: Date): Promise<ArchiveOutcome>;
+//# sourceMappingURL=pattern-archive.d.ts.map

package/dist/domains/learning-optimization/pattern-archive.js

@@ -0,0 +1,56 @@
+/**
+ * Agentic QE v3 - Archiving one learned pattern (#1071, #1106)
+ *
+ * Archiving is a move inside the `learning-optimization` namespace:
+ *
+ *   learning:pattern:<id>  ->  learning:pattern:archived:<id>
+ *
+ * Both callers use it: the consolidation protocol's trim path (#1071) and the
+ * merge path in `LearningCoordinatorService.consolidatePatterns` (#1106).
+ *
+ * Safety rules:
+ * - Only the active key of the given pattern is deleted.
+ * - The active record must still be that pattern (same id, and the same scores
+ *   and last use) when the archive runs, or nothing is written or deleted.
+ * - The archive copy is read back before the active key is deleted, so a
+ *   failed or partial write never loses the pattern.
+ */
+import { LEARNING_NS, LEARNING_PATTERN_KEY_PREFIX, isActivePatternKey } from './active-patterns.js';
+/**
+ * Write the archive copy of one pattern and read it back, without touching
+ * the active key. `copied` means the copy is verified and the active record
+ * is still the given pattern.
+ */
+export async function copyPatternToArchive(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);
+    return copy && copy.id === pattern.id ? 'copied' : 'failed';
+}
+/** Remove the active key of a pattern whose archive copy was verified. */
+export async function removeArchivedPattern(memory, pattern) {
+    await memory.delete(`${LEARNING_PATTERN_KEY_PREFIX}${pattern.id}`, LEARNING_NS);
+}
+/** Move one pattern to its archive key in the learning namespace. */
+export async function archiveSelectedPattern(memory, pattern, archivedAt = new Date()) {
+    const copied = await copyPatternToArchive(memory, pattern, archivedAt);
+    if (copied !== 'copied')
+        return copied;
+    await removeArchivedPattern(memory, pattern);
+    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)));
+}
+//# sourceMappingURL=pattern-archive.js.map

package/dist/domains/learning-optimization/pattern-consolidation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agentic QE v3 - Building a consolidated pattern (#1106)
+ *
+ * Pure: no reads or writes. `LearningCoordinatorService.consolidatePatterns`
+ * stores what this returns, and the consolidation protocol's dry run uses it
+ * to predict the merged pattern, so a dry run selects the same trims as a
+ * real run.
+ */
+import type { LearnedPattern } from './interfaces.js';
+/** Merge similar patterns: best template, combined contexts, weighted scores. */
+export declare function buildConsolidatedPattern(patterns: readonly LearnedPattern[], id: string, now?: Date): LearnedPattern;
+//# sourceMappingURL=pattern-consolidation.d.ts.map

package/dist/domains/learning-optimization/pattern-consolidation.js

@@ -0,0 +1,41 @@
+/**
+ * Agentic QE v3 - Building a consolidated pattern (#1106)
+ *
+ * Pure: no reads or writes. `LearningCoordinatorService.consolidatePatterns`
+ * stores what this returns, and the consolidation protocol's dry run uses it
+ * to predict the merged pattern, so a dry run selects the same trims as a
+ * real run.
+ */
+import { isMeasuredPattern } from './reward-source.js';
+/** Usage-weighted mean of one score (equal weights when nothing was used). */
+function usageWeighted(patterns, score) {
+    const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
+    return patterns.reduce((sum, p) => sum + score(p) * (totalUsage > 0 ? p.usageCount / totalUsage : 1 / patterns.length), 0);
+}
+/** Merge similar patterns: best template, combined contexts, weighted scores. */
+export function buildConsolidatedPattern(patterns, id, now = new Date()) {
+    const bestPattern = patterns.reduce((best, current) => current.successRate > best.successRate ? current : best);
+    const mergedContext = {
+        language: bestPattern.context.language,
+        framework: bestPattern.context.framework,
+        testType: bestPattern.context.testType,
+        codeContext: bestPattern.context.codeContext,
+        tags: [...new Set(patterns.flatMap((p) => p.context.tags))],
+    };
+    return {
+        id,
+        type: bestPattern.type,
+        domain: bestPattern.domain,
+        name: `consolidated-${bestPattern.name}`,
+        description: `Consolidated from ${patterns.length} patterns`,
+        confidence: usageWeighted(patterns, (p) => p.confidence),
+        usageCount: patterns.reduce((sum, p) => sum + p.usageCount, 0),
+        successRate: usageWeighted(patterns, (p) => p.successRate),
+        context: mergedContext,
+        template: bestPattern.template,
+        createdAt: now,
+        lastUsedAt: now,
+        rewardSource: patterns.every(isMeasuredPattern) ? 'measured' : 'assigned',
+    };
+}
+//# sourceMappingURL=pattern-consolidation.js.map

package/dist/domains/learning-optimization/plugin.js

@@ -397,6 +397,8 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
                 duration: 0,
             },
             reward: 0.8,
+            // #1109: generation is recorded before any run, so no outcome exists yet.
+            rewardSource: 'assigned',
             // ADR-110: real matched-pattern IDs from test-generation/coordinator.ts's
             // GeneratedTests.patternsUsed. This event always represents a successful
             // generation, so nulls won't fire from here in practice — threaded for
@@ -435,6 +437,7 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
                 duration: payload.duration,
             },
             reward: successRate,
+            rewardSource: 'measured',
         });
         // Record production metric
         await this.productionIntel.recordMetric('test_success_rate', successRate, 'ratio', 'test-execution', ['automated']);
@@ -462,6 +465,8 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
                 duration: 0,
             },
             reward: 1 - payload.riskScore,
+            // #1109: finding a gap is not an observed success of the detection.
+            rewardSource: 'assigned',
         });
     }
     async handleQualityGate(event) {
@@ -484,6 +489,7 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
                 duration: 0,
             },
             reward: payload.passed ? 1 : 0,
+            rewardSource: 'measured',
         });
     }
     async handleDefectPredicted(event) {
@@ -505,7 +511,9 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
                 outcome: { probability: payload.probability },
                 duration: 0,
             },
-            reward: 0.7, // Predictions are valuable
+            reward: 0.7,
+            // #1109: the prediction has not been confirmed or refuted yet.
+            rewardSource: 'assigned',
         });
     }
     async handleImpactAnalysis(event) {
@@ -534,6 +542,8 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
                 duration: 0,
             },
             reward: 0.8,
+            // #1109: the analysis has no observed outcome to score.
+            rewardSource: 'assigned',
         });
     }
     // ============================================================================