agentic-qe 3.14.4 → 3.14.6

package/dist/kernel/kernel.js

@@ -7,11 +7,12 @@ import { ALL_DOMAINS } from '../shared/types/index.js';
 import { InMemoryEventBus } from './event-bus.js';
 import { DefaultAgentCoordinator } from './agent-coordinator.js';
 import { DefaultPluginLoader } from './plugin-loader.js';
+import { formatErrorForLog } from '../logging/redaction.js';
 import { InMemoryBackend } from './memory-backend.js';
-import { HybridMemoryBackend } from './hybrid-backend.js';
+import { createKernelMemoryBackend } from './hybrid-backend.js';
 import { SemanticAntiDriftMiddleware, ToolCallSignatureTracker } from './anti-drift-middleware.js';
 import { LOOP_EVENT_TYPES } from './event-bus.js';
-import { AGENT_CONSTANTS, MEMORY_CONSTANTS } from './constants.js';
+import { AGENT_CONSTANTS } from './constants.js';
 import { findProjectRoot } from './unified-memory.js';
 import { initializeUnifiedPersistence } from './unified-persistence.js';
 import * as path from 'path';
@@ -163,16 +164,7 @@ export class QEKernelImpl {
         else {
             // Use hybrid backend for persistent storage (default)
             // All data goes to unified memory.db via UnifiedMemoryManager
-            this._memory = new HybridMemoryBackend({
-                sqlite: {
-                    path: path.join(dataDir, 'memory.db'),
-                    walMode: true,
-                    poolSize: 3,
-                    busyTimeout: MEMORY_CONSTANTS.BUSY_TIMEOUT_MS,
-                },
-                enableFallback: true,
-                defaultNamespace: 'qe-kernel',
-            });
+            this._memory = createKernelMemoryBackend(dataDir);
             // Re-create plugins with the real memory backend
             this._plugins = new DefaultPluginLoader(this._eventBus, this._memory, this._config.lazyLoading);
         }
@@ -206,6 +198,9 @@ export class QEKernelImpl {
             const pluginCache = new PluginCache({ cacheDir: pluginCacheDir });
             const pluginLifecycle = new PluginLifecycleManager({ cache: pluginCache });
             const resolution = pluginLifecycle.resolveLoadOrder();
+            for (const error of resolution.errors) {
+                console.warn(`[QEKernel] External plugin ${error.plugin}: ${error.code}: ${error.message}`);
+            }
             for (const resolved of resolution.ordered) {
                 const manifest = resolved.manifest;
                 const cachedPlugin = pluginCache.get(manifest.name, manifest.version);
@@ -232,8 +227,9 @@ export class QEKernelImpl {
                 }
             }
         }
-        catch {
-            // External plugin loading is best-effort — don't block kernel startup
+        catch (error) {
+            // External plugin loading is best-effort, but failures must be visible.
+            console.warn('[QEKernel] External plugin discovery failed:', error);
         }
         // Load plugins based on configuration
         if (!this._config.lazyLoading) {
@@ -493,7 +489,7 @@ export class QEKernelImpl {
                 plugin = await this._plugins.load(domain);
             }
             catch (error) {
-                console.error(`[QEKernel] Failed to lazy load domain ${domain}:`, error);
+                console.error(`[QEKernel] Failed to lazy load domain ${domain}:`, formatErrorForLog(error));
                 return undefined;
             }
         }
@@ -516,7 +512,7 @@ export class QEKernelImpl {
             return true;
         }
         catch (error) {
-            console.error(`[QEKernel] Failed to load domain ${domain}:`, error);
+            console.error(`[QEKernel] Failed to load domain ${domain}:`, formatErrorForLog(error));
             return false;
         }
     }

package/dist/kernel/project-root.d.ts

@@ -21,7 +21,7 @@ export declare function clearProjectRootCache(): void;
  *
  * Priority order:
  * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
- * 2. Walk up looking for the NEAREST .agentic-qe directory (existing AQE project)
+ * 2. Nearest .agentic-qe at or below the nearest .git boundary
  * 3. Walk up looking for .git directory (git repo root)
  * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
  * 5. Fallback to current working directory

package/dist/kernel/project-root.js

@@ -12,6 +12,7 @@
  * @module kernel/project-root
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 /** Module-level cache for findProjectRoot result. */
 let _cachedProjectRoot = null;
@@ -24,12 +25,17 @@ export function clearProjectRootCache() {
     _cachedProjectRoot = null;
     _cachedStartDir = null;
 }
+/** True when `dir` is `parent` or inside it. */
+function isWithin(dir, parent) {
+    const rel = path.relative(parent, dir);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
 /**
  * Find the project root by walking up the directory tree.
  *
  * Priority order:
  * 1. AQE_PROJECT_ROOT environment variable (set by MCP config or init)
- * 2. Walk up looking for the NEAREST .agentic-qe directory (existing AQE project)
+ * 2. Nearest .agentic-qe at or below the nearest .git boundary
  * 3. Walk up looking for .git directory (git repo root)
  * 4. Walk up looking for package.json WITHOUT node_modules sibling (monorepo root)
  * 5. Fallback to current working directory
@@ -47,6 +53,17 @@ export function findProjectRoot(startDir = process.cwd()) {
         return _cachedProjectRoot;
     _cachedStartDir = dir;
     const root = path.parse(dir).root;
+    // A store directly in $HOME is almost always a stray from an `aqe` run in
+    // the home directory. Outside any git repository there is no boundary to
+    // stop at, so never let it claim a descendant directory (#735/#516); an
+    // `aqe` run from $HOME itself still uses it, and AQE_PROJECT_ROOT overrides.
+    let home = null;
+    try {
+        home = path.resolve(os.homedir());
+    }
+    catch {
+        home = null;
+    }
     let checkDir = dir;
     let nearestAqeDir = null;
     let lowestGitDir = null;
@@ -55,8 +72,12 @@ export function findProjectRoot(startDir = process.cwd()) {
         // Issue #516: prefer the NEAREST (lowest) .agentic-qe, mirroring the
         // .git logic below. Keeping the topmost match let an ancestor store
         // (e.g. ~/.agentic-qe, created by any `aqe` run from $HOME) hijack
-        // every descendant project and fragment its learning into $HOME.
-        if (fs.existsSync(path.join(checkDir, '.agentic-qe'))) {
+        // every descendant project and fragment its learning into $HOME. Stop
+        // considering stores above the nearest git boundary, even when the repo
+        // has not been initialized with AQE yet.
+        const isHomeStoreAboveStart = checkDir === home && checkDir !== dir
+            && !isWithin(dir, path.join(checkDir, '.agentic-qe'));
+        if (lowestGitDir === null && !isHomeStoreAboveStart && fs.existsSync(path.join(checkDir, '.agentic-qe'))) {
             if (nearestAqeDir === null) {
                 nearestAqeDir = checkDir;
             }

package/dist/learning/embedder-identity-store.js

@@ -13,9 +13,10 @@
  * We never throw out of these helpers under expected conditions; failure
  * reasons are surfaced as thrown errors only for genuine I/O problems.
  */
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { existsSync, mkdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { findProjectRoot } from '../kernel/project-root.js';
 // `require` is unavailable in pure ESM; createRequire gives us synchronous
 // access to CommonJS modules like better-sqlite3 from the ESM build output.
 const nodeRequire = createRequire(import.meta.url);
@@ -26,8 +27,8 @@ const nodeRequire = createRequire(import.meta.url);
 function getMemoryDbPath() {
     const env = process.env.AQE_MEMORY_PATH;
     if (env && env.length > 0)
-        return env;
-    return join(process.cwd(), '.agentic-qe', 'memory.db');
+        return env === ':memory:' ? env : resolve(findProjectRoot(), env);
+    return join(findProjectRoot(), '.agentic-qe', 'memory.db');
 }
 const NAMESPACE = '_system';
 const KEY_PREFIX = 'embedder_identity:';

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,
@@ -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

@@ -30,7 +30,7 @@ import { createVectorDeltaTracker, } from '../integrations/ruvector/vector-delta
 import { createHopfieldMemory } from '../integrations/ruvector/hopfield-memory.js';
 import { createHyperbolicPatternIndex, } from './hyperbolic-pattern-index.js';
 import { PatternNullStore } from './pattern-null-store.js';
-import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
+import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 import { PatternMutationError } from './pattern-mutation-error.js';
 // ============================================================================
 // R1: HDC Fingerprint Singleton (lazy-initialized)
@@ -244,6 +244,10 @@ export class PatternStore {
      */
     async initializeHNSWInternal() {
         try {
+            // #754: resolve a configured endpoint's identity before binding HNSW.
+            if (!getActiveEmbeddingSpaceIdentity() && !this.config.embeddingSpaceId) {
+                await ensureEndpointEmbeddingSpaceIdentity();
+            }
             this.hnswSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId ?? null;
             if (!this.hnswSpaceId) {
                 throw new Error('VECTOR_SPACE_UNVERIFIED: cannot initialize HNSW without runtime provenance');
@@ -768,10 +772,11 @@ 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 existingIds = new Set(results.map(r => r.pattern.id));
@@ -779,7 +784,7 @@ export class PatternStore {
                         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
@@ -788,12 +793,19 @@ export class PatternStore {
                                 continue;
                             const pattern = await this.get(ftsResult.id);
                             if (pattern && this.matchesFilters(pattern, options)) {
-                                const reuseInfo = this.calculateReuseInfo(pattern, ftsResult.ftsScore);
+                                // #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.
+                                const keywordScore = 0.5 * ftsResult.ftsScore * ftsResult.coverage;
+                                const similarity = ftsResult.phrase ? ftsResult.ftsScore : keywordScore;
+                                const reuseInfo = this.calculateReuseInfo(pattern, similarity);
                                 results.push({
                                     pattern,
-                                    score: 0.5 * ftsResult.ftsScore, // FTS-only: exact keyword match is valuable
+                                    score: keywordScore, // FTS-only: exact keyword match is valuable
                                     matchType: 'exact',
-                                    similarity: ftsResult.ftsScore,
+                                    similarity,
                                     canReuse: reuseInfo.canReuse,
                                     estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
                                     reuseConfidence: reuseInfo.reuseConfidence,
@@ -808,7 +820,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) {
@@ -1439,6 +1453,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

@@ -201,6 +201,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.js

@@ -342,6 +342,8 @@ export class QEReasoningBank {
         }
         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
@@ -444,6 +446,7 @@ export class QEReasoningBank {
                 limit: this.config.maxRoutingCandidates,
                 domain: detectedDomains[0],
                 useVectorSearch: true,
+                textQuery: request.task,
             });
             const patterns = patternResults.success
                 ? patternResults.value.map((r) => r.pattern)

package/dist/learning/real-embeddings.d.ts

@@ -86,4 +86,12 @@ export declare function isUsingEndpoint(): boolean;
 export declare function getEndpointIdentity(): EndpointIdentity | null;
 /** Runtime-backed identity of the initialized embedding space. */
 export declare function getActiveEmbeddingSpaceIdentity(): EmbeddingSpaceIdentity | null;
+/**
+ * #754: resolve the configured endpoint's embedding-space identity before an
+ * index binder (RVF pattern store, brain.rvf dual writer, SQLite HNSW) checks
+ * its space manifest. The endpoint runtime otherwise initializes lazily on the
+ * first embed call — after the binder has already refused for the process.
+ * Returns null when no endpoint is configured, so binders stay fail-closed.
+ */
+export declare function ensureEndpointEmbeddingSpaceIdentity(): Promise<EmbeddingSpaceIdentity | null>;
 //# sourceMappingURL=real-embeddings.d.ts.map

package/dist/learning/real-embeddings.js

@@ -410,4 +410,20 @@ export function getEndpointIdentity() {
 export function getActiveEmbeddingSpaceIdentity() {
     return activeEmbeddingSpaceIdentity;
 }
+/**
+ * #754: resolve the configured endpoint's embedding-space identity before an
+ * index binder (RVF pattern store, brain.rvf dual writer, SQLite HNSW) checks
+ * its space manifest. The endpoint runtime otherwise initializes lazily on the
+ * first embed call — after the binder has already refused for the process.
+ * Returns null when no endpoint is configured, so binders stay fail-closed.
+ */
+export async function ensureEndpointEmbeddingSpaceIdentity() {
+    if (activeEmbeddingSpaceIdentity)
+        return activeEmbeddingSpaceIdentity;
+    const endpoint = process.env.AQE_EMBEDDER_ENDPOINT;
+    if (!endpoint)
+        return null;
+    await initializeModel({ endpoint, endpointToken: process.env.AQE_EMBEDDER_TOKEN });
+    return activeEmbeddingSpaceIdentity;
+}
 //# sourceMappingURL=real-embeddings.js.map

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

@@ -15,8 +15,8 @@ import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../shared/types/index.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { calculateQualityScore, validateQEPattern, mapQEDomainToAQE, PROMOTION_THRESHOLD, } from './qe-patterns.js';
-import { DEFAULT_PATTERN_STORE_CONFIG } from './pattern-store.js';
-import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
+import { DEFAULT_PATTERN_STORE_CONFIG, blendFtsScore } from './pattern-store.js';
+import { ensureEndpointEmbeddingSpaceIdentity, getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 import { verifyOrCreateEmbeddingSpaceManifest } from './embedding-space.js';
 import { PatternMutationError } from './pattern-mutation-error.js';
 // ============================================================================
@@ -75,6 +75,12 @@ export class RvfPatternStore {
             return;
         }
         try {
+            // The endpoint runtime is lazy. Resolve its executable identity before
+            // binding a new RVF index; otherwise every fresh process sees null here
+            // and permanently disables RVF even though the endpoint is configured.
+            if (!this.embeddingSpaceId && !getActiveEmbeddingSpaceIdentity()) {
+                await ensureEndpointEmbeddingSpaceIdentity();
+            }
             this.adapter = this.createAdapter(this.rvfPath, this.config.embeddingDimension);
             const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.embeddingSpaceId ?? null;
             verifyOrCreateEmbeddingSpaceManifest(this.rvfPath, activeSpaceId, this.adapter.status()?.totalVectors ?? 0);
@@ -90,9 +96,10 @@ export class RvfPatternStore {
                 this.adapter?.close();
             }
             catch { /* best effort */ }
-            console.error(`[RvfPatternStore] ERROR: RVF native init failed — vector search is DISABLED. ` +
+            console.error(`[RvfPatternStore] ERROR: RVF initialization failed — vector search is DISABLED. ` +
                 `Cause: ${this.rvfInitError}. ` +
-                `Fix: install @ruvector/rvf-node native bindings, or set useRVFPatternStore=false to use SQLite HNSW.`);
+                `Fix: check the embedder endpoint and @ruvector/rvf-node binding, ` +
+                `or set RUVECTOR_USE_RVF_PATTERN_STORE=false to use SQLite HNSW.`);
             this.adapter = null;
             this.initialized = true; // mark initialized to prevent retry loops
         }
@@ -375,22 +382,35 @@ export class RvfPatternStore {
             }
             catch { /* SQLite unavailable */ }
         }
-        // FTS5 text search fallback via SQLite
-        if (typeof query === 'string' && query.trim() && this.sqliteStore) {
+        // FTS5 hybrid search via SQLite
+        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);
                 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]));
+                for (const result of results) {
+                    const ftsScore = ftsScoreMap.get(result.pattern.id);
+                    if (ftsScore !== undefined) {
+                        result.score = blendFtsScore(result.score, ftsScore);
+                    }
+                }
                 for (const ftsResult of ftsResults) {
                     if (existingIds.has(ftsResult.id))
                         continue;
                     const pattern = await this.get(ftsResult.id);
                     if (pattern && this.matchesFilters(pattern, options)) {
-                        const reuseInfo = this.calculateReuseInfo(pattern, ftsResult.ftsScore);
+                        // 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);
                         results.push({
                             pattern,
-                            score: 0.5 * ftsResult.ftsScore,
+                            score: keywordScore,
                             matchType: 'exact',
-                            similarity: ftsResult.ftsScore,
+                            similarity,
                             canReuse: reuseInfo.canReuse,
                             estimatedTokenSavings: reuseInfo.estimatedTokenSavings,
                             reuseConfidence: reuseInfo.reuseConfidence,

package/dist/learning/sqlite-persistence.d.ts

@@ -91,12 +91,19 @@ export declare class SQLitePatternStore {
     }): QEPattern[];
     /**
      * FTS5 full-text search for patterns.
-     * Returns pattern IDs with BM25 relevance scores.
+     * Returns pattern IDs with BM25 relevance scores. `phrase` marks hits that
+     * also contain the whole query as a phrase (near-duplicate evidence).
+     * `coverage` is the fraction of distinct query terms the hit contains: an
+     * absolute measure, unlike `ftsScore`, which is relative to the best hit.
      */
     searchFTS(query: string, limit?: number): Array<{
         id: string;
         ftsScore: number;
+        phrase: boolean;
+        coverage: number;
     }>;
+    /** IDs whose FTS5 text contains the whole query as one phrase. */
+    private searchFTSPhraseIds;
     /** Last FTS5 search latency in ms, for instrumentation */
     private _lastFtsLatencyMs;
     get lastFtsLatencyMs(): number;

package/dist/learning/sqlite-persistence.js

@@ -54,6 +54,13 @@ export function hashEmbedding(text, dimension = 384) {
     }
     return embedding;
 }
+/**
+ * Lowercased letter/digit tokens with diacritics removed, approximating the
+ * FTS5 unicode61 tokenizer so query terms and stored text compare alike.
+ */
+function ftsTokens(text) {
+    return text.normalize('NFKD').replace(/\p{M}+/gu, '').toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+}
 /**
  * SQLite-based pattern persistence
  */
@@ -465,20 +472,29 @@ export class SQLitePatternStore {
     }
     /**
      * FTS5 full-text search for patterns.
-     * Returns pattern IDs with BM25 relevance scores.
+     * Returns pattern IDs with BM25 relevance scores. `phrase` marks hits that
+     * also contain the whole query as a phrase (near-duplicate evidence).
+     * `coverage` is the fraction of distinct query terms the hit contains: an
+     * absolute measure, unlike `ftsScore`, which is relative to the best hit.
      */
     searchFTS(query, limit = 20) {
         if (!this.db)
             throw new Error('Database not initialized');
         if (!query.trim())
             return [];
-        // Sanitize: wrap in double quotes to force literal phrase match,
-        // escaping any internal double quotes to prevent FTS5 syntax injection
-        const sanitized = '"' + query.replace(/"/g, '""') + '"';
+        // #653: match any query term (BM25 ranks docs matching more/rarer terms
+        // higher). A whole-query phrase almost never matched sentence-style task
+        // queries. Terms are letters/digits only, quoted, so FTS5 syntax can't leak in.
+        const terms = [...new Set(ftsTokens(query))]
+            .filter(term => term.length >= 2)
+            .slice(0, 32);
+        if (terms.length === 0)
+            return [];
+        const sanitized = terms.map(term => `"${term}"`).join(' OR ');
         const start = performance.now();
         try {
             const rows = this.db.prepare(`
-        SELECT p.id, rank AS fts_score
+        SELECT p.id, rank AS fts_score, p.name, p.description, p.pattern_type, p.qe_domain
         FROM qe_patterns_fts fts
         JOIN qe_patterns p ON p.rowid = fts.rowid
         WHERE qe_patterns_fts MATCH ?
@@ -494,16 +510,40 @@ export class SQLitePatternStore {
             // Use Math.max(maxScore, 1.0) to prevent single-result inflation:
             // without this, a single FTS5 result always normalizes to 1.0
             const maxAbsScore = Math.max(...rows.map(r => Math.abs(r.fts_score)), 1.0);
-            return rows.map(r => ({
-                id: r.id,
-                ftsScore: Math.abs(r.fts_score) / maxAbsScore,
-            }));
+            const phraseIds = rows.length > 0 ? this.searchFTSPhraseIds(query, limit) : new Set();
+            return rows.map(r => {
+                const docTerms = new Set(ftsTokens([r.name, r.description, r.pattern_type, r.qe_domain].filter(Boolean).join(' ')));
+                const matched = terms.filter(term => docTerms.has(term)).length;
+                return {
+                    id: r.id,
+                    ftsScore: Math.abs(r.fts_score) / maxAbsScore,
+                    phrase: phraseIds.has(r.id),
+                    coverage: matched / terms.length,
+                };
+            });
         }
         catch {
             // FTS5 table may not exist yet (unified DB migrated before schema update)
             return [];
         }
     }
+    /** IDs whose FTS5 text contains the whole query as one phrase. */
+    searchFTSPhraseIds(query, limit) {
+        // Whole query quoted as one phrase, internal quotes escaped (FTS5 syntax-safe)
+        const phrase = '"' + query.replace(/"/g, '""') + '"';
+        try {
+            const rows = this.db.prepare(`
+        SELECT p.id FROM qe_patterns_fts fts
+        JOIN qe_patterns p ON p.rowid = fts.rowid
+        WHERE qe_patterns_fts MATCH ?
+        LIMIT ?
+      `).all(phrase, limit);
+            return new Set(rows.map(r => r.id));
+        }
+        catch {
+            return new Set();
+        }
+    }
     /** Last FTS5 search latency in ms, for instrumentation */
     _lastFtsLatencyMs = 0;
     get lastFtsLatencyMs() { return this._lastFtsLatencyMs; }

package/dist/logging/console-logger.d.ts

@@ -69,13 +69,10 @@ export declare class ConsoleLogger implements Logger {
      */
     private mergeContext;
     /**
-     * Format context object for display
+     * Format context object for display. The context is first reduced to a
+     * redacted, bounded, cycle-free copy (#740), so it serializes safely.
      */
     private formatContext;
-    /**
-     * Create a JSON replacer that handles circular references and depth limiting
-     */
-    private createReplacer;
 }
 /**
  * No-op Logger implementation for use when logging is disabled