agentic-qe 3.14.5 → 3.14.7

package/dist/kernel/unified-memory-schemas.js

@@ -254,7 +254,48 @@ export const DREAM_SCHEMA = `
   CREATE INDEX IF NOT EXISTS idx_insight_cycle ON dream_insights(cycle_id);
   CREATE INDEX IF NOT EXISTS idx_dream_status ON dream_cycles(status);
 `;
-export const QE_PATTERNS_SCHEMA = `
+// ============================================================================
+// qe_patterns FTS5 index (single source of truth)
+// ============================================================================
+//
+// Shared by QE_PATTERNS_SCHEMA, the v9 migration, the legacy SQLitePatternStore
+// schema and the on-open self-heal (pattern-fts-self-heal.ts), so the DDL can't
+// drift between paths. External-content table: the index stores no text of its
+// own and is kept in sync ONLY by the three triggers below.
+/** FTS5 external-content index over qe_patterns (hybrid vector/text search). */
+export const QE_PATTERNS_FTS_TABLE_DDL = `
+  CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(
+    name, description, pattern_type, qe_domain,
+    content='qe_patterns',
+    content_rowid='rowid'
+  );
+`;
+/** Sync triggers keeping qe_patterns_fts in step with qe_patterns, keyed by name. */
+export const QE_PATTERNS_FTS_TRIGGER_DDL = Object.freeze({
+    qe_patterns_fts_insert: `
+  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;
+`,
+    qe_patterns_fts_delete: `
+  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;
+`,
+    qe_patterns_fts_update: `
+  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;
+`,
+});
+/** FTS5 table plus all sync triggers (idempotent). Requires qe_patterns to exist. */
+export const QE_PATTERNS_FTS_SCHEMA = QE_PATTERNS_FTS_TABLE_DDL + Object.values(QE_PATTERNS_FTS_TRIGGER_DDL).join('');
+const qePatternsSchema = (ftsSchema) => `
   -- QE Patterns table (unified from sqlite-persistence.ts)
   CREATE TABLE IF NOT EXISTS qe_patterns (
     id TEXT PRIMARY KEY,
@@ -367,30 +408,8 @@ export const QE_PATTERNS_SCHEMA = `
     FOREIGN KEY (execution_id) REFERENCES execution_results(id)
   );
 
-  -- FTS5 full-text search index for hybrid vector/text search
-  CREATE VIRTUAL TABLE IF NOT EXISTS qe_patterns_fts USING fts5(
-    name, description, pattern_type, qe_domain,
-    content='qe_patterns',
-    content_rowid='rowid'
-  );
-
-  -- FTS5 triggers to keep index in sync
-  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;
+  -- FTS5 full-text search index + sync triggers for hybrid vector/text search
+  ${ftsSchema}
 
   -- QE Patterns indexes
   CREATE INDEX IF NOT EXISTS idx_qe_patterns_domain ON qe_patterns(qe_domain);
@@ -407,6 +426,15 @@ export const QE_PATTERNS_SCHEMA = `
   CREATE INDEX IF NOT EXISTS idx_executed_steps_execution ON executed_steps(execution_id);
   CREATE INDEX IF NOT EXISTS idx_executed_steps_action ON executed_steps(action_id);
 `;
+export const QE_PATTERNS_SCHEMA = qePatternsSchema(QE_PATTERNS_FTS_SCHEMA);
+/**
+ * QE_PATTERNS_SCHEMA without the FTS5 table/triggers, for migrations that run
+ * after v9 on an existing DB. Re-creating the sync triggers there (with
+ * CREATE TRIGGER IF NOT EXISTS, no rebuild) would hide "triggers were missing"
+ * from the on-open self-heal, leaving UPDATE-only drift unrepaired; the heal
+ * creates any missing FTS objects and rebuilds instead.
+ */
+export const QE_PATTERNS_SCHEMA_WITHOUT_FTS = qePatternsSchema('');
 export const MINCUT_SCHEMA = `
   -- MinCut Graph Snapshots (ADR-047)
   CREATE TABLE IF NOT EXISTS mincut_snapshots (

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);
@@ -810,7 +792,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 +1075,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/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

@@ -128,6 +128,11 @@ export interface PatternSearchOptions {
     useVectorSearch?: boolean;
     /** Provenance of a pre-computed query vector. Required for semantic ranking. */
     embeddingSpaceId?: string;
+    /**
+     * Original text of a pre-computed query vector (#653). Lets FTS5 lexical
+     * scoring participate when the caller embedded the text before searching.
+     */
+    textQuery?: string;
     /**
      * Composable metadata filter expression (Task 1.2: ruvector-filter).
      * Applied post-search to refine results by domain, severity,
@@ -150,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) */
@@ -386,6 +391,12 @@ export declare class PatternStore implements IPatternStore {
      */
     searchHyperbolic(query: Float32Array | number[], k?: number): Promise<Result<PatternSearchResult[]>>;
 }
+/**
+ * Hybrid score for a hit found by both vector and FTS5 search (#653):
+ * 75% vector + 25% BM25, but lexical agreement may only raise the vector
+ * score — a weak BM25 match must not demote a near-identical vector hit.
+ */
+export declare function blendFtsScore(vectorScore: number, ftsScore: number): number;
 /**
  * Create a new pattern store instance.
  *

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);
@@ -772,18 +774,19 @@ export class PatternStore {
                 }
             }
             // FTS5 hybrid search: blend BM25 text relevance with vector similarity
-            // 75% vector score + 25% FTS5 score for patterns found by both
-            if (typeof query === 'string' && query.trim() && this.sqliteStore) {
+            // (see blendFtsScore) for patterns found by both
+            const ftsText = typeof query === 'string' ? query : options.textQuery;
+            if (ftsText?.trim() && this.sqliteStore) {
                 try {
-                    const ftsResults = this.sqliteStore.searchFTS(query, limit * 2);
+                    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) {
                             const ftsScore = ftsScoreMap.get(result.pattern.id);
                             if (ftsScore !== undefined) {
-                                result.score = 0.75 * result.score + 0.25 * ftsScore;
+                                result.score = blendFtsScore(result.score, ftsScore);
                             }
                         }
                         // Add FTS5-only results not already in vector results
@@ -792,15 +795,18 @@ export class PatternStore {
                                 continue;
                             const pattern = await this.get(ftsResult.id);
                             if (pattern && this.matchesFilters(pattern, options)) {
-                                const reuseInfo = this.calculateReuseInfo(pattern, ftsResult.ftsScore);
+                                // 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 = 0; // Lexical relevance is not vector similarity or safe reuse.
                                 results.push({
                                     pattern,
-                                    score: 0.5 * ftsResult.ftsScore, // FTS-only: exact keyword match is valuable
-                                    matchType: 'exact',
-                                    similarity: ftsResult.ftsScore,
-                                    canReuse: reuseInfo.canReuse,
-                                    estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
-                                    reuseConfidence: reuseInfo.reuseConfidence,
+                                    score: keywordScore,
+                                    matchType: 'lexical',
+                                    similarity,
+                                    canReuse: false,
+                                    estimatedTokenSavings: 0,
+                                    reuseConfidence: 0,
                                 });
                             }
                         }
@@ -812,7 +818,9 @@ export class PatternStore {
             }
             // Text search fallback or additional
             if (typeof query === 'string' || results.length < limit) {
-                const textResults = await this.searchByText(typeof query === 'string' ? query : '', options, limit - results.length);
+                // #653: with the caller's text, pad with text matches rather than
+                // unrelated patterns ranked by quality score alone.
+                const textResults = await this.searchByText(ftsText ?? '', options, limit - results.length);
                 // Deduplicate: only add text results not already present
                 const existingIds = new Set(results.map(r => r.pattern.id));
                 for (const tr of textResults) {
@@ -964,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,
                 });
             }
         }
@@ -1443,6 +1450,14 @@ export class PatternStore {
 // ============================================================================
 // Factory Functions
 // ============================================================================
+/**
+ * Hybrid score for a hit found by both vector and FTS5 search (#653):
+ * 75% vector + 25% BM25, but lexical agreement may only raise the vector
+ * score — a weak BM25 match must not demote a near-identical vector hit.
+ */
+export function blendFtsScore(vectorScore, ftsScore) {
+    return Math.max(vectorScore, 0.75 * vectorScore + 0.25 * ftsScore);
+}
 /**
  * Create a new pattern store instance.
  *

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 */
@@ -201,6 +207,12 @@ export declare function calculateQualityScore(pattern: {
  * experience-capture, and shouldPromotePattern().
  */
 export declare const PROMOTION_THRESHOLD = 3;
+/**
+ * Minimum success rate a pattern needs before it can be promoted to long-term
+ * storage. Paired with PROMOTION_THRESHOLD; `aqe init` reports both values in
+ * the generated settings so they match what the runtime enforces (#778).
+ */
+export declare const PROMOTION_MIN_SUCCESS_RATE = 0.7;
 export interface PromotionCheck {
     meetsUsageCriteria: boolean;
     meetsQualityCriteria: boolean;

package/dist/learning/qe-patterns.js

@@ -81,6 +81,12 @@ export function calculateQualityScore(pattern) {
  * experience-capture, and shouldPromotePattern().
  */
 export const PROMOTION_THRESHOLD = 3;
+/**
+ * Minimum success rate a pattern needs before it can be promoted to long-term
+ * storage. Paired with PROMOTION_THRESHOLD; `aqe init` reports both values in
+ * the generated settings so they match what the runtime enforces (#778).
+ */
+export const PROMOTION_MIN_SUCCESS_RATE = 0.7;
 /**
  * Check if pattern should be promoted to long-term storage
  * Requires 3+ successful uses as per ADR-021
@@ -92,7 +98,7 @@ export const PROMOTION_THRESHOLD = 3;
  */
 export function shouldPromotePattern(pattern, coherenceEnergy, coherenceThreshold = 0.4) {
     const meetsUsageCriteria = pattern.tier === 'short-term' && pattern.successfulUses >= PROMOTION_THRESHOLD;
-    const meetsQualityCriteria = pattern.successRate >= 0.7 && pattern.confidence >= 0.6;
+    const meetsQualityCriteria = pattern.successRate >= PROMOTION_MIN_SUCCESS_RATE && pattern.confidence >= 0.6;
     // NEW: Coherence criteria - only block if coherence energy is provided and exceeds threshold
     const meetsCoherenceCriteria = coherenceEnergy === undefined || coherenceEnergy < coherenceThreshold;
     let blockReason;

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,14 +338,20 @@ 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, {
             ...options,
+            // #653: keep the text so FTS5 hybrid scoring still runs on the vector path
+            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,
         });
     }
@@ -440,10 +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)
@@ -604,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) {