agentic-qe 3.15.9 → 3.15.10

package/dist/domains/defect-intelligence/services/defect-predictor.js

@@ -6,6 +6,7 @@
  * ADR-051: LLM enhancement for AI-powered defect risk analysis
  */
 import { v4 as uuidv4 } from 'uuid';
+import { prunePredictionHistory } from '../prediction-history.js';
 import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types/index.js';
 import { GitAnalyzer } from '../../../shared/git/index.js';
@@ -54,6 +55,8 @@ const DEFAULT_FEATURES = [
  * ADR-051: Added LLM enhancement for AI-powered defect risk analysis
  */
 const logger = LoggerFactory.create('defect-intelligence/defect-predictor');
+const GIT_TIMEOUT_WARNING = 'Git history timed out for this file: change frequency, developer experience, code age and bug history ' +
+    'use their "no git data" defaults, so this prediction is incomplete.';
 export class DefectPredictorService {
     config;
     memory;
@@ -429,7 +432,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
     // ============================================================================
     async predictForFile(file, features, threshold) {
         // Extract file metrics
-        const fileMetrics = await this.extractFileMetrics(file);
+        const { metrics: fileMetrics, gitTimedOut } = await this.extractFileMetrics(file);
         // Calculate probability based on weighted features
         const featureContributions = [];
         let probability = 0;
@@ -448,33 +451,44 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         const riskLevel = this.probabilityToRisk(probability, threshold);
         // Generate recommendations based on high-contributing factors
         const recommendations = this.generateRecommendations(featureContributions, probability);
+        if (gitTimedOut)
+            recommendations.unshift(GIT_TIMEOUT_WARNING);
         return {
             file,
             probability,
             riskLevel,
             factors: featureContributions.filter((f) => f.contribution > 0.05),
             recommendations,
+            ...(gitTimedOut ? { warnings: [GIT_TIMEOUT_WARNING] } : {}),
         };
     }
     async extractFileMetrics(file) {
         // Try to get cached metrics
         const cachedMetrics = await this.memory.get(`${this.config.modelNamespace}:file-metrics:${file}`);
         if (cachedMetrics) {
-            return cachedMetrics;
+            return { metrics: cachedMetrics, gitTimedOut: false };
         }
         // Calculate metrics using real code analysis and git history
-        const metrics = {
+        const measure = async () => ({
             codeComplexity: await this.calculateComplexity(file),
             changeFrequency: await this.getChangeFrequency(file),
             developerExperience: await this.getDeveloperExperience(file),
             testCoverage: await this.getTestCoverage(file),
             codeAge: await this.getCodeAge(file),
             bugHistory: await this.getBugHistory(file),
-        };
-        // Cache metrics
-        await this.memory.set(`${this.config.modelNamespace}:file-metrics:${file}`, metrics, { namespace: 'defect-intelligence', ttl: 3600 } // 1 hour cache
-        );
-        return metrics;
+        });
+        // #1115: the git-based metrics of one file share one deadline.
+        const metrics = this.gitAnalyzer.withFileDeadline
+            ? await this.gitAnalyzer.withFileDeadline(file, measure)
+            : await measure();
+        // #1115: a git timeout left defaults in the git-based metrics; do not
+        // cache them as this file's measured metrics.
+        const gitTimedOut = this.gitAnalyzer.consumeTimeout?.(file) === true;
+        if (!gitTimedOut) {
+            await this.memory.set(`${this.config.modelNamespace}:file-metrics:${file}`, metrics, { namespace: 'defect-intelligence', ttl: 3600 } // 1 hour cache
+            );
+        }
+        return { metrics, gitTimedOut };
     }
     /**
      * Calculate code complexity using TypeScript AST analysis
@@ -730,7 +744,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         let risk = 0;
         // Determine impacted areas based on file path
         const area = this.categorizeFile(file);
-        const fileRisk = (await this.extractFileMetrics(file)).codeComplexity;
+        const fileRisk = (await this.extractFileMetrics(file)).metrics.codeComplexity;
         areas.push({
             area,
             files: [file],
@@ -742,7 +756,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         if (depth === 'deep') {
             const dependencies = await this.analyzeDependencies(file);
             for (const dep of dependencies) {
-                const depRisk = (await this.extractFileMetrics(dep)).codeComplexity * 0.5;
+                const depRisk = (await this.extractFileMetrics(dep)).metrics.codeComplexity * 0.5;
                 areas.push({
                     area: this.categorizeFile(dep),
                     files: [dep],
@@ -905,6 +919,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
             timestamp: new Date().toISOString(),
         }, { namespace: 'defect-intelligence', ttl: 86400 * 7 } // 7 days
         );
+        await prunePredictionHistory(this.memory, this.config.modelNamespace);
     }
     async recalculateMetrics(feedback) {
         // Simple online update of accuracy

package/dist/domains/enterprise-integration/services/message-broker-service.js

@@ -375,7 +375,8 @@ export class MessageBrokerService {
             // Check required properties
             if (schemaDef.required && Array.isArray(schemaDef.required) && typeof data === 'object' && data !== null) {
                 for (const prop of schemaDef.required) {
-                    if (!(prop in data)) {
+                    // #1136: own properties only; an inherited `constructor` is not present.
+                    if (!Object.hasOwn(data, prop)) {
                         errors.push(`Required property '${prop}' is missing`);
                     }
                 }
@@ -383,7 +384,7 @@ export class MessageBrokerService {
             // Check properties if defined
             if (schemaDef.properties && typeof data === 'object' && data !== null) {
                 for (const [prop, propSchema] of Object.entries(schemaDef.properties)) {
-                    if (prop in data) {
+                    if (Object.hasOwn(data, prop)) {
                         const propDef = propSchema;
                         if (propDef.type) {
                             const actualType = Array.isArray(data[prop]) ? 'array' : typeof data[prop];

package/dist/domains/enterprise-integration/services/odata-service.js

@@ -164,7 +164,8 @@ export class ODataService {
             const errors = [];
             // Validate required parameters
             for (const param of funcImport.parameters) {
-                if (!param.nullable && !(param.name in parameters)) {
+                // #1136: own properties only; an inherited `constructor` is not a parameter.
+                if (!param.nullable && !Object.hasOwn(parameters, param.name)) {
                     errors.push({
                         type: 'metadata',
                         path: `${functionName}/${param.name}`,

package/dist/domains/enterprise-integration/services/sap-integration-service.js

@@ -251,7 +251,8 @@ export class SapIntegrationService {
     validateExportParams(expectedParams, exportValues) {
         const errors = [];
         for (const param of expectedParams) {
-            if (!(param in exportValues)) {
+            // #1136: own properties only; an inherited `constructor` is not a parameter.
+            if (!Object.hasOwn(exportValues, param)) {
                 errors.push(`Expected export parameter '${param}' not found in response`);
             }
         }
@@ -260,7 +261,7 @@ export class SapIntegrationService {
     validateTableParams(expectedParams, tableData) {
         const errors = [];
         for (const param of expectedParams) {
-            if (!(param in tableData)) {
+            if (!Object.hasOwn(tableData, param)) {
                 errors.push(`Expected table parameter '${param}' not found in response`);
             }
         }

package/dist/domains/learning-optimization/active-patterns.d.ts

@@ -7,8 +7,8 @@
  * - `learning:pattern:creation:<id>`: creation provenance written by
  *   `LearningCoordinatorService.recordPatternCreation()` (no `context`)
  * - `learning:pattern:archived:<id>`: archived patterns written by
- *   `LearningCoordinatorService.archivePattern()` and the
- *   learning-consolidation protocol (full pattern shape)
+ *   `archiveSelectedPattern()` (pattern-archive.ts) for the merge path and
+ *   the learning-consolidation protocol (full pattern shape)
  *
  * Every reader of active patterns must go through this module so that
  * provenance and archives are excluded before `get()`, and so that those rows

package/dist/domains/learning-optimization/active-patterns.js

@@ -7,8 +7,8 @@
  * - `learning:pattern:creation:<id>`: creation provenance written by
  *   `LearningCoordinatorService.recordPatternCreation()` (no `context`)
  * - `learning:pattern:archived:<id>`: archived patterns written by
- *   `LearningCoordinatorService.archivePattern()` and the
- *   learning-consolidation protocol (full pattern shape)
+ *   `archiveSelectedPattern()` (pattern-archive.ts) for the merge path and
+ *   the learning-consolidation protocol (full pattern shape)
  *
  * Every reader of active patterns must go through this module so that
  * provenance and archives are excluded before `get()`, and so that those rows

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

@@ -412,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
@@ -460,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) {
@@ -1062,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);

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

@@ -235,6 +235,8 @@ export interface PatternStats {
     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
@@ -486,11 +488,13 @@ export interface DomainOptimizationResult {
 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/reward-source.d.ts

@@ -19,6 +19,8 @@
  * Patterns learned before the tag existed are read the same way: a pattern
  * whose template lists only actions from those handlers, in the handler's own
  * domain, was mined from assigned rewards (its 100% rate came from them).
+ * Every other untagged pattern predates #1120 and is not measured either
+ * (see patternEvidenceOf).
  */
 import type { Experience, LearnedPattern } from './interfaces.js';
 export type RewardSource = 'measured' | 'assigned';
@@ -32,6 +34,17 @@ export declare function partitionByRewardSource<T extends ProvenanceFields>(expe
 };
 type PatternProvenanceFields = Pick<LearnedPattern, 'domain' | 'template' | 'rewardSource'>;
 export declare function patternRewardSourceOf(pattern: PatternProvenanceFields): RewardSource;
+/**
+ * Where a stored pattern's success rate came from (#1121).
+ * - `measured` / `assigned`: tagged when the pattern was learned (#1109 on).
+ * - `pre-1120`: untagged and not mined from assigned rewards. Before #1120,
+ *   mining dropped failed runs from each action group, so the rate of every
+ *   untagged pattern started at 100% by selection, not by observation. Such
+ *   patterns are kept, never rewritten, and never reported as measured; the
+ *   next learn run mines a tagged replacement from the recorded outcomes.
+ */
+export type PatternEvidence = RewardSource | 'pre-1120';
+export declare function patternEvidenceOf(pattern: PatternProvenanceFields): PatternEvidence;
 export declare function isMeasuredPattern(pattern: PatternProvenanceFields): boolean;
 export {};
 //# sourceMappingURL=reward-source.d.ts.map

package/dist/domains/learning-optimization/reward-source.js

@@ -19,6 +19,8 @@
  * Patterns learned before the tag existed are read the same way: a pattern
  * whose template lists only actions from those handlers, in the handler's own
  * domain, was mined from assigned rewards (its 100% rate came from them).
+ * Every other untagged pattern predates #1120 and is not measured either
+ * (see patternEvidenceOf).
  */
 /** `agentId.value:action` pairs whose untagged rows carry an assigned reward. */
 const LEGACY_ASSIGNED = new Set([
@@ -52,7 +54,12 @@ export function patternRewardSourceOf(pattern) {
         && actions.every((action) => LEGACY_ASSIGNED.has(`${pattern.domain}:${action}`));
     return allAssigned ? 'assigned' : 'measured';
 }
+export function patternEvidenceOf(pattern) {
+    if (pattern.rewardSource)
+        return pattern.rewardSource;
+    return patternRewardSourceOf(pattern) === 'assigned' ? 'assigned' : 'pre-1120';
+}
 export function isMeasuredPattern(pattern) {
-    return patternRewardSourceOf(pattern) === 'measured';
+    return patternEvidenceOf(pattern) === 'measured';
 }
 //# sourceMappingURL=reward-source.js.map

package/dist/domains/learning-optimization/services/learning-coordinator.d.ts

@@ -155,6 +155,11 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
     private recordPatternNulls;
     /** Read recorded input without the pattern-mining side effects. */
     getExperiences(domain: DomainName, timeRange: TimeRange): Promise<Result<Experience[]>>;
+    /**
+     * Read recorded experiences by ID (#1121). IDs with no stored experience
+     * are skipped, so the result length is the number actually read.
+     */
+    getExperiencesByIds(ids: readonly string[]): Promise<Result<Experience[]>>;
     /** Mine experiences for insights. */
     mineExperiences(domain: DomainName, timeRange: TimeRange): Promise<Result<MinedInsights>>;
     /**
@@ -174,7 +179,6 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
      */
     clusterExperiences(experiences: Experience[]): Promise<Result<ExperienceCluster[]>>;
     private storePattern;
-    private archivePattern;
     private updatePatternUsage;
     private recordPatternCreation;
     private indexExperience;
@@ -187,8 +191,6 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
     private inferPatternType;
     private generatePatternTemplate;
     private extractPatternContext;
-    private calculateConsolidatedConfidence;
-    private calculateWeightedSuccessRate;
     private detectAnomalies;
     private calculateStdDev;
     private generateRecommendations;

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

@@ -8,7 +8,9 @@ import { ok, err } from '../../../shared/types/index.js';
 import { rehydrateDates } from '../../../shared/utils/kv-date-rehydrate.js';
 import { toError } from '../../../shared/error-utils.js';
 import { readActivePatterns } from '../active-patterns.js';
-import { isMeasuredPattern, partitionByRewardSource } from '../reward-source.js';
+import { isMeasuredPattern, partitionByRewardSource, patternEvidenceOf } from '../reward-source.js';
+import { copyPatternToArchive, removeArchivedPattern } from '../pattern-archive.js';
+import { buildConsolidatedPattern } from '../pattern-consolidation.js';
 import { createQEFlashAttention, } from '../../../integrations/ruvector/wrappers.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { createSafeRecord } from '../../../shared/utils/safe-record.js';
@@ -354,34 +356,28 @@ Provide:
                 return err(new Error('Not enough valid patterns found'));
             }
             // Merge patterns - take best template, combine contexts
-            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))],
-            };
-            const consolidatedPattern = {
-                id: uuidv4(),
-                type: bestPattern.type,
-                domain: bestPattern.domain,
-                name: `consolidated-${bestPattern.name}`,
-                description: `Consolidated from ${patterns.length} patterns`,
-                confidence: this.calculateConsolidatedConfidence(patterns),
-                usageCount: patterns.reduce((sum, p) => sum + p.usageCount, 0),
-                successRate: this.calculateWeightedSuccessRate(patterns),
-                context: mergedContext,
-                template: bestPattern.template,
-                createdAt: new Date(),
-                lastUsedAt: new Date(),
-                rewardSource: patterns.every(isMeasuredPattern) ? 'measured' : 'assigned',
-            };
-            // Store consolidated pattern
+            const consolidatedPattern = buildConsolidatedPattern(patterns, uuidv4());
+            // #1106: all or nothing. Every source pattern's archive copy is written
+            // and read back first; then the consolidated pattern is stored and read
+            // back; only then are the source patterns removed from the active set.
+            // If any step fails, no source pattern is deleted.
+            const archivedAt = new Date();
+            let notCopied = 0;
+            for (const pattern of patterns) {
+                if (await copyPatternToArchive(this.memory, pattern, archivedAt) !== 'copied')
+                    notCopied++;
+            }
+            if (notCopied > 0) {
+                return err(new Error(`${notCopied} of ${patterns.length} source patterns could not be archived (archive copy not verified); ` +
+                    'nothing was merged and every source pattern was left active'));
+            }
             await this.storePattern(consolidatedPattern);
-            // Archive old patterns
+            const stored = await this.memory.get(`learning:pattern:${consolidatedPattern.id}`, LEARNING_NS);
+            if (!stored || stored.id !== consolidatedPattern.id) {
+                return err(new Error('Consolidated pattern could not be read back; nothing was merged and every source pattern was left active'));
+            }
             for (const pattern of patterns) {
-                await this.archivePattern(pattern.id);
+                await removeArchivedPattern(this.memory, pattern);
             }
             return ok(consolidatedPattern);
         }
@@ -395,9 +391,10 @@ Provide:
     async getPatternStats(domain) {
         try {
             const inDomain = (await readActiveLearnedPatterns(this.memory)).filter((pattern) => !domain || pattern.domain === domain);
-            // #1109: every figure below describes patterns with measured rates only.
+            // #1109/#1121: every figure below describes patterns with measured rates only.
             const patterns = inDomain.filter(isMeasuredPattern);
-            const assignedPatternsExcluded = inDomain.length - patterns.length;
+            const legacyPatternsExcluded = inDomain.filter((p) => patternEvidenceOf(p) === 'pre-1120').length;
+            const assignedPatternsExcluded = inDomain.length - patterns.length - legacyPatternsExcluded;
             const byType = {
                 'test-pattern': 0,
                 'fix-pattern': 0,
@@ -441,6 +438,7 @@ Provide:
                 avgSuccessRate: patterns.length > 0 ? totalSuccessRate / patterns.length : 0,
                 topPatterns,
                 ...(assignedPatternsExcluded > 0 ? { assignedPatternsExcluded } : {}),
+                ...(legacyPatternsExcluded > 0 ? { legacyPatternsExcluded } : {}),
             });
         }
         catch (error) {
@@ -537,6 +535,24 @@ Provide:
             return err(toError(error));
         }
     }
+    /**
+     * Read recorded experiences by ID (#1121). IDs with no stored experience
+     * are skipped, so the result length is the number actually read.
+     */
+    async getExperiencesByIds(ids) {
+        try {
+            const experiences = [];
+            for (const id of new Set(ids)) {
+                const experience = await this.memory.get(`learning:experience:${id}`, LEARNING_NS);
+                if (experience)
+                    experiences.push(experience);
+            }
+            return ok(experiences);
+        }
+        catch (error) {
+            return err(toError(error));
+        }
+    }
     /** Mine experiences for insights. */
     async mineExperiences(domain, timeRange) {
         try {
@@ -695,17 +711,6 @@ Provide:
             persist: true,
         });
     }
-    async archivePattern(patternId) {
-        const key = `learning:pattern:${patternId}`;
-        const pattern = await this.memory.get(key, LEARNING_NS);
-        if (pattern) {
-            await this.memory.set(`learning:pattern:archived:${patternId}`, pattern, {
-                namespace: 'learning-optimization',
-                persist: true,
-            });
-            await this.memory.delete(key, LEARNING_NS);
-        }
-    }
     async updatePatternUsage(patternId) {
         const key = `learning:pattern:${patternId}`;
         const pattern = await this.memory.get(key, LEARNING_NS);
@@ -896,24 +901,6 @@ Provide:
             tags: Array.from(tags),
         };
     }
-    calculateConsolidatedConfidence(patterns) {
-        const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
-        let weightedConfidence = 0;
-        for (const pattern of patterns) {
-            const weight = totalUsage > 0 ? pattern.usageCount / totalUsage : 1 / patterns.length;
-            weightedConfidence += pattern.confidence * weight;
-        }
-        return weightedConfidence;
-    }
-    calculateWeightedSuccessRate(patterns) {
-        const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
-        let weightedRate = 0;
-        for (const pattern of patterns) {
-            const weight = totalUsage > 0 ? pattern.usageCount / totalUsage : 1 / patterns.length;
-            weightedRate += pattern.successRate * weight;
-        }
-        return weightedRate;
-    }
     detectAnomalies(experiences) {
         const anomalies = [];
         const avgReward = this.calculateAverageReward(experiences);