agentic-qe 3.14.6 → 3.14.8

package/dist/kernel/unified-memory.js

@@ -41,7 +41,8 @@ export { BinaryHeap, UnifiedHnswIndex, createHnswIndex } from './unified-memory-
 // parity tests or benchmarks only.
 import { UnifiedHnswIndex } from './unified-memory-hnsw.js';
 // Import schemas
-import { SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, FEEDBACK_SCHEMA, HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, STATS_TABLES, } from './unified-memory-schemas.js';
+import { SCHEMA_VERSION, SCHEMA_VERSION_TABLE, KV_STORE_SCHEMA, VECTORS_SCHEMA, RL_QVALUES_SCHEMA, GOAP_SCHEMA, DREAM_SCHEMA, QE_PATTERNS_SCHEMA, QE_PATTERNS_FTS_SCHEMA, QE_PATTERNS_SCHEMA_WITHOUT_FTS, MINCUT_SCHEMA, SONA_PATTERNS_SCHEMA, FEEDBACK_SCHEMA, HYPERGRAPH_SCHEMA, PATTERN_NULLS_SCHEMA, STATS_TABLES, } from './unified-memory-schemas.js';
+import { ensurePatternFtsInSync } from './pattern-fts-self-heal.js';
 import { applyMigration as applyLearningEvidenceMigration } from '../migrations/20260830_add_learning_evidence_tables.js';
 // CRDT imports for distributed state synchronization
 import { createCRDTStore, } from '../memory/crdt/index.js';
@@ -55,6 +56,7 @@ import { createCRDTStore, } from '../memory/crdt/index.js';
 // working unchanged. Imported (not bare re-exported) so internal callers below
 // have a usable local binding.
 import { findProjectRoot, clearProjectRootCache } from './project-root.js';
+import { registerStoreCloser, requestOwnedShutdown } from './process-lifecycle.js';
 export { findProjectRoot, clearProjectRootCache };
 /**
  * Get the default database path using project root detection.
@@ -276,6 +278,9 @@ export class UnifiedMemoryManager {
                 signal.throwIfAborted();
             }
             await this.runMigrations();
+            // Not gated on schema version: repairs missing qe_patterns_fts sync
+            // triggers / index drift on every open. Never throws; silent when healthy.
+            ensurePatternFtsInSync(this.db, { logPrefix: '[UnifiedMemory]' });
             signal?.throwIfAborted();
             // DATA LOSS PREVENTION: After migration, if the DB existed before and was
             // large (>1MB = has real data), but now qe_patterns is empty, something
@@ -451,36 +456,13 @@ export class UnifiedMemoryManager {
                 if (currentVersion < 8)
                     this.db.exec(FEEDBACK_SCHEMA);
                 if (currentVersion < 9) {
-                    // Add FTS5 full-text search for qe_patterns (hybrid vector/text search)
-                    this.db.exec(`
-            CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(
-              name, description, pattern_type, qe_domain,
-              content='qe_patterns',
-              content_rowid='rowid'
-            );
-
-            CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_insert AFTER INSERT ON qe_patterns BEGIN
-              INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
-              VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
-            END;
-
-            CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_delete AFTER DELETE ON qe_patterns BEGIN
-              INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
-              VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
-            END;
-
-            CREATE TRIGGER IF NOT EXISTS qe_patterns_fts_update AFTER UPDATE ON qe_patterns BEGIN
-              INSERT INTO qe_patterns_fts(qe_patterns_fts, rowid, name, description, pattern_type, qe_domain)
-              VALUES ('delete', old.rowid, old.name, old.description, old.pattern_type, old.qe_domain);
-              INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
-              VALUES (new.rowid, new.name, new.description, new.pattern_type, new.qe_domain);
-            END;
-          `);
-                    // Populate FTS5 index from existing patterns
-                    this.db.exec(`
-            INSERT INTO qe_patterns_fts(rowid, name, description, pattern_type, qe_domain)
-            SELECT rowid, name, description, pattern_type, qe_domain FROM qe_patterns;
-          `);
+                    // Add FTS5 full-text search for qe_patterns (hybrid vector/text search).
+                    // DDL shared with QE_PATTERNS_SCHEMA and the on-open self-heal.
+                    this.db.exec(QE_PATTERNS_FTS_SCHEMA);
+                    // Populate the index from existing patterns. 'rebuild' rather than a
+                    // raw INSERT...SELECT so it's idempotent when QE_PATTERNS_SCHEMA's
+                    // triggers already indexed some rows.
+                    this.db.exec(`INSERT INTO qe_patterns_fts(qe_patterns_fts) VALUES('rebuild')`);
                 }
                 if (currentVersion < 10)
                     this.db.exec(PATTERN_NULLS_SCHEMA);
@@ -600,10 +582,11 @@ export class UnifiedMemoryManager {
     }
     async kvSearch(pattern, namespace = 'default', limit = 100) {
         this.ensureInitialized();
-        const sqlPattern = pattern.replace(/\*/g, '%').replace(/\?/g, '_');
+        // Only glob wildcards are special; SQL LIKE's own wildcard/escape bytes are literal.
+        const sqlPattern = pattern.replace(/[!%_]/g, '!$&').replace(/\*/g, '%').replace(/\?/g, '_');
         const rows = this.db.prepare(`
       SELECT key FROM kv_store
-      WHERE namespace = ? AND key LIKE ?
+      WHERE namespace = ? AND key LIKE ? ESCAPE '!'
         AND (expires_at IS NULL OR expires_at > ?)
       LIMIT ?
     `).all(namespace, sqlPattern, Date.now(), limit);
@@ -810,7 +793,9 @@ export class UnifiedMemoryManager {
         const db = this.db;
         const table = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='qe_pattern_embeddings'").get();
         if (!table) {
-            db.exec(QE_PATTERNS_SCHEMA);
+            // FTS objects are left to ensurePatternFtsInSync (runs after migrations)
+            // so missing triggers are still seen and the index is rebuilt.
+            db.exec(QE_PATTERNS_SCHEMA_WITHOUT_FTS);
             return;
         }
         const columns = db.prepare("PRAGMA table_info('qe_pattern_embeddings')").all();
@@ -1091,8 +1076,21 @@ function registerExitHandlers() {
         }
     };
     process.on('beforeExit', cleanup);
-    process.on('SIGINT', () => { cleanup(); process.exit(0); });
-    process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+    // A claimed lifecycle owner (the MCP server) closes this store at the end of
+    // its shutdown on every path (EOF, JSON-RPC shutdown, signals, watchdog), so
+    // the WAL is checkpointed into memory.db. close() is idempotent.
+    registerStoreCloser(cleanup);
+    const onSignal = (signal) => {
+        // #801: when a lifecycle owner is claimed, its graceful shutdown may still
+        // need this store, and exiting here would pre-empt it. The owner closes it
+        // through the closer registered above.
+        if (requestOwnedShutdown(signal))
+            return;
+        cleanup();
+        process.exit(0);
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
 }
 registerExitHandlers();
 //# sourceMappingURL=unified-memory.js.map

package/dist/kernel/unified-persistence.js

@@ -21,6 +21,7 @@
 import { toErrorMessage } from '../shared/error-utils.js';
 import { getUnifiedMemory, resetUnifiedMemory, DEFAULT_UNIFIED_MEMORY_CONFIG, } from './unified-memory.js';
 import { MEMORY_CONSTANTS } from './constants.js';
+import { registerStoreCloser, requestOwnedShutdown } from './process-lifecycle.js';
 // Use same path as unified-memory for true unification
 export const DEFAULT_UNIFIED_CONFIG = {
     dbPath: DEFAULT_UNIFIED_MEMORY_CONFIG.dbPath, // '.agentic-qe/memory.db'
@@ -254,14 +255,19 @@ function registerExitHandlers() {
         }
     };
     process.on('beforeExit', cleanup);
-    process.on('SIGINT', () => {
-        cleanup();
-        process.exit(0);
-    });
-    process.on('SIGTERM', () => {
+    // Closed by a claimed lifecycle owner (the MCP server) at the end of its
+    // shutdown on every path; registered after unified memory, so it closes first.
+    registerStoreCloser(cleanup);
+    const onSignal = (signal) => {
+        // #801: defer to a claimed lifecycle owner instead of exiting under its
+        // graceful shutdown; the owner closes the facade via the closer above.
+        if (requestOwnedShutdown(signal))
+            return;
         cleanup();
         process.exit(0);
-    });
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
 }
 // Register exit handlers when module is loaded
 registerExitHandlers();

package/dist/learning/aqe-learning-engine.js

@@ -752,7 +752,7 @@ export class AQELearningEngine {
      */
     async localAnalyze(targetPath, depth) {
         try {
-            const glob = await import('fast-glob');
+            const { glob } = await import('tinyglobby');
             const { existsSync, readFileSync } = await import('fs');
             const { join } = await import('path');
             // Scan patterns based on depth
@@ -762,9 +762,10 @@ export class AQELearningEngine {
                     ? ['**/*.ts', '**/*.js', '**/*.json', '**/*.py']
                     : ['**/*'];
             const ignore = ['node_modules/**', 'dist/**', 'coverage/**', '.git/**'];
-            const files = await glob.default(patterns, {
+            const files = await glob(patterns, {
                 cwd: targetPath,
                 ignore,
+                expandDirectories: false,
                 onlyFiles: true,
             });
             // Detect languages and frameworks

package/dist/learning/experience-capture.d.ts

@@ -301,8 +301,9 @@ export declare class ExperienceCaptureService {
      */
     private detectPatternType;
     /**
-     * Generate pattern name from experience
+     * Stable lookup identity; verify full origin metadata before reinforcement.
      */
+    private experienceIdentity;
     private generatePatternName;
     /**
      * Extract tags from experience

package/dist/learning/experience-capture.js

@@ -12,6 +12,7 @@
  * - Pattern promotion after threshold uses
  * - Cross-domain experience sharing
  */
+import { createHash } from 'node:crypto';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../shared/types/index.js';
 import { LoggerFactory } from '../logging/index.js';
@@ -373,16 +374,23 @@ export class ExperienceCaptureService {
         if (!this.patternStore) {
             return { newPattern: false, reinforced: false, promoted: false };
         }
-        // Search for similar existing patterns
-        const searchResult = await this.patternStore.search(experience.task, {
+        // Reinforcement records repeated observations of the exact originating task;
+        // lexical relevance is not a semantic reuse oracle.
+        const identity = this.experienceIdentity(experience);
+        const searchResult = await this.patternStore.search(identity, {
             limit: 1,
             domain: experience.domain,
-            useVectorSearch: true,
+            patternType: this.detectPatternType(experience.task),
+            useVectorSearch: false,
         });
         if (searchResult.success && searchResult.value.length > 0) {
             const existing = searchResult.value[0];
-            // If similarity is high enough, reinforce existing pattern
-            if (existing.similarity >= this.config.similarityThreshold) {
+            const origin = existing.pattern.context?.experienceOrigin;
+            if (origin?.task === experience.task
+                && origin.domain === (experience.domain ?? null)
+                && origin.patternType === this.detectPatternType(experience.task)
+                && existing.pattern.patternType === origin.patternType
+                && (!experience.domain || existing.pattern.qeDomain === experience.domain)) {
                 const usageResult = await this.patternStore.recordUsage(existing.pattern.id, experience.success);
                 // Check if pattern should be promoted (short-term → long-term)
                 const pattern = await this.patternStore.get(existing.pattern.id);
@@ -590,10 +598,12 @@ ${stepDescriptions}
 Duration: ${experience.durationMs}ms`;
         return {
             patternType,
+            qeDomain: experience.domain,
             name: this.generatePatternName(experience),
             description: `Pattern extracted from: ${experience.task}`,
             context: {
-                tags: this.extractTags(experience),
+                tags: [...this.extractTags(experience), this.experienceIdentity(experience)],
+                experienceOrigin: { task: experience.task, domain: experience.domain ?? null, patternType },
                 testType: this.detectTestType(experience.task),
             },
             template: {
@@ -657,8 +667,13 @@ Duration: ${experience.durationMs}ms`;
         return 'test-template'; // Default
     }
     /**
-     * Generate pattern name from experience
+     * Stable lookup identity; verify full origin metadata before reinforcement.
      */
+    experienceIdentity(experience) {
+        return createHash('sha256').update(JSON.stringify([
+            experience.task, experience.domain ?? null, this.detectPatternType(experience.task),
+        ])).digest('hex');
+    }
     generatePatternName(experience) {
         // Take first 50 chars of task, sanitize
         const sanitized = experience.task
@@ -666,7 +681,7 @@ Duration: ${experience.durationMs}ms`;
             .slice(0, 50)
             .trim();
         const domain = experience.domain ? `[${experience.domain}] ` : '';
-        return `${domain}${sanitized}`;
+        return `${domain}${sanitized} ${this.experienceIdentity(experience)}`;
     }
     /**
      * Extract tags from experience

package/dist/learning/pattern-store.d.ts

@@ -155,7 +155,7 @@ export interface PatternSearchResult {
     /** Match score (0-1) */
     score: number;
     /** How the pattern was matched */
-    matchType: 'vector' | 'exact' | 'context';
+    matchType: 'vector' | 'exact' | 'lexical' | 'context';
     /** Similarity score for vector matches (ADR-042) */
     similarity: number;
     /** Whether this pattern can be reused to skip LLM calls (ADR-042) */

package/dist/learning/pattern-store.js

@@ -60,10 +60,12 @@ function getHDCTokenFingerprinter() {
 /** Module-level Hopfield memory for exact pattern recall */
 let hopfieldMemory = null;
 let hopfieldDimension = 0;
-function getHopfieldMemory(dimension) {
-    if (!hopfieldMemory || hopfieldDimension !== dimension) {
+let hopfieldSpaceId;
+function getHopfieldMemory(dimension, spaceId) {
+    if (!hopfieldMemory || hopfieldDimension !== dimension || hopfieldSpaceId !== spaceId) {
         hopfieldMemory = createHopfieldMemory({ dimension, maxPatterns: 10000 });
         hopfieldDimension = dimension;
+        hopfieldSpaceId = spaceId;
     }
     return hopfieldMemory;
 }
@@ -564,9 +566,9 @@ export class PatternStore {
             console.debug(`[PatternStore] HDC token fingerprint failed for ${pattern.id}:`, toErrorMessage(error));
         }
         // R5: Store embedding in Hopfield memory for exact recall
-        if (isHopfieldMemoryEnabled() && pattern.embedding) {
+        if (isHopfieldMemoryEnabled() && pattern.embedding && activeSpaceId) {
             try {
-                const hopfield = getHopfieldMemory(pattern.embedding.length);
+                const hopfield = getHopfieldMemory(pattern.embedding.length, activeSpaceId);
                 hopfield.store(new Float32Array(pattern.embedding), {
                     id: pattern.id,
                     name: pattern.name,
@@ -717,10 +719,14 @@ export class PatternStore {
         const limit = options.limit || 10;
         const results = [];
         try {
+            const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId;
+            if (Array.isArray(query) && (!activeSpaceId || options.embeddingSpaceId !== activeSpaceId)) {
+                throw new Error('VECTOR_SPACE_UNVERIFIED: pre-computed query vectors require the active embeddingSpaceId');
+            }
             // R5: Exact recall via Hopfield — check for high-confidence exact match
-            if (Array.isArray(query) && isHopfieldMemoryEnabled()) {
+            if (Array.isArray(query) && options.useVectorSearch !== false && activeSpaceId && isHopfieldMemoryEnabled()) {
                 try {
-                    const hopfield = getHopfieldMemory(query.length);
+                    const hopfield = getHopfieldMemory(query.length, activeSpaceId);
                     if (hopfield.getPatternCount() > 0) {
                         const recallResult = hopfield.recall(new Float32Array(query));
                         if (recallResult && recallResult.similarity > 0.98) {
@@ -747,10 +753,6 @@ export class PatternStore {
             }
             // Vector search if query is embedding and HNSW available (lazy-load)
             if (Array.isArray(query) && options.useVectorSearch !== false) {
-                const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId;
-                if (!activeSpaceId || options.embeddingSpaceId !== activeSpaceId) {
-                    throw new Error('VECTOR_SPACE_UNVERIFIED: pre-computed query vectors require the active embeddingSpaceId');
-                }
                 const hnsw = await this.ensureHNSW();
                 if (hnsw) {
                     const hnswResults = await hnsw.search(query, limit * 2);
@@ -778,7 +780,7 @@ export class PatternStore {
                 try {
                     const ftsResults = this.sqliteStore.searchFTS(ftsText, limit * 2);
                     if (ftsResults.length > 0) {
-                        const ftsScoreMap = new Map(ftsResults.map(r => [r.id, r.ftsScore]));
+                        const ftsScoreMap = new Map(ftsResults.map(r => [r.id, r.ftsScore * r.coverage]));
                         const existingIds = new Set(results.map(r => r.pattern.id));
                         // Boost existing vector results that also match FTS5
                         for (const result of results) {
@@ -793,22 +795,18 @@ export class PatternStore {
                                 continue;
                             const pattern = await this.get(ftsResult.id);
                             if (pattern && this.matchesFilters(pattern, options)) {
-                                // #653: ftsScore is normalized to the best hit, so only a
-                                // whole-phrase hit may read as a near-duplicate; term-only hits
-                                // report the conservative keyword score as their similarity.
-                                // Scaled by query-term coverage so the best of a weak lexical
-                                // set (e.g. one shared stopword) cannot outrank vector hits.
+                                // Relative BM25 is weighted by query coverage for ranking;
+                                // lexical evidence alone never authorizes vector reuse.
                                 const keywordScore = 0.5 * ftsResult.ftsScore * ftsResult.coverage;
-                                const similarity = ftsResult.phrase ? ftsResult.ftsScore : keywordScore;
-                                const reuseInfo = this.calculateReuseInfo(pattern, similarity);
+                                const similarity = 0; // Lexical relevance is not vector similarity or safe reuse.
                                 results.push({
                                     pattern,
-                                    score: keywordScore, // FTS-only: exact keyword match is valuable
-                                    matchType: 'exact',
+                                    score: keywordScore,
+                                    matchType: 'lexical',
                                     similarity,
-                                    canReuse: reuseInfo.canReuse,
-                                    estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
-                                    reuseConfidence: reuseInfo.reuseConfidence,
+                                    canReuse: false,
+                                    estimatedTokenSavings: 0,
+                                    reuseConfidence: 0,
                                 });
                             }
                         }
@@ -974,15 +972,14 @@ export class PatternStore {
                 score = pattern.qualityScore;
             }
             if (score > 0 || !queryLower) {
-                const reuseInfo = this.calculateReuseInfo(pattern, score);
                 results.push({
                     pattern,
-                    score: score || pattern.qualityScore,
-                    matchType: queryLower ? 'exact' : 'context',
-                    similarity: score || pattern.qualityScore,
-                    canReuse: reuseInfo.canReuse,
-                    estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
-                    reuseConfidence: reuseInfo.reuseConfidence,
+                    score: queryLower ? 0.5 * score : pattern.qualityScore,
+                    matchType: queryLower ? 'lexical' : 'context',
+                    similarity: 0,
+                    canReuse: false,
+                    estimatedTokenSavings: 0,
+                    reuseConfidence: 0,
                 });
             }
         }

package/dist/learning/qe-patterns.d.ts

@@ -111,6 +111,12 @@ export interface QEPattern {
  * Pattern applicability context
  */
 export interface QEPatternContext {
+    /** Exact originating experience; reinforcement identity, never a similarity claim. */
+    readonly experienceOrigin?: {
+        task: string;
+        domain: QEDomain | null;
+        patternType: QEPatternType;
+    };
     /** Programming language this pattern applies to */
     readonly language?: ProgrammingLanguage;
     /** Test framework this pattern uses */

package/dist/learning/qe-reasoning-bank.d.ts

@@ -48,6 +48,7 @@ export declare class QEReasoningBank implements IQEReasoningBank {
     private readonly eventBus?;
     private readonly coherenceService?;
     private readonly config;
+    private readonly embeddingProvenance;
     private patternStore;
     private initialized;
     private sqliteStore;

package/dist/learning/qe-reasoning-bank.js

@@ -64,6 +64,7 @@ export class QEReasoningBank {
     eventBus;
     coherenceService;
     config;
+    embeddingProvenance = new WeakMap();
     patternStore;
     initialized = false;
     sqliteStore = null;
@@ -337,7 +338,11 @@ export class QEReasoningBank {
                 searchQuery = '';
             }
             else {
-                searchQuery = await this.embed(query);
+                const embedding = await this.embed(query);
+                // Hash fallback and resized vectors do not belong to the active provider.
+                // Keep their text searchable without claiming semantic comparability.
+                searchQuery = this.embeddingProvenance.has(embedding) ? embedding : query;
+                useVectorSearch = Array.isArray(searchQuery);
             }
         }
         return this.patternStore.search(searchQuery, {
@@ -346,7 +351,7 @@ export class QEReasoningBank {
             textQuery: typeof query === 'string' && query.trim() ? query : options?.textQuery,
             useVectorSearch,
             embeddingSpaceId: typeof query === 'string'
-                ? getActiveEmbeddingSpaceIdentity()?.spaceId
+                ? (Array.isArray(searchQuery) ? this.embeddingProvenance.get(searchQuery) : undefined)
                 : options?.embeddingSpaceId,
         });
     }
@@ -442,11 +447,13 @@ export class QEReasoningBank {
             }
             // 2. Search for similar patterns
             const embedding = await this.embed(request.task);
-            const patternResults = await this.patternStore.search(embedding, {
+            const embeddingSpaceId = this.embeddingProvenance.get(embedding);
+            const patternResults = await this.patternStore.search(embeddingSpaceId ? embedding : request.task, {
                 limit: this.config.maxRoutingCandidates,
                 domain: detectedDomains[0],
-                useVectorSearch: true,
+                useVectorSearch: Boolean(embeddingSpaceId),
                 textQuery: request.task,
+                embeddingSpaceId,
             });
             const patterns = patternResults.success
                 ? patternResults.value.map((r) => r.pattern)
@@ -607,6 +614,9 @@ export class QEReasoningBank {
                 if (embedding.length !== this.config.embeddingDimension) {
                     return resizeEmbedding(embedding, this.config.embeddingDimension);
                 }
+                const spaceId = getActiveEmbeddingSpaceIdentity()?.spaceId;
+                if (spaceId)
+                    this.embeddingProvenance.set(embedding, spaceId);
                 return embedding;
             }
             catch (error) {

package/dist/learning/real-qe-reasoning-bank.d.ts

@@ -30,6 +30,14 @@ export interface RealQEReasoningBankConfig {
     coherenceThreshold?: number;
 }
 export declare const DEFAULT_REAL_CONFIG: RealQEReasoningBankConfig;
+/** Ranking evidence keeps lexical relevance separate from vector reuse safety. */
+export interface RealQEPatternSearchResult {
+    pattern: QEPattern;
+    score: number;
+    similarity: number;
+    matchType: 'vector' | 'lexical';
+    canReuse: boolean;
+}
 export interface RealQERoutingRequest {
     task: string;
     taskType?: 'test-generation' | 'analysis' | 'debugging' | 'optimization';
@@ -144,10 +152,7 @@ export declare class RealQEReasoningBank {
         limit?: number;
         domain?: QEDomain;
         minSimilarity?: number;
-    }): Promise<Result<Array<{
-        pattern: QEPattern;
-        similarity: number;
-    }>>>;
+    }): Promise<Result<RealQEPatternSearchResult[]>>;
     /**
      * Route a task to optimal agent
      */

package/dist/learning/real-qe-reasoning-bank.js

@@ -19,6 +19,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { LoggerFactory } from '../logging/index.js';
 import { toError, toErrorMessage } from '../shared/error-utils.js';
 import { maybeEnhanceRoutingWithPatterns } from './pattern-routing-guidance.js';
+import { blendFtsScore, DEFAULT_PATTERN_STORE_CONFIG } from './pattern-store.js';
 import { EMBEDDING_SPACE_CANARY } from './embedding-space.js';
 const logger = LoggerFactory.create('RealQEReasoningBank');
 import { computeRealEmbedding, isTransformerAvailable, getEmbeddingDimension, clearEmbeddingCache, getActiveEmbeddingSpaceIdentity, } from './real-embeddings.js';
@@ -418,11 +419,11 @@ export class RealQEReasoningBank {
             const limit = options.limit || 10;
             const results = this.hnswIndex.searchKnn(queryEmbedding, limit * 2); // Get extra for filtering
             const patterns = [];
-            for (let i = 0; i < results.neighbors.length && patterns.length < limit; i++) {
+            for (let i = 0; i < results.neighbors.length; i++) {
                 const hnswIndex = results.neighbors[i];
                 const distance = results.distances[i];
                 const similarity = 1 - distance; // Convert distance to similarity
-                if (options.minSimilarity && similarity < options.minSimilarity) {
+                if (options.minSimilarity !== undefined && similarity < options.minSimilarity) {
                     continue;
                 }
                 const patternId = this.patternIdMap.get(hnswIndex);
@@ -435,13 +436,36 @@ export class RealQEReasoningBank {
                 if (options.domain && pattern.qeDomain !== options.domain) {
                     continue;
                 }
-                patterns.push({ pattern, similarity });
+                const reuse = DEFAULT_PATTERN_STORE_CONFIG.reuseOptimization;
+                const ageDays = (Date.now() - new Date(pattern.lastUsedAt).getTime()) / 86_400_000;
+                patterns.push({ pattern, similarity, score: similarity, matchType: 'vector',
+                    canReuse: Boolean(pattern.reusable && similarity >= reuse.minSimilarityForReuse
+                        && pattern.successRate >= reuse.minSuccessRateForReuse && ageDays <= reuse.maxAgeForReuse),
+                });
+            }
+            const existing = new Map(patterns.map(hit => [hit.pattern.id, hit]));
+            for (const lexical of this.sqliteStore.searchFTS(query, limit * 2)) {
+                const vector = existing.get(lexical.id);
+                if (vector) {
+                    vector.score = blendFtsScore(vector.score, lexical.ftsScore * lexical.coverage);
+                    continue;
+                }
+                // A vector threshold requires measured vector evidence. A rejected
+                // vector must never re-enter through the lexical-only branch.
+                if (options.minSimilarity !== undefined)
+                    continue;
+                const pattern = this.sqliteStore.getPattern(lexical.id);
+                if (!pattern || (options.domain && pattern.qeDomain !== options.domain))
+                    continue;
+                patterns.push({ pattern, score: 0.5 * lexical.ftsScore * lexical.coverage,
+                    similarity: 0, matchType: 'lexical', canReuse: false });
             }
+            patterns.sort((a, b) => b.score - a.score);
             const searchTime = performance.now() - startTime;
             if (searchTime > 10) {
                 logger.warn('Slow search', { searchTimeMs: Number(searchTime.toFixed(1)) });
             }
-            return ok(patterns);
+            return ok(patterns.slice(0, limit));
         }
         catch (error) {
             return err(toError(error));

package/dist/learning/rvf-pattern-store.js

@@ -322,16 +322,18 @@ export class RvfPatternStore {
         // Uses getPattern(id) which joins the embedding from qe_pattern_embeddings.
         if (Array.isArray(query) && !this.adapter && this.sqliteStore && results.length === 0) {
             try {
-                const allPatterns = this.sqliteStore.getPatterns({ limit: limit * 4 });
+                const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.embeddingSpaceId;
+                const embeddings = this.sqliteStore.getAllEmbeddings();
                 const qArr = query;
                 const qMag = Math.sqrt(qArr.reduce((s, v) => s + v * v, 0));
                 if (qMag > 0) {
-                    for (const pat of allPatterns) {
-                        if (!this.matchesFilters(pat, options))
+                    for (const row of embeddings) {
+                        if (!activeSpaceId || row.spaceId !== activeSpaceId)
                             continue;
-                        // getPattern() joins the embedding; getPatterns() does not
-                        const full = this.sqliteStore.getPattern(pat.id);
-                        const emb = full?.embedding;
+                        const full = this.sqliteStore.getPattern(row.patternId);
+                        if (!full || !this.matchesFilters(full, options))
+                            continue;
+                        const emb = row.embedding;
                         if (!emb || emb.length !== qArr.length)
                             continue;
                         let dot = 0, eMag = 0;
@@ -368,15 +370,14 @@ export class RvfPatternStore {
                         continue;
                     if (!this.matchesFilters(pattern, options))
                         continue;
-                    const reuseInfo = this.calculateReuseInfo(pattern, pattern.confidence);
                     results.push({
                         pattern,
                         score: pattern.confidence,
-                        matchType: 'exact',
-                        similarity: pattern.confidence,
-                        canReuse: reuseInfo.canReuse,
-                        estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
-                        reuseConfidence: reuseInfo.reuseConfidence,
+                        matchType: 'context',
+                        similarity: 0,
+                        canReuse: false,
+                        estimatedTokenSavings: 0,
+                        reuseConfidence: 0,
                     });
                 }
             }
@@ -390,7 +391,7 @@ export class RvfPatternStore {
                 const existingIds = new Set(results.map(r => r.pattern.id));
                 // #653: same vector/FTS5 blend as PatternStore for hits found by
                 // both, so lexical relevance can reorder vector results.
-                const ftsScoreMap = new Map(ftsResults.map(r => [r.id, r.ftsScore]));
+                const ftsScoreMap = new Map(ftsResults.map(r => [r.id, r.ftsScore * r.coverage]));
                 for (const result of results) {
                     const ftsScore = ftsScoreMap.get(result.pattern.id);
                     if (ftsScore !== undefined) {
@@ -404,16 +405,15 @@ export class RvfPatternStore {
                     if (pattern && this.matchesFilters(pattern, options)) {
                         // Same keyword-only similarity rule as PatternStore (#653)
                         const keywordScore = 0.5 * ftsResult.ftsScore * ftsResult.coverage;
-                        const similarity = ftsResult.phrase ? ftsResult.ftsScore : keywordScore;
-                        const reuseInfo = this.calculateReuseInfo(pattern, similarity);
+                        const similarity = 0; // Lexical relevance is not vector similarity or safe reuse.
                         results.push({
                             pattern,
                             score: keywordScore,
-                            matchType: 'exact',
+                            matchType: 'lexical',
                             similarity,
-                            canReuse: reuseInfo.canReuse,
-                            estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
-                            reuseConfidence: reuseInfo.reuseConfidence,
+                            canReuse: false,
+                            estimatedTokenSavings: 0,
+                            reuseConfidence: 0,
                         });
                     }
                 }