agentic-qe 3.15.17 → 3.15.18

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

@@ -6,14 +6,14 @@
  * ADR-051: LLM enhancement for AI-powered defect risk analysis
  */
 import { v4 as uuidv4 } from 'uuid';
-import { prunePredictionHistory } from '../prediction-history.js';
+import { predictionTargetForFiles, 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';
 import { FileReader } from '../../../shared/io/index.js';
 import { findProjectRoot } from '../../../kernel/project-root.js';
 import { TypeScriptParser } from '../../../shared/parsers/index.js';
-import { toError } from '../../../shared/error-utils.js';
+import { toError, toErrorMessage } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { measuredFileCoverage } from '../../quality-assessment/coverage-report-event.js';
@@ -55,8 +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.';
+const GIT_TIMEOUT_WARNING = 'Git history timed out or was too large to read 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;
@@ -298,7 +298,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
                 }
             }
             // Store prediction for potential feedback
-            await this.storePrediction(predictions);
+            const retained = await this.storePrediction(predictions, files);
             // Update metrics
             this.modelMetrics.totalPredictions += predictions.length;
             this.modelMetrics.lastUpdated = new Date();
@@ -308,6 +308,7 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
                 factors: Array.from(factors),
                 // ADR-051: Include LLM analysis in result if available
                 llmAnalysis: llmAnalysis ?? undefined,
+                ...(retained ? {} : { retention: 'failed' }),
             });
         }
         catch (error) {
@@ -477,13 +478,17 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
             codeAge: await this.getCodeAge(file),
             bugHistory: await this.getBugHistory(file),
         });
-        // #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;
+        // cache them as this file's measured metrics. #1165: read the flag inside
+        // the deadline call, so another prediction on the same file cannot take it.
+        const measureOnce = async () => ({
+            metrics: await measure(),
+            gitTimedOut: this.gitAnalyzer.consumeTimeout?.(file) === true,
+        });
+        // #1115: the git-based metrics of one file share one deadline.
+        const { metrics, gitTimedOut } = this.gitAnalyzer.withFileDeadline
+            ? await this.gitAnalyzer.withFileDeadline(file, measureOnce)
+            : await measureOnce();
         if (!gitTimedOut) {
             await this.memory.set(`${this.config.modelNamespace}:file-metrics:${file}`, metrics, { namespace: 'defect-intelligence', ttl: 3600 } // 1 hour cache
             );
@@ -899,6 +904,11 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         // More predictions generally mean better confidence
         if (predictions.length > 10)
             confidence *= 1.05;
+        // #1165: git defaults stand in for most features of a prediction whose
+        // git history timed out; such predictions halve their share of confidence.
+        const incomplete = predictions.filter((p) => p.warnings?.includes(GIT_TIMEOUT_WARNING)).length;
+        if (predictions.length > 0)
+            confidence *= 1 - incomplete / predictions.length / 2;
         return Math.min(1, Math.max(0, confidence));
     }
     calculateVariance(values) {
@@ -908,15 +918,25 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         const squareDiffs = values.map((v) => Math.pow(v - mean, 2));
         return squareDiffs.reduce((a, b) => a + b, 0) / values.length;
     }
-    async storePrediction(predictions) {
+    /** Records the run; `false` when it was stored but older runs could not be pruned (#1137). */
+    async storePrediction(predictions, files) {
         const predictionId = uuidv4();
         await this.memory.set(`${this.config.modelNamespace}:prediction:${predictionId}`, {
             id: predictionId,
+            target: predictionTargetForFiles(files),
             predictions,
             timestamp: new Date().toISOString(),
         }, { namespace: 'defect-intelligence', ttl: 86400 * 7 } // 7 days
         );
-        await prunePredictionHistory(this.memory, this.config.modelNamespace);
+        try {
+            await prunePredictionHistory(this.memory, this.config.modelNamespace);
+            return true;
+        }
+        catch (error) {
+            // The run is stored; retention catches up on the next run or the TTL.
+            logger.warn('Defect prediction stored, but pruning older runs failed', { error: toErrorMessage(error) });
+            return false;
+        }
     }
     async recalculateMetrics(feedback) {
         // Simple online update of accuracy

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

@@ -5,6 +5,7 @@
 import { LoggerFactory } from '../../logging/index.js';
 import { readActivePatterns, LEARNING_NS } from './active-patterns.js';
 import { partitionByRewardSource } from './reward-source.js';
+import { measuredSuccessRate, rankTopPerformingDomains } from './domain-ranking.js';
 import { searchAllKeys } from '../../shared/utils/namespaced-search.js';
 import { v4 as uuidv4 } from 'uuid';
 import { toError } from '../../shared/error-utils.js';
@@ -362,6 +363,7 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             let knowledgeShared = 0;
             const domainsUpdated = [];
             let newPatternsCreated = 0;
+            const mergeFailures = [];
             let totalTransfers = 0;
             let successfulTransfers = 0;
             // Get all knowledge items
@@ -404,6 +406,12 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                             if (consolidateResult.success) {
                                 newPatternsCreated++;
                             }
+                            else {
+                                // #1149: a merge failure is reported, never dropped.
+                                const failure = { sourcePatternIds: group.map((p) => p.id), error: consolidateResult.error.message };
+                                mergeFailures.push(failure);
+                                logger.warn('Pattern merge failed during cross-domain sharing', failure);
+                            }
                         }
                     }
                 }
@@ -415,6 +423,7 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
                 // #1121: with no transfer attempted there is no rate, not 100%.
                 transferSuccessRate: totalTransfers > 0 ? successfulTransfers / totalTransfers : null,
                 newPatternsCreated,
+                ...(mergeFailures.length > 0 ? { mergeFailures } : {}),
             };
             // Publish event
             if (this.config.publishEvents && knowledgeShared > 0) {
@@ -447,10 +456,14 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             // Get experiences from last 24h
             const timeRange = TimeRange.lastNDays(1);
             let experiencesLast24h = 0;
+            const domainRates = [];
             for (const domain of ALL_DOMAINS) {
-                const expResult = await this.getExperiencesForDomain(domain, timeRange);
+                // #1147: read through the learning service, which reads the
+                // learning-optimization namespace the experiences are stored in.
+                const expResult = await this.learningService.getExperiences(domain, timeRange);
                 if (expResult.success) {
                     experiencesLast24h += expResult.value.length;
+                    domainRates.push({ domain, successRate: measuredSuccessRate(expResult.value) });
                 }
             }
             // Get production health for trends
@@ -467,15 +480,9 @@ export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
             const overallLearningRate = patternStats && patternStats.totalPatterns > 0
                 ? patternStats.avgSuccessRate * 0.6 + (patternStats.avgConfidence * 0.4)
                 : null;
-            // Determine top performing domains
-            const topPerformingDomains = [];
-            if (patternStats) {
-                const domainScores = Object.entries(patternStats.byDomain)
-                    .filter(([_, count]) => count > 0)
-                    .map(([domain, count]) => ({ domain: domain, score: count }))
-                    .sort((a, b) => b.score - a.score);
-                topPerformingDomains.push(...domainScores.slice(0, 3).map((d) => d.domain));
-            }
+            // #1147: rank by measured success over the same 24h, not by pattern
+            // count; a domain with no measured outcome or at 0% is left out.
+            const { topPerformingDomains } = rankTopPerformingDomains(domainRates);
             const dashboard = {
                 overallLearningRate,
                 totalPatterns: patternStats?.totalPatterns || 0,

package/dist/domains/learning-optimization/domain-ranking.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agentic QE v3 - Ranking domains by measured success (#1147)
+ *
+ * Pure: no reads or writes. Both learning dashboards (the MCP
+ * `qe/learning/optimize` tool and the domain coordinator) rank domains with
+ * this one rule:
+ * - a domain with no measured outcome has no rate and is left out;
+ * - a domain whose measured runs all failed (0%) is not top-performing;
+ * - the rest are ordered by measured success rate, highest first.
+ */
+import type { DomainName } from '../../shared/types/index.js';
+import type { Experience } from './interfaces.js';
+export interface DomainSuccessRate {
+    readonly domain: DomainName;
+    /** Measured success rate, or null when the domain has no measured outcome. */
+    readonly successRate: number | null;
+}
+export interface TopPerformingDomains {
+    readonly topPerformingDomains: DomainName[];
+    /** Domains with at least one measured outcome (ranked or not). */
+    readonly measuredDomains: number;
+}
+/** Measured success rate of a domain's experiences; null when none is measured. */
+export declare function measuredSuccessRate(experiences: readonly Experience[]): number | null;
+export declare function rankTopPerformingDomains(rates: readonly DomainSuccessRate[], limit?: number): TopPerformingDomains;
+//# sourceMappingURL=domain-ranking.d.ts.map

package/dist/domains/learning-optimization/domain-ranking.js

@@ -0,0 +1,28 @@
+/**
+ * Agentic QE v3 - Ranking domains by measured success (#1147)
+ *
+ * Pure: no reads or writes. Both learning dashboards (the MCP
+ * `qe/learning/optimize` tool and the domain coordinator) rank domains with
+ * this one rule:
+ * - a domain with no measured outcome has no rate and is left out;
+ * - a domain whose measured runs all failed (0%) is not top-performing;
+ * - the rest are ordered by measured success rate, highest first.
+ */
+import { partitionByRewardSource } from './reward-source.js';
+/** Measured success rate of a domain's experiences; null when none is measured. */
+export function measuredSuccessRate(experiences) {
+    const { measured } = partitionByRewardSource(experiences);
+    if (measured.length === 0)
+        return null;
+    return measured.filter((e) => e.result.success).length / measured.length;
+}
+export function rankTopPerformingDomains(rates, limit = 3) {
+    const measured = rates.filter((r) => r.successRate !== null);
+    const topPerformingDomains = measured
+        .filter((r) => r.successRate > 0)
+        .sort((a, b) => b.successRate - a.successRate)
+        .slice(0, limit)
+        .map((r) => r.domain);
+    return { topPerformingDomains, measuredDomains: measured.length };
+}
+//# sourceMappingURL=domain-ranking.js.map

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

@@ -493,6 +493,11 @@ export interface CrossDomainSharingReport {
     /** Null when no transfer was attempted (#1121). */
     readonly transferSuccessRate: number | null;
     readonly newPatternsCreated: number;
+    /** Pattern merges that failed; absent when none did (#1149). */
+    readonly mergeFailures?: ReadonlyArray<{
+        readonly sourcePatternIds: string[];
+        readonly error: string;
+    }>;
 }
 export interface LearningDashboard {
     /** Null when pattern stats are unavailable or no measured pattern exists (#1121). */

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

@@ -1,5 +1,5 @@
 /**
- * Agentic QE v3 - Archiving one learned pattern (#1071, #1106)
+ * Agentic QE v3 - Archiving one learned pattern (#1071, #1106, #1149)
  *
  * Archiving is a move inside the `learning-optimization` namespace:
  *
@@ -12,20 +12,67 @@
  * - 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.
+ * - The archive copy is the stored active record. It is read back and compared
+ *   in full before the active key is deleted, so a failed or partial write
+ *   never loses the pattern (#1149).
+ * - Compare-and-delete: the active key is deleted only while the active record
+ *   still equals the archive copy. An update made after the copy keeps the
+ *   pattern active (#1149).
+ * - A copy that is not followed by a delete is removed again, so no archive
+ *   row is left for a pattern that is still active (#1149).
+ * - Moves on one backend run one at a time (`withPatternMoveLock`), so two
+ *   merges of the same patterns cannot both succeed (#1149). The lock is
+ *   per process; the backend has no transactions to lock across processes.
  */
 import type { MemoryBackend } from '../../kernel/interfaces.js';
 import type { LearnedPattern } from './interfaces.js';
-export type ArchiveOutcome = 'archived' | 'missing' | 'failed';
+/**
+ * Outcome of one move:
+ * - `archived`: copied, verified, and removed from the active set
+ * - `missing`: the active record is gone; nothing was written
+ * - `changed`: the active record changed since it was selected, or during
+ *   the move; it stays active and no archive copy is kept
+ * - `failed`: the archive copy could not be verified; the pattern stays active
+ */
+export type ArchiveOutcome = 'archived' | 'missing' | 'changed' | 'failed';
+/**
+ * Outcome of removing the active key after a copy:
+ * - `removed`: the active record equalled the archive copy and was deleted
+ * - `missing`: the active record was already gone
+ * - `changed`: the active record changed after the copy; left active
+ * - `failed`: the archive copy is gone or no longer verifies; left active
+ */
+export type RemoveOutcome = 'removed' | 'missing' | 'changed' | 'failed';
+/**
+ * JSON with object keys sorted, so two records compare equal exactly when
+ * they store the same values. Dates serialize as ISO strings, as they do in
+ * the backend.
+ */
+export declare function canonicalJson(value: unknown): string;
 /**
  * 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.
+ * the active key. `copied` means the copy is verified in full and the active
+ * record is still the given pattern. On `failed` the unverified copy has been
+ * removed again.
  */
 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>;
+/**
+ * Compare-and-delete the active key of a pattern whose archive copy was
+ * verified: delete only while the active record still equals the copy.
+ */
+export declare function removeArchivedPattern(memory: MemoryBackend, pattern: LearnedPattern): Promise<RemoveOutcome>;
+/**
+ * Remove the archive copy of a pattern that is still active, after a move
+ * that did not complete. The copy is kept when the active record is gone, so
+ * a pattern is never left without either record.
+ */
+export declare function discardArchiveCopy(memory: MemoryBackend, pattern: LearnedPattern): Promise<boolean>;
 /** Move one pattern to its archive key in the learning namespace. */
 export declare function archiveSelectedPattern(memory: MemoryBackend, pattern: LearnedPattern, archivedAt?: Date): Promise<ArchiveOutcome>;
+/**
+ * Run `fn` after every earlier pattern move on the same backend has settled.
+ * Not re-entrant: `fn` must not call `withPatternMoveLock` (or
+ * `archiveSelectedPattern`) on the same backend.
+ */
+export declare function withPatternMoveLock<T>(memory: MemoryBackend, fn: () => Promise<T>): Promise<T>;
 //# sourceMappingURL=pattern-archive.d.ts.map

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

@@ -1,5 +1,5 @@
 /**
- * Agentic QE v3 - Archiving one learned pattern (#1071, #1106)
+ * Agentic QE v3 - Archiving one learned pattern (#1071, #1106, #1149)
  *
  * Archiving is a move inside the `learning-optimization` namespace:
  *
@@ -12,38 +12,111 @@
  * - 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.
+ * - The archive copy is the stored active record. It is read back and compared
+ *   in full before the active key is deleted, so a failed or partial write
+ *   never loses the pattern (#1149).
+ * - Compare-and-delete: the active key is deleted only while the active record
+ *   still equals the archive copy. An update made after the copy keeps the
+ *   pattern active (#1149).
+ * - A copy that is not followed by a delete is removed again, so no archive
+ *   row is left for a pattern that is still active (#1149).
+ * - Moves on one backend run one at a time (`withPatternMoveLock`), so two
+ *   merges of the same patterns cannot both succeed (#1149). The lock is
+ *   per process; the backend has no transactions to lock across processes.
  */
 import { LEARNING_NS, LEARNING_PATTERN_KEY_PREFIX, isActivePatternKey } from './active-patterns.js';
+const activeKeyOf = (id) => `${LEARNING_PATTERN_KEY_PREFIX}${id}`;
+const archiveKeyOf = (id) => `${LEARNING_PATTERN_KEY_PREFIX}archived:${id}`;
+/**
+ * JSON with object keys sorted, so two records compare equal exactly when
+ * they store the same values. Dates serialize as ISO strings, as they do in
+ * the backend.
+ */
+export function canonicalJson(value) {
+    return JSON.stringify(value, (_key, v) => v && typeof v === 'object' && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+        : v);
+}
+/** The archive copy without its `archivedAt` stamp, i.e. the record that was archived. */
+function archivedRecord(copy) {
+    const { archivedAt: _archivedAt, ...record } = copy;
+    return record;
+}
 /**
  * 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.
+ * the active key. `copied` means the copy is verified in full and the active
+ * record is still the given pattern. On `failed` the unverified copy has been
+ * removed again.
  */
 export async function copyPatternToArchive(memory, pattern, archivedAt = new Date()) {
-    const activeKey = `${LEARNING_PATTERN_KEY_PREFIX}${pattern.id}`;
+    const activeKey = activeKeyOf(pattern.id);
     if (!isActivePatternKey(activeKey))
         return 'missing';
     const current = await memory.get(activeKey, LEARNING_NS);
-    if (!current || current.id !== pattern.id || changedSinceSelection(current, pattern))
+    if (!current || current.id !== pattern.id)
         return 'missing';
-    const archiveKey = `${LEARNING_PATTERN_KEY_PREFIX}archived:${pattern.id}`;
-    await memory.set(archiveKey, { ...pattern, archivedAt }, { ...LEARNING_NS, persist: true });
+    if (changedSinceSelection(current, pattern))
+        return 'changed';
+    const archiveKey = archiveKeyOf(pattern.id);
+    const expected = { ...current, archivedAt };
+    await memory.set(archiveKey, expected, { ...LEARNING_NS, persist: true });
     const copy = await memory.get(archiveKey, LEARNING_NS);
-    return copy && copy.id === pattern.id ? 'copied' : 'failed';
+    if (copy && canonicalJson(copy) === canonicalJson(expected))
+        return 'copied';
+    await discardArchiveCopy(memory, pattern);
+    return 'failed';
 }
-/** Remove the active key of a pattern whose archive copy was verified. */
+/**
+ * Compare-and-delete the active key of a pattern whose archive copy was
+ * verified: delete only while the active record still equals the copy.
+ */
 export async function removeArchivedPattern(memory, pattern) {
-    await memory.delete(`${LEARNING_PATTERN_KEY_PREFIX}${pattern.id}`, LEARNING_NS);
+    const activeKey = activeKeyOf(pattern.id);
+    const active = await memory.get(activeKey, LEARNING_NS);
+    if (!active)
+        return 'missing';
+    const copy = await memory.get(archiveKeyOf(pattern.id), LEARNING_NS);
+    if (!copy || typeof copy !== 'object' || copy.id !== pattern.id)
+        return 'failed';
+    if (canonicalJson(active) !== canonicalJson(archivedRecord(copy)))
+        return 'changed';
+    await memory.delete(activeKey, LEARNING_NS);
+    return 'removed';
+}
+/**
+ * Remove the archive copy of a pattern that is still active, after a move
+ * that did not complete. The copy is kept when the active record is gone, so
+ * a pattern is never left without either record.
+ */
+export async function discardArchiveCopy(memory, pattern) {
+    if (!(await memory.get(activeKeyOf(pattern.id), LEARNING_NS)))
+        return false;
+    return memory.delete(archiveKeyOf(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';
+    return withPatternMoveLock(memory, async () => {
+        const copied = await copyPatternToArchive(memory, pattern, archivedAt);
+        if (copied !== 'copied')
+            return copied;
+        const removed = await removeArchivedPattern(memory, pattern);
+        if (removed === 'removed')
+            return 'archived';
+        await discardArchiveCopy(memory, pattern);
+        return removed;
+    });
+}
+const moveQueues = new WeakMap();
+/**
+ * Run `fn` after every earlier pattern move on the same backend has settled.
+ * Not re-entrant: `fn` must not call `withPatternMoveLock` (or
+ * `archiveSelectedPattern`) on the same backend.
+ */
+export function withPatternMoveLock(memory, fn) {
+    const previous = moveQueues.get(memory) ?? Promise.resolve();
+    const run = previous.then(fn, fn);
+    moveQueues.set(memory, run.then(() => undefined, () => undefined));
+    return run;
 }
 /** True when the stored record's scores or last use differ from the selected snapshot. */
 function changedSinceSelection(current, selected) {

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

@@ -6,12 +6,27 @@
  * to predict the merged pattern, so a dry run selects the same trims as a
  * real run.
  */
-import { isMeasuredPattern } from './reward-source.js';
+import { patternEvidenceOf } 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);
 }
+/**
+ * #1147: a merge keeps the most conservative evidence of its sources:
+ * `assigned` if any source is, else `pre-1120` if any source is, else
+ * `measured`. `pre-1120` has no tag of its own; the merge is left untagged,
+ * which `patternEvidenceOf` reads as `pre-1120` (the kept template is a
+ * source's, so it is not read as assigned unless a source was).
+ */
+function mergedEvidence(patterns) {
+    const evidence = new Set(patterns.map(patternEvidenceOf));
+    if (evidence.has('assigned'))
+        return 'assigned';
+    if (evidence.has('pre-1120'))
+        return 'pre-1120';
+    return 'measured';
+}
 /** 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);
@@ -22,6 +37,7 @@ export function buildConsolidatedPattern(patterns, id, now = new Date()) {
         codeContext: bestPattern.context.codeContext,
         tags: [...new Set(patterns.flatMap((p) => p.context.tags))],
     };
+    const evidence = mergedEvidence(patterns);
     return {
         id,
         type: bestPattern.type,
@@ -35,7 +51,7 @@ export function buildConsolidatedPattern(patterns, id, now = new Date()) {
         template: bestPattern.template,
         createdAt: now,
         lastUsedAt: now,
-        rewardSource: patterns.every(isMeasuredPattern) ? 'measured' : 'assigned',
+        ...(evidence === 'pre-1120' ? {} : { rewardSource: evidence }),
     };
 }
 //# sourceMappingURL=pattern-consolidation.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * Agentic QE v3 - Committing one pattern merge (#1106, #1149)
+ *
+ * `LearningCoordinatorService.consolidatePatterns` builds the consolidated
+ * pattern; this module moves the sources out of the active set:
+ *
+ * 1. Every source pattern's archive copy is written and verified.
+ * 2. The consolidated pattern is stored and read back in full.
+ * 3. The sources are removed one by one with compare-and-delete.
+ *
+ * A failure in steps 1-2, or before the first source is removed, rolls the
+ * merge back: the consolidated pattern and the archive copies are deleted and
+ * every source stays active. A failure after a source was removed keeps the
+ * consolidated pattern (it now holds that source's data) and reports each
+ * source's real state. Callers run this under `withPatternMoveLock`.
+ */
+import type { MemoryBackend } from '../../kernel/interfaces.js';
+import { type Result } from '../../shared/types/index.js';
+import type { LearnedPattern } from './interfaces.js';
+/**
+ * Archive `sources`, store `consolidated` with `store`, then remove the
+ * sources. Returns the consolidated pattern only when every source left the
+ * active set.
+ */
+export declare function commitPatternMerge(memory: MemoryBackend, sources: readonly LearnedPattern[], consolidated: LearnedPattern, store: (pattern: LearnedPattern) => Promise<void>, archivedAt?: Date): Promise<Result<LearnedPattern>>;
+//# sourceMappingURL=pattern-merge.d.ts.map