fix(memory-core): preserve hybrid fallback ordering

yu-xin-c · yu-xin-c · commit c461225bb8f0 · 2026-07-21T13:36:53.000+08:00
diff --git a/extensions/memory-core/src/memory/index.test.ts b/extensions/memory-core/src/memory/index.test.ts
@@ -1819,7 +1819,6 @@ describe("memory index", () => {
 
   it("preserves keyword-only hybrid hits alongside strict vector results", async () => {
     const cfg = createCfg({
-      storePath: path.join(workspaceDir, "index-hybrid-keyword-with-strict-vector.sqlite"),
       minScore: 0.35,
       hybrid: { enabled: true, vectorWeight: 0.7, textWeight: 0.3 },
     });
@@ -1871,6 +1870,97 @@ describe("memory index", () => {
     }
   });
 
+  it("keeps overlapping keyword-backed hybrid hits when all scores are below minScore", async () => {
+    const cfg = createCfg({
+      minScore: 0.35,
+      hybrid: { enabled: true, vectorWeight: 0.7, textWeight: 0.3 },
+    });
+    const manager = await getFreshManager(cfg);
+    try {
+      const overlappingResult = {
+        path: "memory/overlap.md",
+        startLine: 3,
+        endLine: 4,
+        source: "memory" as const,
+        snippet: "overlap keyword vector",
+        score: 0.2,
+        vectorScore: 0.1,
+        textScore: 0.5,
+      };
+      const selectHybridSearchResults = Reflect.get(manager, "selectHybridSearchResults") as (
+        merged: Array<typeof overlappingResult>,
+        keywordResults: Array<typeof overlappingResult & { id: string }>,
+        maxResults: number,
+        minScore: number,
+      ) => Array<typeof overlappingResult>;
+
+      const results = selectHybridSearchResults.call(
+        manager,
+        [overlappingResult],
+        [{ ...overlappingResult, id: "overlap" }],
+        10,
+        0.35,
+      );
+
+      expect(results.map((result) => result.path)).toStrictEqual(["memory/overlap.md"]);
+      expect(results[0]?.vectorScore).toBeGreaterThan(0);
+      expect(results[0]?.textScore).toBeGreaterThan(0);
+    } finally {
+      await manager.close?.();
+    }
+  });
+
+  it("preserves hybrid merger order when retaining keyword-only hits", async () => {
+    const cfg = createCfg({
+      minScore: 0.35,
+      hybrid: { enabled: true, vectorWeight: 0.7, textWeight: 0.3 },
+    });
+    const manager = await getFreshManager(cfg);
+    try {
+      const keywordOnlyResult = {
+        path: "memory/keyword-first.md",
+        startLine: 2,
+        endLine: 2,
+        source: "memory" as const,
+        snippet: "keyword first",
+        score: 0.3,
+        vectorScore: 0,
+        textScore: 1,
+      };
+      const strictVectorResult = {
+        path: "memory/vector-second.md",
+        startLine: 1,
+        endLine: 1,
+        source: "memory" as const,
+        snippet: "strict vector second",
+        score: 0.63,
+        vectorScore: 0.9,
+        textScore: 0,
+      };
+      const selectHybridSearchResults = Reflect.get(manager, "selectHybridSearchResults") as (
+        merged: Array<typeof keywordOnlyResult>,
+        keywordResults: Array<typeof keywordOnlyResult & { id: string }>,
+        maxResults: number,
+        minScore: number,
+      ) => Array<typeof keywordOnlyResult>;
+
+      const results = selectHybridSearchResults.call(
+        manager,
+        [keywordOnlyResult, strictVectorResult],
+        [{ ...keywordOnlyResult, id: "keyword-only" }],
+        10,
+        0.35,
+      );
+
+      expect(results.map((result) => result.path)).toStrictEqual([
+        "memory/keyword-first.md",
+        "memory/vector-second.md",
+      ]);
+    } finally {
+      await manager.close?.();
+    }
+  });
+
   it("reports vector availability after probe", async () => {
     const cfg = createCfg({ vectorEnabled: true });
     const manager = await getPersistentManager(cfg);
diff --git a/extensions/memory-core/src/memory/manager.ts b/extensions/memory-core/src/memory/manager.ts
@@ -917,23 +917,35 @@ export class MemoryIndexManager extends MemoryManagerEmbeddingOps implements Mem
       return strict.slice(0, maxResults);
     }
 
-    // Hybrid weighting can put valid keyword-only FTS hits below minScore.
-    // Preserve those lexical hits even when another vector result is strict.
     const keywordKeys = new Set(keywordResults.map((entry) => memoryResultRangeKey(entry)));
-    const keywordOnly = merged.filter(
-      (entry) => entry.vectorScore === 0 && keywordKeys.has(memoryResultRangeKey(entry)),
-    );
+    if (strict.length === 0) {
+      // Keep the original relaxed keyword-backed fallback for overlapping
+      // hybrid hits whose weighted score falls below minScore.
+      const relaxedMinScore = 0;
+      return this.selectScoredResults(
+        merged.filter((entry) => keywordKeys.has(memoryResultRangeKey(entry))),
+        maxResults,
+        minScore,
+        relaxedMinScore,
+      );
+    }
+
+    // Hybrid weighting can put valid keyword-only FTS hits below minScore.
+    // Preserve those lexical hits without disturbing mergeHybridResults order.
     const seen = new Set<string>();
-    const deduped: HybridMergedSearchResult[] = [];
-    for (const entry of [...strict, ...keywordOnly]) {
+    const selected: HybridMergedSearchResult[] = [];
+    for (const entry of merged) {
       const key = memoryResultRangeKey(entry);
       if (seen.has(key)) {
         continue;
       }
-      seen.add(key);
-      deduped.push(entry);
+      const keywordOnly = entry.vectorScore === 0 && keywordKeys.has(key);
+      if (entry.score >= minScore || keywordOnly) {
+        seen.add(key);
+        selected.push(entry);
+      }
     }
-    return deduped.toSorted((a, b) => b.score - a.score).slice(0, maxResults);
+    return selected.slice(0, maxResults);
   }
 
   private selectScoredResults<T extends MemorySearchResult & { score: number }>(
