agentic-qe 3.14.6 → 3.14.7

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,
                         });
                     }
                 }

package/dist/learning/sqlite-persistence.js

@@ -16,6 +16,8 @@ import { v4 as uuidv4 } from 'uuid';
 import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
+import { QE_PATTERNS_FTS_SCHEMA } from '../kernel/unified-memory-schemas.js';
+import { ensurePatternFtsInSync } from '../kernel/pattern-fts-self-heal.js';
 import { computeBatchEmbeddings, getEmbeddingDimension, isUsingEndpoint, getActiveEmbeddingSpaceIdentity, } from './real-embeddings.js';
 import { EMBEDDING_SPACE_CANARY, inspectEmbeddingSpaceRows, } from './embedding-space.js';
 import { recordPatternUsage } from './pattern-usage-recorder.js';
@@ -108,6 +110,11 @@ export class SQLitePatternStore {
                 if (this.config.foreignKeys) {
                     this.db.pragma('foreign_keys = ON');
                 }
+                // Unified mode heals on UnifiedMemoryManager open; legacy DBs get the
+                // same repair. Runs BEFORE createSchema so a missing trigger is still
+                // observable (createSchema would silently recreate it without
+                // rebuilding the drifted index). No-op on a fresh DB.
+                ensurePatternFtsInSync(this.db, { logPrefix: '[SQLitePatternStore]' });
                 // Create schema (only for legacy mode)
                 this.createSchema();
                 console.log(`[SQLitePatternStore] Initialized (legacy): ${this.config.dbPath}`);
@@ -219,30 +226,8 @@ export class SQLitePatternStore {
       CREATE UNIQUE INDEX IF NOT EXISTS idx_patterns_unique_name_domain_type
         ON qe_patterns(name, qe_domain, pattern_type);
 
-      -- 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 (shared DDL)
+      ${QE_PATTERNS_FTS_SCHEMA}
 
       -- Indexes for performance
       CREATE INDEX IF NOT EXISTS idx_patterns_domain ON qe_patterns(qe_domain);