@hanhnd/agent-kit 1.0.37 → 1.0.38

package/dist/cli.js

@@ -15036,6 +15036,9 @@ var DEFAULT_MEMORY_CONFIG = {
 var LOCK_RETRY_MS = 50;
 var LOCK_TIMEOUT_MS = 500;
 var RRF_K = 60;
+var FETCH_MULTIPLIER = 4;
+var RECENCY_WEIGHT = 0.5;
+var DENSE_SCORE_FLOOR = 0.2;
 
 // src/core/config/index.ts
 function resolveMemoryConfig(settings, workspaceRoot) {
@@ -15456,6 +15459,7 @@ var MemoryStore = class {
     return 0;
   }
   upsert(chunks, embeddings) {
+    const deleteChunk = this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`);
     const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
         (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
@@ -15466,7 +15470,7 @@ var MemoryStore = class {
         const chunk = chunks[i];
         try {
           const vectorBinding = this.toVectorBinding(embeddings[i]);
-          this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
+          deleteChunk.run(chunk.id);
           insertChunk.run(
             chunk.id,
             chunk.source,
@@ -15495,11 +15499,10 @@ var MemoryStore = class {
     if (!embedding) throw new Error("missing embedding");
     if (!(embedding instanceof Float32Array)) throw new Error("missing embedding");
     if (embedding.length !== this.config.vectorDimension) throw new Error("embedding dimension mismatch");
-    const values = Array.from(embedding, (value) => {
-      if (!Number.isFinite(value)) throw new Error("embedding contains non-finite value");
-      return value;
-    });
-    return JSON.stringify(values);
+    for (let i = 0; i < embedding.length; i++) {
+      if (!Number.isFinite(embedding[i])) throw new Error("embedding contains non-finite value");
+    }
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
   }
   normalizeVectorDistance(distance) {
     if (distance <= 0) return 1;
@@ -15855,7 +15858,7 @@ var MemoryIndexer = class {
     return totals;
   }
   async search(query, topK) {
-    const fetchLimit = topK * 2;
+    const fetchLimit = topK * FETCH_MULTIPLIER;
     let denseResults = [];
     if (this.store.vecAvailable) {
       try {
@@ -15866,30 +15869,50 @@ var MemoryIndexer = class {
       }
     }
     const bm25Results = this.store.searchBm25(query, fetchLimit);
-    const bm25Ids = new Set(bm25Results.map((result) => result.id));
-    if (bm25Ids.size > 0) {
-      denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
-    }
+    const denseIds = new Set(denseResults.map((r) => r.id));
+    const bm25Ids = new Set(bm25Results.map((r) => r.id));
+    const unionIds = /* @__PURE__ */ new Set([...denseIds, ...bm25Ids]);
+    const denseRetrievalScore = new Map(denseResults.map((r) => [r.id, r.score]));
+    const unionArray = [...unionIds];
+    const chunks = this.store.getChunksByIds(unionArray);
+    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+    const unionIndexOf = new Map(unionArray.map((id, idx) => [id, idx]));
+    const recencyOrdered = [...unionArray].sort((a, b) => {
+      const mtimeA = chunkMap.get(a)?.fileMtimeAt ?? 0;
+      const mtimeB = chunkMap.get(b)?.fileMtimeAt ?? 0;
+      if (mtimeB !== mtimeA) return mtimeB - mtimeA;
+      return (unionIndexOf.get(a) ?? 0) - (unionIndexOf.get(b) ?? 0);
+    });
     const scoreMap = /* @__PURE__ */ new Map();
     denseResults.forEach((r, rank) => {
-      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
+      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0, recency: 0 });
     });
     bm25Results.forEach((r, rank) => {
-      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0 };
+      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0, recency: 0 };
       entry.bm25 = 1 / (RRF_K + rank + 1);
       scoreMap.set(r.id, entry);
     });
-    const hasDense = this.store.vecAvailable && denseResults.length > 0;
-    const numRetrievers = hasDense ? 2 : 1;
-    const maxScore = numRetrievers / (RRF_K + 1);
+    recencyOrdered.forEach((id, rank) => {
+      const entry = scoreMap.get(id);
+      if (!entry) return;
+      entry.recency = RECENCY_WEIGHT * (1 / (RRF_K + rank + 1));
+    });
+    const denseActive = denseResults.length > 0;
+    const bm25Active = bm25Results.length > 0;
+    const recencyActive = unionIds.size > 0;
+    const maxScore = ((denseActive ? 1 : 0) + (bm25Active ? 1 : 0) + (recencyActive ? RECENCY_WEIGHT : 0)) / (RRF_K + 1);
     const ranked = [...scoreMap.entries()].map(([id, scores]) => ({
       id,
-      totalScore: scores.dense + scores.bm25,
+      totalScore: scores.dense + scores.bm25 + scores.recency,
       hasDense: scores.dense > 0,
-      hasBm25: scores.bm25 > 0
-    })).sort((a, b) => b.totalScore - a.totalScore);
-    const chunks = this.store.getChunksByIds(ranked.map((r) => r.id));
-    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+      hasBm25: scores.bm25 > 0,
+      isDenseOnly: denseIds.has(id) && !bm25Ids.has(id)
+    })).filter((candidate) => {
+      if (!candidate.isDenseOnly) return true;
+      const retrieval = denseRetrievalScore.get(candidate.id);
+      if (retrieval === void 0) return true;
+      return retrieval >= DENSE_SCORE_FLOOR;
+    }).sort((a, b) => b.totalScore - a.totalScore);
     const results = [];
     const seenSources = /* @__PURE__ */ new Set();
     for (const r of ranked) {

package/dist/server.js

@@ -35920,6 +35920,9 @@ var DEFAULT_MEMORY_CONFIG = {
 var LOCK_RETRY_MS = 50;
 var LOCK_TIMEOUT_MS = 500;
 var RRF_K = 60;
+var FETCH_MULTIPLIER = 4;
+var RECENCY_WEIGHT = 0.5;
+var DENSE_SCORE_FLOOR = 0.2;
 
 // src/utils/files.ts
 import * as fs from "node:fs";
@@ -37093,7 +37096,7 @@ var MemoryIndexer = class {
     return totals;
   }
   async search(query, topK) {
-    const fetchLimit = topK * 2;
+    const fetchLimit = topK * FETCH_MULTIPLIER;
     let denseResults = [];
     if (this.store.vecAvailable) {
       try {
@@ -37104,30 +37107,50 @@ var MemoryIndexer = class {
       }
     }
     const bm25Results = this.store.searchBm25(query, fetchLimit);
-    const bm25Ids = new Set(bm25Results.map((result) => result.id));
-    if (bm25Ids.size > 0) {
-      denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
-    }
+    const denseIds = new Set(denseResults.map((r) => r.id));
+    const bm25Ids = new Set(bm25Results.map((r) => r.id));
+    const unionIds = /* @__PURE__ */ new Set([...denseIds, ...bm25Ids]);
+    const denseRetrievalScore = new Map(denseResults.map((r) => [r.id, r.score]));
+    const unionArray = [...unionIds];
+    const chunks = this.store.getChunksByIds(unionArray);
+    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+    const unionIndexOf = new Map(unionArray.map((id, idx) => [id, idx]));
+    const recencyOrdered = [...unionArray].sort((a, b) => {
+      const mtimeA = chunkMap.get(a)?.fileMtimeAt ?? 0;
+      const mtimeB = chunkMap.get(b)?.fileMtimeAt ?? 0;
+      if (mtimeB !== mtimeA) return mtimeB - mtimeA;
+      return (unionIndexOf.get(a) ?? 0) - (unionIndexOf.get(b) ?? 0);
+    });
     const scoreMap = /* @__PURE__ */ new Map();
     denseResults.forEach((r, rank) => {
-      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
+      scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0, recency: 0 });
     });
     bm25Results.forEach((r, rank) => {
-      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0 };
+      const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0, recency: 0 };
       entry.bm25 = 1 / (RRF_K + rank + 1);
       scoreMap.set(r.id, entry);
     });
-    const hasDense = this.store.vecAvailable && denseResults.length > 0;
-    const numRetrievers = hasDense ? 2 : 1;
-    const maxScore = numRetrievers / (RRF_K + 1);
+    recencyOrdered.forEach((id, rank) => {
+      const entry = scoreMap.get(id);
+      if (!entry) return;
+      entry.recency = RECENCY_WEIGHT * (1 / (RRF_K + rank + 1));
+    });
+    const denseActive = denseResults.length > 0;
+    const bm25Active = bm25Results.length > 0;
+    const recencyActive = unionIds.size > 0;
+    const maxScore = ((denseActive ? 1 : 0) + (bm25Active ? 1 : 0) + (recencyActive ? RECENCY_WEIGHT : 0)) / (RRF_K + 1);
     const ranked = [...scoreMap.entries()].map(([id, scores]) => ({
       id,
-      totalScore: scores.dense + scores.bm25,
+      totalScore: scores.dense + scores.bm25 + scores.recency,
       hasDense: scores.dense > 0,
-      hasBm25: scores.bm25 > 0
-    })).sort((a, b) => b.totalScore - a.totalScore);
-    const chunks = this.store.getChunksByIds(ranked.map((r) => r.id));
-    const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+      hasBm25: scores.bm25 > 0,
+      isDenseOnly: denseIds.has(id) && !bm25Ids.has(id)
+    })).filter((candidate) => {
+      if (!candidate.isDenseOnly) return true;
+      const retrieval = denseRetrievalScore.get(candidate.id);
+      if (retrieval === void 0) return true;
+      return retrieval >= DENSE_SCORE_FLOOR;
+    }).sort((a, b) => b.totalScore - a.totalScore);
     const results = [];
     const seenSources = /* @__PURE__ */ new Set();
     for (const r of ranked) {
@@ -37321,6 +37344,7 @@ var MemoryStore = class {
     return 0;
   }
   upsert(chunks, embeddings) {
+    const deleteChunk = this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`);
     const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
         (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
@@ -37331,7 +37355,7 @@ var MemoryStore = class {
         const chunk = chunks[i];
         try {
           const vectorBinding = this.toVectorBinding(embeddings[i]);
-          this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
+          deleteChunk.run(chunk.id);
           insertChunk.run(
             chunk.id,
             chunk.source,
@@ -37360,11 +37384,10 @@ var MemoryStore = class {
     if (!embedding) throw new Error("missing embedding");
     if (!(embedding instanceof Float32Array)) throw new Error("missing embedding");
     if (embedding.length !== this.config.vectorDimension) throw new Error("embedding dimension mismatch");
-    const values = Array.from(embedding, (value) => {
-      if (!Number.isFinite(value)) throw new Error("embedding contains non-finite value");
-      return value;
-    });
-    return JSON.stringify(values);
+    for (let i = 0; i < embedding.length; i++) {
+      if (!Number.isFinite(embedding[i])) throw new Error("embedding contains non-finite value");
+    }
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
   }
   normalizeVectorDistance(distance) {
     if (distance <= 0) return 1;

package/dist/services/memory/constants.d.ts

@@ -4,3 +4,6 @@ export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
 export declare const LOCK_RETRY_MS = 50;
 export declare const LOCK_TIMEOUT_MS = 500;
 export declare const RRF_K = 60;
+export declare const FETCH_MULTIPLIER = 4;
+export declare const RECENCY_WEIGHT = 0.5;
+export declare const DENSE_SCORE_FLOOR = 0.2;

package/dist/services/memory/constants.js

@@ -16,3 +16,9 @@ export const DEFAULT_MEMORY_CONFIG = {
 export const LOCK_RETRY_MS = 50;
 export const LOCK_TIMEOUT_MS = 500;
 export const RRF_K = 60;
+// Tunable starting default: fetchLimit = topK * FETCH_MULTIPLIER (was hardcoded topK * 2)
+export const FETCH_MULTIPLIER = 4;
+// Tunable starting default: weight on the recency RRF channel; < 1 so recency cannot outrank a dual-channel durable hit
+export const RECENCY_WEIGHT = 0.5;
+// Tunable starting default: min dense retrieval score [0,1] for a dense-only candidate to survive (permissive start)
+export const DENSE_SCORE_FLOOR = 0.2;

package/dist/services/memory/indexer.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { chunkMarkdown } from './chunker.js';
-import { LOCK_RETRY_MS, LOCK_TIMEOUT_MS, RRF_K } from './constants.js';
+import { DENSE_SCORE_FLOOR, FETCH_MULTIPLIER, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, RECENCY_WEIGHT, RRF_K, } from './constants.js';
 import { acquireLock, releaseLock } from '../../utils/files.js';
 export function deriveSourceType(source) {
     if (source.startsWith('compiled/provisional/conversation-digests/'))
@@ -118,7 +118,8 @@ export class MemoryIndexer {
         return totals;
     }
     async search(query, topK) {
-        const fetchLimit = topK * 2;
+        // Task 2.2: overfetch to supply enough distinct sources after per-source dedup
+        const fetchLimit = topK * FETCH_MULTIPLIER;
         let denseResults = [];
         if (this.store.vecAvailable) {
             try {
@@ -130,32 +131,65 @@ export class MemoryIndexer {
             }
         }
         const bm25Results = this.store.searchBm25(query, fetchLimit);
-        const bm25Ids = new Set(bm25Results.map((result) => result.id));
-        if (bm25Ids.size > 0) {
-            denseResults = denseResults.filter((result) => bm25Ids.has(result.id));
-        }
+        // Task 2.1: candidate set = dense ∪ bm25 — no intersection filter
+        const denseIds = new Set(denseResults.map((r) => r.id));
+        const bm25Ids = new Set(bm25Results.map((r) => r.id));
+        const unionIds = new Set([...denseIds, ...bm25Ids]);
+        // Task 2.5: preserve raw dense retrieval scores [0,1] for the precision floor check
+        const denseRetrievalScore = new Map(denseResults.map((r) => [r.id, r.score]));
+        // Task 2.3: fetch all union candidates once — supplies recency mtime AND final content (no second DB call)
+        const unionArray = [...unionIds];
+        const chunks = this.store.getChunksByIds(unionArray);
+        const chunkMap = new Map(chunks.map((c) => [c.id, c]));
+        // Task 2.3: recency channel — rank union by fileMtimeAt DESC; stable tiebreak on union insertion order
+        const unionIndexOf = new Map(unionArray.map((id, idx) => [id, idx]));
+        const recencyOrdered = [...unionArray].sort((a, b) => {
+            const mtimeA = chunkMap.get(a)?.fileMtimeAt ?? 0;
+            const mtimeB = chunkMap.get(b)?.fileMtimeAt ?? 0;
+            if (mtimeB !== mtimeA)
+                return mtimeB - mtimeA;
+            return (unionIndexOf.get(a) ?? 0) - (unionIndexOf.get(b) ?? 0);
+        });
+        // RRF score accumulation: dense + bm25 + weighted recency channels
         const scoreMap = new Map();
         denseResults.forEach((r, rank) => {
-            scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0 });
+            scoreMap.set(r.id, { dense: 1 / (RRF_K + rank + 1), bm25: 0, recency: 0 });
         });
         bm25Results.forEach((r, rank) => {
-            const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0 };
+            const entry = scoreMap.get(r.id) ?? { dense: 0, bm25: 0, recency: 0 };
             entry.bm25 = 1 / (RRF_K + rank + 1);
             scoreMap.set(r.id, entry);
         });
-        const hasDense = this.store.vecAvailable && denseResults.length > 0;
-        const numRetrievers = hasDense ? 2 : 1;
-        const maxScore = numRetrievers / (RRF_K + 1);
+        recencyOrdered.forEach((id, rank) => {
+            const entry = scoreMap.get(id);
+            if (!entry)
+                return;
+            entry.recency = RECENCY_WEIGHT * (1 / (RRF_K + rank + 1));
+        });
+        // Task 2.4: active-channel normalization — maxScore sums weights of channels that produced ≥1 result
+        const denseActive = denseResults.length > 0;
+        const bm25Active = bm25Results.length > 0;
+        const recencyActive = unionIds.size > 0;
+        const maxScore = ((denseActive ? 1 : 0) + (bm25Active ? 1 : 0) + (recencyActive ? RECENCY_WEIGHT : 0)) / (RRF_K + 1);
+        // Task 2.5: build ranked list, dropping dense-only candidates below the precision floor
         const ranked = [...scoreMap.entries()]
             .map(([id, scores]) => ({
             id,
-            totalScore: scores.dense + scores.bm25,
+            totalScore: scores.dense + scores.bm25 + scores.recency,
             hasDense: scores.dense > 0,
             hasBm25: scores.bm25 > 0,
+            isDenseOnly: denseIds.has(id) && !bm25Ids.has(id),
         }))
+            .filter((candidate) => {
+            if (!candidate.isDenseOnly)
+                return true;
+            const retrieval = denseRetrievalScore.get(candidate.id);
+            // Only drop when a dense retrieval score exists and is below the floor
+            if (retrieval === undefined)
+                return true;
+            return retrieval >= DENSE_SCORE_FLOOR;
+        })
             .sort((a, b) => b.totalScore - a.totalScore);
-        const chunks = this.store.getChunksByIds(ranked.map((r) => r.id));
-        const chunkMap = new Map(chunks.map((c) => [c.id, c]));
         const results = [];
         const seenSources = new Set();
         for (const r of ranked) {

package/dist/services/memory/indexer.test.js

@@ -266,8 +266,10 @@ describe('MemoryIndexer', () => {
             fs.rmSync(testDir, { recursive: true, force: true });
         }
     });
-    test('search does not include dense-only results when BM25 has matches', async () => {
-        const testCfg = makeConfig('/tmp/search-dense-filter');
+    // Task 3.1: Rewrite — asserts union behavior (previously asserted the removed intersection filter).
+    // BC1 + BC2: dense-only high-score candidate surfaces; dual-channel hit ranks first.
+    test('search includes high-score dense-only results alongside BM25 matches', async () => {
+        const testCfg = makeConfig('/tmp/search-union-behavior');
         const chunks = [
             {
                 id: 'preference-1',
@@ -291,7 +293,7 @@ describe('MemoryIndexer', () => {
         const fakeStore = {
             vecAvailable: true,
             searchDense: () => [
-                { id: 'dense-only-1', score: 0.99 },
+                { id: 'dense-only-1', score: 0.99 }, // score >= DENSE_SCORE_FLOOR (0.2) → survives floor
                 { id: 'preference-1', score: 0.98 },
             ],
             searchBm25: () => [{ id: 'preference-1', score: 1 }],
@@ -299,8 +301,361 @@ describe('MemoryIndexer', () => {
         };
         const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
         const results = await testIndexer.search('personal likes and preferences of the user', 5);
-        assert.deepEqual(results.map((result) => result.chunk.id), ['preference-1']);
+        const resultIds = results.map((r) => r.chunk.id);
+        assert.ok(resultIds.includes('preference-1'), `Expected preference-1 in results, got: ${resultIds.join(', ')}`);
+        assert.ok(resultIds.includes('dense-only-1'), `Expected dense-only-1 in results, got: ${resultIds.join(', ')}`);
+        assert.equal(results[0].chunk.id, 'preference-1', 'dual-channel hit must rank first');
         assert.equal(results[0].retriever, 'both');
+        const denseOnlyResult = results.find((r) => r.chunk.id === 'dense-only-1');
+        assert.ok(denseOnlyResult, 'dense-only-1 must be present in results');
+        assert.equal(denseOnlyResult.retriever, 'dense');
+    });
+    // Task 3.2 — Regression tests BC1–BC9
+    // BC3: durable dual-channel memory ranks above a newer single-channel chunk despite lower recency score
+    test('BC3: durable dual-channel chunk ranks above newer single-channel chunk', async () => {
+        const testCfg = makeConfig('/tmp/bc3-durable-vs-recent');
+        const chunks = [
+            {
+                id: 'durable-1',
+                source: 'compiled/preferences.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'I prefer dark mode',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 100, // old mtime
+            },
+            {
+                id: 'recent-1',
+                source: 'compiled/entities/meeting.md',
+                heading: 'Meeting',
+                headingLevel: 1,
+                content: 'Meeting notes from today',
+                lineStart: 1,
+                lineEnd: 2,
+                fileMtimeAt: 9_999_999_999_999, // very new mtime
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            searchDense: () => [{ id: 'durable-1', score: 0.9 }],
+            searchBm25: () => [
+                { id: 'durable-1', score: 1 }, // rank 0 in bm25
+                { id: 'recent-1', score: 0.8 }, // rank 1 in bm25 — newer mtime but single bm25 channel
+            ],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('preferences', 5);
+        assert.ok(results.length >= 2, `Expected at least 2 results, got ${results.length}`);
+        assert.equal(results[0].chunk.id, 'durable-1', 'dual-channel durable memory must rank above newer single-channel chunk');
+        assert.equal(results[0].retriever, 'both');
+        const recentResult = results.find((r) => r.chunk.id === 'recent-1');
+        assert.ok(recentResult, 'recent-1 must still surface');
+    });
+    // BC4: search returns dense results when BM25 is empty, with recency channel applied
+    test('BC4: search returns dense results and applies recency when BM25 has no matches', async () => {
+        const testCfg = makeConfig('/tmp/bc4-dense-only-recency');
+        const chunks = [
+            {
+                id: 'semantic-old',
+                source: 'compiled/concepts/topic.md',
+                heading: 'Topic',
+                headingLevel: 1,
+                content: 'Concept about topic',
+                lineStart: 1,
+                lineEnd: 2,
+                fileMtimeAt: 1, // very old
+            },
+            {
+                id: 'semantic-new',
+                source: 'compiled/entities/recent-entity.md',
+                heading: 'Recent',
+                headingLevel: 1,
+                content: 'Recent entity content',
+                lineStart: 1,
+                lineEnd: 2,
+                fileMtimeAt: 9_999_999_999_999, // very new
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            searchDense: () => [
+                { id: 'semantic-old', score: 0.9 }, // dense rank 0
+                { id: 'semantic-new', score: 0.85 }, // dense rank 1
+            ],
+            searchBm25: () => [],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('topic', 5);
+        assert.ok(results.length >= 2, `Expected at least 2 dense results, got ${results.length}`);
+        const ids = results.map((r) => r.chunk.id);
+        assert.ok(ids.includes('semantic-old'), 'semantic-old must be present');
+        assert.ok(ids.includes('semantic-new'), 'semantic-new must be present');
+        for (const result of results) {
+            assert.equal(result.retriever, 'dense', `Expected retriever 'dense', got '${result.retriever}'`);
+            assert.ok(result.score > 0, 'Normalized score must be positive');
+        }
+    });
+    // BC5: dense channel unavailable — bm25 results returned with finite normalized score, no throw
+    test('BC5: bm25 results are returned with normalized score when dense channel is unavailable', async () => {
+        const testCfg = makeConfig('/tmp/bc5-dense-unavailable');
+        const chunks = [
+            {
+                id: 'keyword-1',
+                source: 'compiled/concepts/keyword.md',
+                heading: 'Keyword',
+                headingLevel: 1,
+                content: 'Keyword concept content',
+                lineStart: 1,
+                lineEnd: 2,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: false,
+            searchBm25: () => [{ id: 'keyword-1', score: 1 }],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('keyword', 5);
+        assert.equal(results.length, 1, 'Must return bm25 result when dense is unavailable');
+        assert.equal(results[0].chunk.id, 'keyword-1');
+        assert.equal(results[0].retriever, 'bm25');
+        assert.ok(Number.isFinite(results[0].score), 'Score must be finite');
+        assert.ok(results[0].score >= 0 && results[0].score <= 1, `Score must be in [0,1], got ${results[0].score}`);
+    });
+    // BC6: both channels empty → search returns []
+    test('BC6: search returns empty array when both dense and bm25 channels are empty', async () => {
+        const testCfg = makeConfig('/tmp/bc6-both-empty');
+        const fakeStore = {
+            vecAvailable: false,
+            searchBm25: () => [],
+            getChunksByIds: () => [],
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('anything', 5);
+        assert.deepEqual(results, []);
+    });
+    // BC7: per-source dedup yields up to topK distinct sources even when one source dominates the pool
+    test('BC7: per-source dedup yields topK distinct sources when one source dominates the pool', async () => {
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bc7-overfetch-'));
+        const testCfg = makeConfig(path.join(testDir, 'wiki'));
+        const allChunks = [
+            {
+                id: 'dom-1',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 1',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'dom-2',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 2',
+                lineStart: 2,
+                lineEnd: 2,
+            },
+            {
+                id: 'dom-3',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 3',
+                lineStart: 3,
+                lineEnd: 3,
+            },
+            {
+                id: 'dom-4',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 4',
+                lineStart: 4,
+                lineEnd: 4,
+            },
+            {
+                id: 'dom-5',
+                source: 'compiled/entities/dominant.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'dom 5',
+                lineStart: 5,
+                lineEnd: 5,
+            },
+            {
+                id: 'src-b-1',
+                source: 'compiled/entities/source-b.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'source b',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'src-c-1',
+                source: 'compiled/entities/source-c.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'source c',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: false,
+            searchBm25: () => [
+                { id: 'dom-1', score: 5 },
+                { id: 'dom-2', score: 4.9 },
+                { id: 'dom-3', score: 4.8 },
+                { id: 'dom-4', score: 4.7 },
+                { id: 'dom-5', score: 4.6 },
+                { id: 'src-b-1', score: 3 },
+                { id: 'src-c-1', score: 2 },
+            ],
+            getChunksByIds: (ids) => allChunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        try {
+            const entitiesDir = path.join(testCfg.wikiDir, 'compiled', 'entities');
+            fs.mkdirSync(entitiesDir, { recursive: true });
+            fs.writeFileSync(path.join(entitiesDir, 'dominant.md'), 'dominant content', 'utf8');
+            fs.writeFileSync(path.join(entitiesDir, 'source-b.md'), 'source b content', 'utf8');
+            fs.writeFileSync(path.join(entitiesDir, 'source-c.md'), 'source c content', 'utf8');
+            const results = await testIndexer.search('query', 3);
+            assert.equal(results.length, 3, `Expected 3 results, got ${results.length}`);
+            const sources = results.map((r) => r.chunk.source);
+            const uniqueSources = new Set(sources);
+            assert.equal(uniqueSources.size, 3, 'Each result must be from a distinct source');
+            assert.ok(sources.includes('compiled/entities/dominant.md'), 'dominant source must be present');
+            assert.ok(sources.includes('compiled/entities/source-b.md'), 'source-b must be present');
+            assert.ok(sources.includes('compiled/entities/source-c.md'), 'source-c must be present');
+        }
+        finally {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    // BC8: dense-only candidate below DENSE_SCORE_FLOOR (0.2) is dropped; at/above floor is kept; bm25-only never dropped
+    test('BC8: dense-only candidate below DENSE_SCORE_FLOOR is dropped; bm25-only and above-floor are kept', async () => {
+        const testCfg = makeConfig('/tmp/bc8-floor');
+        const chunks = [
+            {
+                id: 'below-floor',
+                source: 'compiled/entities/below.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'below floor dense',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'above-floor',
+                source: 'compiled/entities/above.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'above floor dense',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'bm25-overlap',
+                source: 'compiled/concepts/overlap.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'overlap content',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+            {
+                id: 'bm25-only',
+                source: 'compiled/concepts/keyword-only.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'keyword only',
+                lineStart: 1,
+                lineEnd: 1,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            // below-floor: dense-only, score 0.1 < DENSE_SCORE_FLOOR (0.2) → must be dropped
+            // above-floor: dense-only, score 0.9 >= DENSE_SCORE_FLOOR (0.2) → must be kept
+            // bm25-overlap: in both channels → never dropped regardless of dense score
+            searchDense: () => [
+                { id: 'below-floor', score: 0.1 },
+                { id: 'above-floor', score: 0.9 },
+                { id: 'bm25-overlap', score: 0.3 },
+            ],
+            searchBm25: () => [
+                { id: 'bm25-overlap', score: 1 },
+                { id: 'bm25-only', score: 0.8 },
+            ],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const results = await testIndexer.search('query', 10);
+        const resultIds = results.map((r) => r.chunk.id);
+        assert.ok(!resultIds.includes('below-floor'), `below-floor (score 0.1 < 0.2) must be dropped; got: ${resultIds.join(', ')}`);
+        assert.ok(resultIds.includes('above-floor'), `above-floor (score 0.9 >= 0.2) must be kept; got: ${resultIds.join(', ')}`);
+        assert.ok(resultIds.includes('bm25-overlap'), `bm25-overlap (dual-channel) must always be kept`);
+        assert.ok(resultIds.includes('bm25-only'), `bm25-only must never be dropped by the floor`);
+    });
+    // BC9: recency tiebreak is stable — repeated calls with tied/absent fileMtimeAt return identical order
+    test('BC9: repeated search calls with equal-mtime candidates return deterministic order', async () => {
+        const testCfg = makeConfig('/tmp/bc9-determinism');
+        const chunks = [
+            {
+                id: 'c1',
+                source: 'compiled/entities/c1.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'c1 content',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 0,
+            },
+            {
+                id: 'c2',
+                source: 'compiled/entities/c2.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'c2 content',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 0,
+            },
+            {
+                id: 'c3',
+                source: 'compiled/entities/c3.md',
+                heading: '',
+                headingLevel: 0,
+                content: 'c3 content',
+                lineStart: 1,
+                lineEnd: 1,
+                fileMtimeAt: 0,
+            },
+        ];
+        const fakeStore = {
+            vecAvailable: true,
+            searchDense: () => [
+                { id: 'c1', score: 0.9 },
+                { id: 'c2', score: 0.85 },
+                { id: 'c3', score: 0.8 },
+            ],
+            searchBm25: () => [],
+            getChunksByIds: (ids) => chunks.filter((c) => ids.includes(c.id)),
+        };
+        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+        const firstCall = await testIndexer.search('query', 5);
+        const secondCall = await testIndexer.search('query', 5);
+        assert.equal(firstCall.length, secondCall.length, 'Result count must be identical across calls');
+        for (let idx = 0; idx < firstCall.length; idx++) {
+            assert.equal(firstCall[idx].chunk.id, secondCall[idx].chunk.id, `Position ${idx} must be deterministic: got '${firstCall[idx].chunk.id}' vs '${secondCall[idx].chunk.id}'`);
+        }
     });
     test('search still returns dense-only results when BM25 has no matches', async () => {
         const testCfg = makeConfig('/tmp/search-dense-fallback');

package/dist/services/memory/store.js

@@ -146,6 +146,7 @@ export class MemoryStore {
         return 0;
     }
     upsert(chunks, embeddings) {
+        const deleteChunk = this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`);
         const insertChunk = this.db.prepare(`
       INSERT OR REPLACE INTO memory_chunks
         (id, source, source_type, heading, heading_level, content, line_start, line_end, indexed_at, file_mtime_at, embedding)
@@ -157,7 +158,7 @@ export class MemoryStore {
                 try {
                     const vectorBinding = this.toVectorBinding(embeddings[i]);
                     // Delete existing row first to get correct rowid
-                    this.db.prepare(`DELETE FROM memory_chunks WHERE id = ?`).run(chunk.id);
+                    deleteChunk.run(chunk.id);
                     insertChunk.run(chunk.id, chunk.source, chunk.sourceType, chunk.heading, chunk.headingLevel, chunk.content, chunk.lineStart, chunk.lineEnd, Date.now(), chunk.fileMtimeAt, vectorBinding);
                 }
                 catch (err) {
@@ -179,12 +180,11 @@ export class MemoryStore {
             throw new Error('missing embedding');
         if (embedding.length !== this.config.vectorDimension)
             throw new Error('embedding dimension mismatch');
-        const values = Array.from(embedding, (value) => {
-            if (!Number.isFinite(value))
+        for (let i = 0; i < embedding.length; i++) {
+            if (!Number.isFinite(embedding[i]))
                 throw new Error('embedding contains non-finite value');
-            return value;
-        });
-        return JSON.stringify(values);
+        }
+        return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
     }
     normalizeVectorDistance(distance) {
         if (distance <= 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.37",
+  "version": "1.0.38",
   "description": "Agent Kit MCP server for software development agent workflows",
   "type": "module",
   "main": "dist/server.js",