agentic-qe 3.15.16 → 3.15.18

package/dist/domains/code-intelligence/services/semantic-analyzer.js

@@ -6,12 +6,15 @@ import { createHash } from 'node:crypto';
 import { ok, err } from '../../../shared/types/index.js';
 import { NomicEmbedder, EMBEDDING_CONFIG, } from '../../../shared/embeddings/index.js';
 import { toError } from '../../../shared/error-utils.js';
+import { compareTextRelevance, textRelevance } from './text-relevance.js';
 /**
  * #1224: the message for a search over an empty index. "No results" is only
  * reported after searching an index that holds code.
  */
 export const NOTHING_INDEXED_FOR_SEARCH = 'No code is indexed for search yet, so the search was not run. ' +
     'Index the project first (MCP code_index, or `aqe code index <path>`), then search again.';
+/** Highest score first; equal scores by text relevance (#1287). */
+const byScoreThenRelevance = (a, b) => b.hit.score - a.hit.score || compareTextRelevance(a.relevance, b.relevance);
 /** Upper bound on indexed files one exact/fuzzy search reads. */
 const MAX_INDEXED_FILES_SCANNED = 100_000;
 const DEFAULT_CONFIG = {
@@ -60,17 +63,17 @@ export class SemanticAnalyzerService {
                 ...this.config.nomicConfig,
                 enableFallback: false,
             });
-            // Check if Ollama is available
-            const isAvailable = await nomicEmbedder.healthCheck();
-            if (isAvailable) {
+            // #1229: Ollama lists the model under its own name (all-minilm:22m);
+            // the reason says whether Ollama is down or lacks the model.
+            const check = await nomicEmbedder.checkModel();
+            if (check.status === 'available') {
                 this.embedder = nomicEmbedder;
                 // Update dimension to match Nomic's output
                 this.config.embeddingDimension =
                     EMBEDDING_CONFIG.DIMENSIONS;
             }
             else {
-                this.embedderUnavailableReason =
-                    `no embedding model available (Ollama model '${EMBEDDING_CONFIG.MODEL}' is not reachable)`;
+                this.embedderUnavailableReason = `no embedding model available (${check.reason})`;
             }
         }
         else {
@@ -276,7 +279,7 @@ export class SemanticAnalyzerService {
     }
     /** Identifies the model behind stored vectors, so vectors from another model are not compared. */
     embeddingModelId() {
-        return this.embedder instanceof NomicEmbedder ? EMBEDDING_CONFIG.MODEL : 'injected-provider';
+        return this.embedder instanceof NomicEmbedder ? this.embedder.getModelId() : 'injected-provider';
     }
     isCurrentModelVector(metadata) {
         return metadata.embeddingModel === this.embeddingModelId();
@@ -366,8 +369,9 @@ export class SemanticAnalyzerService {
      * vector, so vector search cannot rank them. Match those by text, label the
      * hits 'lexical', and report the result as 'partial-vector' with the counts.
      * Cosine and text-match scores are not comparable, so vector hits come
-     * first (by cosine), then lexical hits (by share of query words found); the
-     * reason says how many text matches the limit left out.
+     * first (by cosine), then lexical hits (by share of query words found, ties
+     * by text relevance, #1287); the reason says how many text matches the
+     * limit left out.
      */
     async withVectorlessFiles(query, vectorHits, limit, scope, filters) {
         const model = this.embeddingModelId();
@@ -383,16 +387,19 @@ export class SemanticAnalyzerService {
             withoutVector++;
             if (vectorFiles.has(stored.file))
                 return;
-            const hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
-            if (hit)
-                lexicalHits.push({ ...hit, matchType: 'lexical' });
+            const match = this.fuzzyMatch(query, queryTokens, stored, scope, filters);
+            if (match)
+                lexicalHits.push({ ...match, hit: { ...match.hit, matchType: 'lexical' } });
         });
         const coverage = { indexedFiles, filesWithVector: indexedFiles - withoutVector };
         if (withoutVector === 0) {
             return { results: vectorHits, mode: 'vector', coverage };
         }
         const byScore = (a, b) => b.score - a.score;
-        const results = [...[...vectorHits].sort(byScore), ...lexicalHits.sort(byScore)].slice(0, limit);
+        const results = [
+            ...[...vectorHits].sort(byScore),
+            ...lexicalHits.sort(byScoreThenRelevance).map((match) => match.hit),
+        ].slice(0, limit);
         const droppedLexical = vectorHits.length + lexicalHits.length - results.length;
         return {
             results,
@@ -449,18 +456,22 @@ export class SemanticAnalyzerService {
         return results;
     }
     async fuzzySearch(query, limit, scope, filters) {
-        const results = [];
+        const matches = [];
         const queryTokens = this.tokenize(query.toLowerCase());
         await this.forEachIndexed((stored) => {
-            const hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
-            if (hit)
-                results.push(hit);
+            const match = this.fuzzyMatch(query, queryTokens, stored, scope, filters);
+            if (match)
+                matches.push(match);
         });
-        // Sort by score and limit
-        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+        // Sort by score, ties by relevance (#1287), and limit
+        return matches.sort(byScoreThenRelevance).slice(0, limit).map((match) => match.hit);
     }
-    /** Token-overlap match of one indexed file, or null when it is filtered out or scores too low. */
-    fuzzyMatch(queryTokens, stored, scope, filters) {
+    /**
+     * Token-overlap match of one indexed file, or null when it is filtered out or
+     * scores too low. The score is the share of query words found; `relevance`
+     * only orders equal scores (#1287).
+     */
+    fuzzyMatch(query, queryTokens, stored, scope, filters) {
         // Apply scope filter
         if (scope && scope.length > 0 && !scope.some((s) => stored.file.includes(s))) {
             return null;
@@ -475,11 +486,14 @@ export class SemanticAnalyzerService {
         if (score < this.config.minScore)
             return null;
         return {
-            file: stored.file,
-            snippet: this.extractSnippet(stored.content, 200),
-            score,
-            highlights: queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct))),
-            metadata: stored.metadata,
+            hit: {
+                file: stored.file,
+                snippet: this.extractSnippet(stored.content, 200),
+                score,
+                highlights: queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct))),
+                metadata: stored.metadata,
+            },
+            relevance: textRelevance(query, stored.content),
         };
     }
     // ============================================================================

package/dist/domains/code-intelligence/services/text-relevance.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Agentic QE v3 - Text match relevance (#1287)
+ *
+ * Text matching scores a file by the share of query words it contains, so
+ * every file containing all of them scores 1.0. This ranks those ties by how
+ * well the file matches the query, without changing the score itself.
+ */
+/** How well one file's text matches a query. Higher fields rank first, in this order. */
+export interface TextRelevance {
+    /**
+     * 2: an identifier is exactly the query words (`processOrder`, `process_order`
+     * for "process order"); 1: the query words appear next to each other
+     * (`process the order` does not, `process order` and `processOrderItems` do);
+     * 0: scattered, or the query is a single word.
+     */
+    adjacency: number;
+    /** Share of query words found as a whole word (`order`), not only inside one (`orders`, `reorder`). */
+    exactWords: number;
+    /** Number of words in the file that contain a query word. */
+    occurrences: number;
+}
+/** Splits an identifier into lowercase words: `processOrder`, `process_order`, `PROCESS_ORDER` → process, order. */
+export declare function identifierWords(identifier: string): string[];
+/**
+ * Relevance of `content` to `query`. Words are compared case-insensitively,
+ * and identifiers are split into words, so the query `process order` matches
+ * the identifier `processOrder` as adjacent whole words.
+ */
+export declare function textRelevance(query: string, content: string): TextRelevance;
+/** Sort comparator: more relevant first. */
+export declare function compareTextRelevance(a: TextRelevance, b: TextRelevance): number;
+//# sourceMappingURL=text-relevance.d.ts.map

package/dist/domains/code-intelligence/services/text-relevance.js

@@ -0,0 +1,63 @@
+/**
+ * Agentic QE v3 - Text match relevance (#1287)
+ *
+ * Text matching scores a file by the share of query words it contains, so
+ * every file containing all of them scores 1.0. This ranks those ties by how
+ * well the file matches the query, without changing the score itself.
+ */
+/** Splits an identifier into lowercase words: `processOrder`, `process_order`, `PROCESS_ORDER` → process, order. */
+export function identifierWords(identifier) {
+    return identifier
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter((word) => word.length > 0)
+        .map((word) => word.toLowerCase());
+}
+function identifiers(text) {
+    return text.split(/[^\w]+/).filter((token) => token.length > 0);
+}
+/** Whether `words` appears in `stream` as consecutive entries. */
+function containsRun(stream, words) {
+    outer: for (let i = 0; i + words.length <= stream.length; i++) {
+        for (let j = 0; j < words.length; j++) {
+            if (stream[i + j] !== words[j])
+                continue outer;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Relevance of `content` to `query`. Words are compared case-insensitively,
+ * and identifiers are split into words, so the query `process order` matches
+ * the identifier `processOrder` as adjacent whole words.
+ */
+export function textRelevance(query, content) {
+    const queryWords = identifiers(query).flatMap(identifierWords);
+    const contentIdentifiers = identifiers(content);
+    const lowerIdentifiers = contentIdentifiers.map((token) => token.toLowerCase());
+    const splitIdentifiers = contentIdentifiers.map(identifierWords);
+    const contentWords = new Set([...lowerIdentifiers, ...splitIdentifiers.flat()]);
+    const queryTokens = identifiers(query.toLowerCase());
+    let adjacency = 0;
+    if (queryWords.length > 1) {
+        const phrase = queryWords.join(' ');
+        if (splitIdentifiers.some((words) => words.join(' ') === phrase))
+            adjacency = 2;
+        else if (containsRun(splitIdentifiers.flat(), queryWords))
+            adjacency = 1;
+    }
+    return {
+        adjacency,
+        exactWords: queryWords.length === 0
+            ? 0
+            : queryWords.filter((word) => contentWords.has(word)).length / queryWords.length,
+        occurrences: lowerIdentifiers.filter((token) => queryTokens.some((qt) => token.includes(qt))).length,
+    };
+}
+/** Sort comparator: more relevant first. */
+export function compareTextRelevance(a, b) {
+    return b.adjacency - a.adjacency || b.exactWords - a.exactWords || b.occurrences - a.occurrences;
+}
+//# sourceMappingURL=text-relevance.js.map

package/dist/domains/defect-intelligence/interfaces.d.ts

@@ -30,6 +30,8 @@ export interface PredictionResult {
     factors: string[];
     /** ADR-051: LLM-enhanced analysis when enabled */
     llmAnalysis?: LLMDefectAnalysis;
+    /** #1137: the run was stored, but pruning older runs failed. */
+    retention?: 'failed';
 }
 /**
  * ADR-051: LLM-enhanced defect analysis result

package/dist/domains/defect-intelligence/prediction-history.d.ts

@@ -1,5 +1,7 @@
 import type { MemoryBackend } from '../../kernel/interfaces.js';
 export declare const MAX_PREDICTION_HISTORY = 32;
+/** Longest `target` a prediction run may name (Linux PATH_MAX) (#1137). */
+export declare const MAX_PREDICTION_TARGET_LENGTH = 4096;
 type RiskLevel = 'critical' | 'high' | 'medium' | 'low' | 'info';
 /** One file prediction as the defect-intelligence predictor recorded it. */
 export interface DomainFilePrediction {
@@ -12,16 +14,28 @@ export interface DomainFilePrediction {
     }[];
     recommendations: string[];
 }
+/**
+ * #1137: the target a run for an explicit file list covers. A list too long
+ * to store as a target is identified by its digest.
+ */
+export declare function predictionTargetForFiles(files: readonly string[]): string;
 /** A recorded prediction run, or `null` when the record is not a usable one. */
 export declare function parsePredictionRecord(raw: unknown, now: number): {
     id: string;
     timestamp: string;
     predictions: DomainFilePrediction[];
+    /** What the run covered; '' for runs recorded before #1137. */
+    target: string;
     predictionMethod?: 'static-code-indicators';
     estimated?: true;
     filesSkipped?: number;
 } | null;
-/** Keep 32 usable immutable UUID runs, preserving tied-latest ambiguity. */
+/**
+ * Bound the stored prediction runs: delete runs older than 7 days and usable
+ * runs beyond the cap. A row this version cannot parse (stamped ahead by
+ * another host's clock, or a riskLevel from a newer release) is left to its
+ * TTL rather than deleted on this version's schema (#1137).
+ */
 export declare function prunePredictionHistory(memory: Pick<MemoryBackend, 'search' | 'get' | 'delete'>, modelNamespace?: string): Promise<void>;
 export {};
 //# sourceMappingURL=prediction-history.d.ts.map

package/dist/domains/defect-intelligence/prediction-history.js

@@ -1,4 +1,7 @@
+import { createHash } from 'node:crypto';
 export const MAX_PREDICTION_HISTORY = 32;
+/** Longest `target` a prediction run may name (Linux PATH_MAX) (#1137). */
+export const MAX_PREDICTION_TARGET_LENGTH = 4096;
 const MAX_PREDICTION_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 const NAMESPACE = 'defect-intelligence';
 const RISK_LEVELS = ['critical', 'high', 'medium', 'low', 'info'];
@@ -21,6 +24,16 @@ function parseFilePrediction(raw) {
         : [];
     return { file, probability, riskLevel: riskLevel, factors, recommendations };
 }
+/**
+ * #1137: the target a run for an explicit file list covers. A list too long
+ * to store as a target is identified by its digest.
+ */
+export function predictionTargetForFiles(files) {
+    const target = `files:${[...new Set(files)].sort().join(',')}`;
+    return target.length <= MAX_PREDICTION_TARGET_LENGTH
+        ? target
+        : `files-sha256:${createHash('sha256').update(target).digest('hex')}`;
+}
 /** A recorded prediction run, or `null` when the record is not a usable one. */
 export function parsePredictionRecord(raw, now) {
     if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.timestamp !== 'string')
@@ -28,6 +41,8 @@ export function parsePredictionRecord(raw, now) {
     const t = Date.parse(raw.timestamp);
     if (!Number.isFinite(t) || t > now + 60_000 || now - t > MAX_PREDICTION_AGE_MS)
         return null;
+    if (raw.target !== undefined && (typeof raw.target !== 'string' || raw.target.length > MAX_PREDICTION_TARGET_LENGTH))
+        return null;
     if (!Array.isArray(raw.predictions) || raw.predictions.length === 0)
         return null;
     const predictions = raw.predictions.map(parseFilePrediction);
@@ -35,6 +50,7 @@ export function parsePredictionRecord(raw, now) {
         return null;
     return {
         id: raw.id, timestamp: raw.timestamp, predictions: predictions,
+        target: raw.target ?? '',
         ...(raw.predictionMethod === 'static-code-indicators' ? {
             predictionMethod: 'static-code-indicators', estimated: true,
             filesSkipped: typeof raw.filesSkipped === 'number' && Number.isSafeInteger(raw.filesSkipped) && raw.filesSkipped >= 0
@@ -42,26 +58,66 @@ export function parsePredictionRecord(raw, now) {
         } : {}),
     };
 }
-/** Keep 32 usable immutable UUID runs, preserving tied-latest ambiguity. */
+/** Milliseconds since the epoch the record claims, or `null` when it names no parseable time. */
+function recordTime(raw) {
+    if (!isRecord(raw) || typeof raw.timestamp !== 'string')
+        return null;
+    const t = Date.parse(raw.timestamp);
+    return Number.isFinite(t) ? t : null;
+}
+/**
+ * #1137: the latest run of every target stays (with any run tied with it, so
+ * the worker still sees the ambiguity), most recently predicted targets first;
+ * the newest other runs fill what is left. Never more than the cap in total.
+ */
+function selectRetained(newestFirst) {
+    const latestAt = new Map();
+    const latest = [];
+    for (const run of newestFirst) {
+        const at = latestAt.get(run.target);
+        if (at === undefined)
+            latestAt.set(run.target, run.timestamp);
+        if (at === undefined || at === run.timestamp)
+            latest.push(run);
+    }
+    const keep = new Set(latest.slice(0, MAX_PREDICTION_HISTORY).map((run) => run.key));
+    for (const run of newestFirst) {
+        if (keep.size >= MAX_PREDICTION_HISTORY)
+            break;
+        keep.add(run.key);
+    }
+    return keep;
+}
+/**
+ * Bound the stored prediction runs: delete runs older than 7 days and usable
+ * runs beyond the cap. A row this version cannot parse (stamped ahead by
+ * another host's clock, or a riskLevel from a newer release) is left to its
+ * TTL rather than deleted on this version's schema (#1137).
+ */
 export async function prunePredictionHistory(memory, modelNamespace = 'defect-intelligence:predictor') {
     const prefix = `${modelNamespace}:prediction:`;
     const keys = await memory.search(`${prefix}*`, Number.MAX_SAFE_INTEGER, { namespace: NAMESPACE });
     const now = Date.now();
     const records = [];
-    const invalid = [];
+    const expired = [];
     for (const found of keys) {
         const key = found.startsWith(`${NAMESPACE}:${prefix}`) ? found.slice(NAMESPACE.length + 1) : found;
         if (!key.startsWith(prefix))
             continue;
-        const parsed = parsePredictionRecord(await memory.get(key, { namespace: NAMESPACE }), now);
+        const raw = await memory.get(key, { namespace: NAMESPACE });
+        const t = recordTime(raw);
+        if (t !== null && now - t > MAX_PREDICTION_AGE_MS) {
+            expired.push(key);
+            continue;
+        }
+        const parsed = parsePredictionRecord(raw, now);
         if (parsed)
-            records.push({ key, timestamp: Date.parse(parsed.timestamp), id: parsed.id });
-        else
-            invalid.push(key);
+            records.push({ key, timestamp: Date.parse(parsed.timestamp), id: parsed.id, target: parsed.target });
     }
     records.sort((a, b) => b.timestamp - a.timestamp || (a.id === b.id ? (a.key === b.key ? 0 : a.key > b.key ? -1 : 1) : a.id > b.id ? -1 : 1));
+    const keep = selectRetained(records);
     // Only observed immutable keys are candidates; concurrent new runs are untouched.
-    for (const key of [...invalid, ...records.slice(MAX_PREDICTION_HISTORY).map(record => record.key)]) {
+    for (const key of [...expired, ...records.filter((record) => !keep.has(record.key)).map((record) => record.key)]) {
         await memory.delete(key, { namespace: NAMESPACE });
     }
 }

package/dist/domains/defect-intelligence/services/defect-predictor.d.ts

@@ -188,6 +188,7 @@ export declare class DefectPredictorService implements IDefectPredictorService {
     private generateTestRecommendations;
     private calculateModelConfidence;
     private calculateVariance;
+    /** Records the run; `false` when it was stored but older runs could not be pruned (#1137). */
     private storePrediction;
     private recalculateMetrics;
 }

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). */