fix(memory-search): limit hybrid renormalization to vector-only classified media

yetval · yetval · commit 0e64b72a6915 · 2026-07-13T11:34:04.000-04:00
diff --git a/extensions/memory-core/src/memory/hybrid.test.ts b/extensions/memory-core/src/memory/hybrid.test.ts
@@ -739,4 +739,62 @@ describe("memory hybrid helpers", () => {
     expect(image?.textScore).toBeCloseTo(0.8);
     expect(image?.score ?? 0).toBeGreaterThan(0.7 * 0.95);
   });
+
+  it("keeps the established weighted score for vector-only non-media candidates when weights do not sum to one", async () => {
+    const notePath = "memory/notes.md";
+    const merged = await mergeHybridResults({
+      vectorWeight: 1,
+      textWeight: 1,
+      isNonTextMediaPath: (path) => path.endsWith(".png"),
+      vector: [
+        {
+          id: "note",
+          path: notePath,
+          startLine: 1,
+          endLine: 2,
+          source: "memory",
+          snippet: "vec-note",
+          vectorScore: 0.6,
+        },
+      ],
+      keyword: [],
+    });
+
+    const note = merged.find((r) => r.path === notePath);
+    expect(note?.score).toBeCloseTo(1 * 0.6);
+  });
+
+  it("keeps the established weighted score for both-signal non-media candidates when weights do not sum to one", async () => {
+    const notePath = "memory/notes.md";
+    const merged = await mergeHybridResults({
+      vectorWeight: 1,
+      textWeight: 1,
+      isNonTextMediaPath: (path) => path.endsWith(".png"),
+      vector: [
+        {
+          id: "note",
+          path: notePath,
+          startLine: 1,
+          endLine: 2,
+          source: "memory",
+          snippet: "vec-note",
+          vectorScore: 0.6,
+        },
+      ],
+      keyword: [
+        {
+          id: "note",
+          path: notePath,
+          startLine: 1,
+          endLine: 2,
+          source: "memory",
+          snippet: "kw-note",
+          textScore: 0.9,
+        },
+      ],
+    });
+
+    const note = merged.find((r) => r.path === notePath);
+    expect(note?.score).toBeCloseTo(1 * 0.6 + 1 * 0.9);
+  });
 });
diff --git a/extensions/memory-core/src/memory/hybrid.ts b/extensions/memory-core/src/memory/hybrid.ts
@@ -166,23 +166,24 @@ export async function mergeHybridResults(params: {
           : entry.pathScore;
     // Make fusion modality-aware: non-text media (image/audio) only carries a
     // synthetic label as text, so its keyword signal is structurally near zero.
-    // Drop the text weight for such candidates and renormalize the remaining
-    // weights so the score collapses to the vector signal on the same [0,1]
-    // scale as text candidates. Only drop the signal when the candidate also has
-    // a vector signal, so a keyword-only media hit keeps its text-weighted score.
-    // Text candidates are unchanged: their weights already sum to 1, so dividing
-    // by weightSum is a no-op. Gate the drop on a positive configured vector
-    // weight so a valid keyword match is never removed when vectorWeight is 0.
+    // For such candidates drop the text weight and renormalize by the remaining
+    // vector weight so the score collapses to the vector signal on the same
+    // [0,1] scale as text candidates. Only drop the signal when the candidate
+    // has a vector signal but no keyword signal, so a keyword-only or both-signal
+    // media hit keeps its text-weighted score. Gate the drop on a positive
+    // configured vector weight so a valid keyword match is never removed when
+    // vectorWeight is 0.
     const dropMediaTextSignal =
       entry.hasVector &&
       !entry.hasKeyword &&
       params.vectorWeight > 0 &&
       params.isNonTextMediaPath?.(entry.path) === true;
-    const effectiveTextWeight = dropMediaTextSignal ? 0 : params.textWeight;
-    const weightSum = params.vectorWeight + effectiveTextWeight;
-    const weightedContent =
-      params.vectorWeight * entry.vectorScore + effectiveTextWeight * keywordScore;
-    const contentScore = weightSum > 0 ? weightedContent / weightSum : 0;
+    // Renormalize only for the vector-only media case. Every other candidate
+    // keeps the established unnormalized weighted formula, so custom weights
+    // that do not sum to one preserve their score scale and result ordering.
+    const contentScore = dropMediaTextSignal
+      ? entry.vectorScore
+      : params.vectorWeight * entry.vectorScore + params.textWeight * keywordScore;
     const hasWeightedContentRelevance = contentScore > 0;
     // With decay enabled, reserve the lower half of an exact tier for path
     // identity and the upper half for content relevance. This lets recency beat
