agentic-qe 3.14.5 → 3.14.6

package/dist/integrations/coherence/coherence-service.js

@@ -31,6 +31,31 @@
 import { DEFAULT_COHERENCE_CONFIG, DEFAULT_COHERENCE_LOGGER, WasmNotLoadedError, CoherenceError, } from './types.js';
 import { toErrorMessage, toError } from '../../shared/error-utils.js';
 import { CohomologyAdapter, SpectralAdapter, CausalAdapter, CategoryAdapter, HomotopyAdapter, WitnessAdapter, } from './engines/index.js';
+import { tallyVotes, describeLeader, describeBreakdown } from './vote-tally.js';
+/** Fallback consensus is valid only when more than this share of votes agree */
+const FALLBACK_MAJORITY_THRESHOLD = 0.6;
+/**
+ * Minimum number of voters for unanimity to be flagged as possible false
+ * consensus. Two agreeing agents are too few to call it groupthink.
+ */
+const MIN_VOTERS_FOR_FALSE_CONSENSUS = 3;
+/**
+ * False consensus means votes that *appear* unified but may not be
+ * (tool contract: "appears unified but isn't"). From verdicts alone the only
+ * observable "appears unified" signal is unanimity, so both the spectral and
+ * the fallback path flag unanimity among at least three voters as a risk.
+ * A split vote (e.g. 2 pass / 1 fail) shows its disagreement openly: it is a
+ * majority or an unverified consensus, never a false one (issue #535).
+ */
+function appearsFalselyUnified(tally) {
+    return tally.isUnanimous && tally.total >= MIN_VOTERS_FOR_FALSE_CONSENSUS;
+}
+/** e.g. "3 of 3 votes 'pass'" or "2 of 3 votes 'pass'; 2 'pass' / 1 'fail'" */
+function describeTally(tally) {
+    return tally.isUnanimous
+        ? describeLeader(tally)
+        : `${describeLeader(tally)}; ${describeBreakdown(tally)}`;
+}
 // ============================================================================
 // Coherence Service Implementation
 // ============================================================================
@@ -557,15 +582,44 @@ export class CoherenceService {
                 }
                 const collapseRisk = this.spectralAdapter.predictCollapseRisk();
                 const fiedlerValue = this.spectralAdapter.computeFiedlerValue();
+                const tally = tallyVotes(votes);
+                // When every vote agrees and carries positive confidence, the agreement
+                // graph is complete with positive edge weights, so its algebraic
+                // connectivity is necessarily > 0. A non-positive value here means the
+                // engine's eigen-solver result cannot be trusted; count votes instead
+                // of reporting a unanimous vote as a collapsed one.
+                if (tally.isUnanimous && votes.every(v => v.confidence > 0) && !(fiedlerValue > 0)) {
+                    this.logger.warn('Spectral engine returned a zero Fiedler value for a connected agreement graph, using fallback', {
+                        fiedlerValue,
+                        voteCount: votes.length,
+                    });
+                    return this.verifyConsensusWithFallback(votes, startTime);
+                }
+                // Agents are connected only when they share a verdict, so any split
+                // vote disconnects the graph (λ2 = 0) and fails verification here.
+                const isValid = collapseRisk < 0.3 && fiedlerValue > 0.1;
+                const isFalseConsensus = appearsFalselyUnified(tally);
+                let recommendation;
+                if (!isValid) {
+                    recommendation =
+                        `No verified consensus (${describeTally(tally)}): agreement-graph Fiedler value ` +
+                            `${fiedlerValue.toFixed(3)}, collapse risk ${collapseRisk.toFixed(2)}. Spawn independent reviewer.`;
+                }
+                else if (isFalseConsensus) {
+                    recommendation =
+                        `Consensus verified (${describeTally(tally)}), but unanimous agreement may indicate ` +
+                            'false consensus. Consider adding diversity.';
+                }
+                else {
+                    recommendation = `Consensus verified (${describeTally(tally)}).`;
+                }
                 return {
-                    isValid: collapseRisk < 0.3 && fiedlerValue > 0.1,
+                    isValid,
                     confidence: 1 - collapseRisk,
-                    isFalseConsensus: fiedlerValue < 0.05,
+                    isFalseConsensus,
                     fiedlerValue,
                     collapseRisk,
-                    recommendation: collapseRisk > 0.3
-                        ? 'Spawn independent reviewer'
-                        : 'Consensus verified',
+                    recommendation,
                     durationMs: Date.now() - startTime,
                     usedFallback: false,
                 };
@@ -586,30 +640,36 @@ export class CoherenceService {
      * Fallback consensus verification
      */
     verifyConsensusWithFallback(votes, startTime) {
-        // Count verdicts
-        const verdictCounts = new Map();
-        for (const vote of votes) {
-            const key = String(vote.verdict);
-            verdictCounts.set(key, (verdictCounts.get(key) || 0) + 1);
-        }
-        // Find majority
-        let maxCount = 0;
-        verdictCounts.forEach(count => {
-            maxCount = Math.max(maxCount, count);
-        });
-        const majorityRatio = maxCount / votes.length;
+        const tally = tallyVotes(votes);
+        const { majorityRatio } = tally;
         const avgConfidence = votes.reduce((sum, v) => sum + v.confidence, 0) / votes.length;
+        // Flags and text are derived from the same predicates so the
+        // recommendation can never contradict them (issue #535).
+        const isValid = majorityRatio > FALLBACK_MAJORITY_THRESHOLD;
+        const isFalseConsensus = appearsFalselyUnified(tally);
+        let recommendation;
+        if (!isValid) {
+            recommendation =
+                `No clear majority: ${describeBreakdown(tally)} across ${tally.total} votes ` +
+                    `(needs more than ${Math.round(FALLBACK_MAJORITY_THRESHOLD * 100)}% agreeing). Consider spawning additional agents.`;
+        }
+        else if (isFalseConsensus) {
+            recommendation =
+                `Unanimous consensus (${describeLeader(tally)}) may indicate false consensus. Consider adding diversity.`;
+        }
+        else if (tally.isUnanimous) {
+            recommendation = `Unanimous consensus achieved (${describeLeader(tally)}).`;
+        }
+        else {
+            recommendation = `Majority consensus achieved (${describeTally(tally)}).`;
+        }
         return {
-            isValid: majorityRatio > 0.6,
+            isValid,
             confidence: majorityRatio * avgConfidence,
-            isFalseConsensus: verdictCounts.size === 1 && votes.length > 2,
+            isFalseConsensus,
             fiedlerValue: majorityRatio, // Approximation
             collapseRisk: 1 - majorityRatio,
-            recommendation: majorityRatio < 0.6
-                ? 'No clear majority. Consider spawning additional agents.'
-                : majorityRatio === 1 && verdictCounts.size === 1
-                    ? 'Unanimous consensus may indicate false consensus. Consider adding diversity.'
-                    : 'Majority consensus achieved.',
+            recommendation,
             durationMs: Date.now() - startTime,
             usedFallback: true,
         };

package/dist/integrations/coherence/vote-tally.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Agentic QE v3 - Consensus vote tally
+ *
+ * Counts verdicts once so that every consensus flag and every
+ * recommendation string is derived from the same numbers (issue #535).
+ */
+/** Minimal vote shape needed to tally verdicts */
+export interface TallyableVote {
+    verdict: string | number | boolean;
+}
+/** Verdict counts for a set of votes */
+export interface VoteTally {
+    /** Total number of votes */
+    total: number;
+    /** Verdicts with counts, most votes first (ties ordered by verdict) */
+    counts: Array<{
+        verdict: string;
+        count: number;
+    }>;
+    /** Verdict with the most votes (first in `counts`) */
+    topVerdict: string;
+    /** Number of votes for `topVerdict` */
+    topCount: number;
+    /** topCount / total (0 when there are no votes) */
+    majorityRatio: number;
+    /** True when every vote has the same verdict */
+    isUnanimous: boolean;
+}
+/**
+ * Tally votes by verdict. Verdicts are compared by their string form,
+ * matching how consensus has always grouped them.
+ */
+export declare function tallyVotes(votes: readonly TallyableVote[]): VoteTally;
+/** e.g. "2 of 3 votes 'pass'" */
+export declare function describeLeader(tally: VoteTally): string;
+/** e.g. "2 'pass' / 1 'fail'" */
+export declare function describeBreakdown(tally: VoteTally): string;
+//# sourceMappingURL=vote-tally.d.ts.map

package/dist/integrations/coherence/vote-tally.js

@@ -0,0 +1,39 @@
+/**
+ * Agentic QE v3 - Consensus vote tally
+ *
+ * Counts verdicts once so that every consensus flag and every
+ * recommendation string is derived from the same numbers (issue #535).
+ */
+/**
+ * Tally votes by verdict. Verdicts are compared by their string form,
+ * matching how consensus has always grouped them.
+ */
+export function tallyVotes(votes) {
+    const byVerdict = new Map();
+    for (const vote of votes) {
+        const key = String(vote.verdict);
+        byVerdict.set(key, (byVerdict.get(key) ?? 0) + 1);
+    }
+    const counts = [...byVerdict.entries()]
+        .map(([verdict, count]) => ({ verdict, count }))
+        .sort((a, b) => b.count - a.count || a.verdict.localeCompare(b.verdict));
+    const top = counts[0] ?? { verdict: '', count: 0 };
+    const total = votes.length;
+    return {
+        total,
+        counts,
+        topVerdict: top.verdict,
+        topCount: top.count,
+        majorityRatio: total > 0 ? top.count / total : 0,
+        isUnanimous: counts.length === 1,
+    };
+}
+/** e.g. "2 of 3 votes 'pass'" */
+export function describeLeader(tally) {
+    return `${tally.topCount} of ${tally.total} votes '${tally.topVerdict}'`;
+}
+/** e.g. "2 'pass' / 1 'fail'" */
+export function describeBreakdown(tally) {
+    return tally.counts.map(({ verdict, count }) => `${count} '${verdict}'`).join(' / ');
+}
+//# sourceMappingURL=vote-tally.js.map

package/dist/integrations/ruvector/shared-rvf-adapter.d.ts

@@ -11,6 +11,14 @@
  * @module integrations/ruvector/shared-rvf-adapter
  */
 import type { RvfNativeAdapter, RvfCompactionResult, RvfStatus } from './rvf-native-adapter.js';
+/**
+ * The store is locked by a live process. The open ladder has already logged
+ * why it is degrading, so callers should not log it again (#574).
+ */
+export declare class RvfLiveLockError extends Error {
+    readonly lockError: unknown;
+    constructor(lockError: unknown);
+}
 /** @internal test-only seam */
 export declare function __setSharedRvfAdapterForTests(adapter: RvfNativeAdapter | null): void;
 /**
@@ -21,6 +29,19 @@ export declare function __setSharedRvfAdapterForTests(adapter: RvfNativeAdapter
  * @returns The shared adapter, or null if native bindings are unavailable
  */
 export declare function getSharedRvfAdapter(dataDir?: string, dimensions?: number): RvfNativeAdapter | null;
+/**
+ * Race-tolerant open-or-create.
+ * Tries open first (cheap, succeeds for the common case where init has
+ * already produced the file). On open failure we attempt create. On the
+ * concurrent-create loser, create itself fails with `FsyncFailed`; we
+ * retry open once more. Any final exception bubbles up to the caller.
+ *
+ * Also asserts `dim()` matches the caller-requested `dimensions` after
+ * open so silent dimension drift between releases / configs is detected
+ * — a bad-dim file is closed and create() is attempted (fail-loud rather
+ * than corrupt-silently, which would manifest as wrong vector hits later).
+ */
+declare function openOrCreateRvf(openFn: (p: string) => RvfNativeAdapter, createFn: (p: string, dim: number) => RvfNativeAdapter, rvfPath: string, dimensions: number): RvfNativeAdapter;
 export interface CompactDecision {
     shouldCompact: boolean;
     trigger: 'force' | 'size-guard' | 'dead-ratio' | 'none';
@@ -64,6 +85,8 @@ export declare function compactSharedRvfAdapter(opts?: {
  * `getSharedRvfAdapter()` which invokes it internally.
  */
 export declare function runBootCompactGuard(adapter: RvfNativeAdapter, rvfPath: string): RvfCompactionResult | null;
+/** @internal test-only seam: the open ladder with injectable open/create */
+export { openOrCreateRvf as __openOrCreateRvfForTests };
 /** Close the shared adapter and reset the singleton. */
 export declare function resetSharedRvfAdapter(): void;
 //# sourceMappingURL=shared-rvf-adapter.d.ts.map

package/dist/integrations/ruvector/shared-rvf-adapter.js

@@ -18,6 +18,18 @@ import { findProjectRoot } from '../../kernel/project-root.js';
 import { quarantineUnusableStore, isLockHeldByLiveProcess, isRvfLockHeldError, removeStaleRvfLock, readLockOwnerPid, } from './rvf-store-integrity.js';
 let sharedAdapter = null;
 let initAttempted = false;
+/**
+ * The store is locked by a live process. The open ladder has already logged
+ * why it is degrading, so callers should not log it again (#574).
+ */
+export class RvfLiveLockError extends Error {
+    lockError;
+    constructor(lockError) {
+        super(lockError instanceof Error ? lockError.message : String(lockError));
+        this.lockError = lockError;
+        this.name = 'RvfLiveLockError';
+    }
+}
 // ---------------------------------------------------------------------------
 // Test seam: allow tests to install a fake adapter without going through the
 // native binding loader. NOT part of the public API — used by tests only.
@@ -97,6 +109,9 @@ export function getSharedRvfAdapter(dataDir = '.agentic-qe', dimensions = 384) {
         return sharedAdapter;
     }
     catch (error) {
+        // Already reported by the open ladder as "locked by a live process".
+        if (error instanceof RvfLiveLockError)
+            return null;
         console.warn('[RVF] Shared adapter init failed:', error instanceof Error ? error.message : error);
         return null;
     }
@@ -137,12 +152,14 @@ function openOrCreateRvf(openFn, createFn, rvfPath, dimensions) {
     // assumption. This includes a lock owned by the current PID: another
     // in-process adapter may still hold the store, so PID equality is not proof
     // that the lock can be removed safely.
+    let liveOwner = false;
     if (!opened && isRvfLockHeldError(openErr)) {
         try {
             // eslint-disable-next-line @typescript-eslint/no-require-imports
             const fs = require('fs');
             const lockPath = `${rvfPath}.lock`;
             if (fs.existsSync(lockPath) && isLockHeldByLiveProcess(rvfPath)) {
+                liveOwner = true;
                 console.warn(`[RVF] ${rvfPath} is locked by a live process (pid ${readLockOwnerPid(rvfPath)}) — ` +
                     'not breaking the lock; degrading to SQLite for this run.');
             }
@@ -159,6 +176,11 @@ function openOrCreateRvf(openFn, createFn, rvfPath, dimensions) {
             }
         }
     }
+    // #574: a live owner means the store is busy, not missing or broken. A
+    // create on an existing path always fails and a reopen hits the same lock,
+    // so stop at the warning above instead of running Passes 2 and 3.
+    if (liveOwner)
+        throw new RvfLiveLockError(openErr);
     if (opened) {
         const actualDim = opened.dimension();
         if (actualDim === dimensions)
@@ -312,6 +334,8 @@ function formatBytes(n) {
     }
     return `${v.toFixed(i === 0 ? 0 : 1)}${units[i]}`;
 }
+/** @internal test-only seam: the open ladder with injectable open/create */
+export { openOrCreateRvf as __openOrCreateRvfForTests };
 /** Close the shared adapter and reset the singleton. */
 export function resetSharedRvfAdapter() {
     if (sharedAdapter) {

package/dist/kernel/kernel.js

@@ -7,6 +7,7 @@ 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 { createKernelMemoryBackend } from './hybrid-backend.js';
 import { SemanticAntiDriftMiddleware, ToolCallSignatureTracker } from './anti-drift-middleware.js';
@@ -488,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;
             }
         }
@@ -511,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/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

@@ -772,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));
@@ -783,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
@@ -792,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,
@@ -812,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) {
@@ -1443,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/rvf-pattern-store.js

@@ -15,7 +15,7 @@ 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 { 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';
@@ -382,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;