@hanhnd/agent-kit 1.0.37 → 1.0.39

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

@@ -1,13 +1,12 @@
 import * as assert from 'node:assert/strict';
-import fsDefault from 'node:fs';
 import * as fs from 'node:fs';
-import { syncBuiltinESMExports } from 'node:module';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { after, before, describe, test } from 'node:test';
 import { deriveSourceType, MemoryIndexer } from './indexer.js';
 import { MemoryStore } from './store.js';
-import { EmbeddingModelName } from './types.js';
+import { EmbeddingModelName, } from './types.js';
+import { DENSE_SCORE_FLOOR, FETCH_MULTIPLIER, RECENCY_WEIGHT, RRF_K } from './constants.js';
 class StubEmbedder {
     async embed(texts) {
         return texts.map(() => new Float32Array(384).fill(0.05));
@@ -16,6 +15,14 @@ class StubEmbedder {
         return Promise.resolve();
     }
 }
+class FailEmbedder {
+    async embed() {
+        throw new Error('embed failed');
+    }
+    initialize() {
+        return Promise.resolve();
+    }
+}
 function makeConfig(wikiDir) {
     return {
         enabled: true,
@@ -27,6 +34,23 @@ function makeConfig(wikiDir) {
         vectorDimension: 384,
     };
 }
+function makeChunkFull(overrides = {}) {
+    return {
+        id: 'test-id',
+        source: 'compiled/entities/test.md',
+        sourceType: 'entity',
+        heading: 'Test',
+        headingLevel: 1,
+        content: 'test content',
+        lineStart: 1,
+        lineEnd: 2,
+        fileMtimeAt: 1000,
+        ...overrides,
+    };
+}
+function makeHybridRow(chunk, retriever = 'both') {
+    return { chunk, score: 0.8, retriever };
+}
 describe('MemoryIndexer', () => {
     let tmpDir;
     let store;
@@ -52,9 +76,7 @@ describe('MemoryIndexer', () => {
     test('indexFile on unchanged file — indexed === 0, skipped > 0', async () => {
         const filePath = path.join(tmpDir, 'stable-file.md');
         fs.writeFileSync(filePath, '# Stable\nThis content does not change between runs.', 'utf8');
-        // First run indexes it
         await indexer.indexFile(filePath);
-        // Second run — same content
         const stats = await indexer.indexFile(filePath);
         assert.equal(stats.indexed, 0, `Expected indexed === 0, got ${stats.indexed}`);
         assert.ok(stats.skipped > 0, `Expected skipped > 0, got ${stats.skipped}`);
@@ -74,29 +96,121 @@ describe('MemoryIndexer', () => {
         const staleSource = path.relative(tmpDir, staleFile);
         const before = store.hashesBySource(staleSource);
         assert.ok(before.size > 0, 'Stale file must be indexed first');
-        // Delete the file and re-index the directory
         fs.unlinkSync(staleFile);
         await indexer.indexDirectory(tmpDir);
         const afterDeletion = store.hashesBySource(staleSource);
         assert.equal(afterDeletion.size, 0, 'Stale source must be removed from store after directory scan');
     });
-    test('search returns result with correct source for indexed content', async () => {
-        const filePath = path.join(config.wikiDir, 'compiled', 'searchable.md');
-        const fileContent = '# Searchable\nspecialUniqueTermForSearch is in this document.';
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, fileContent, 'utf8');
-        await indexer.indexDirectory(path.join(config.wikiDir, 'compiled'), {
-            relativeBase: config.wikiDir,
-        });
-        const results = await indexer.search('specialUniqueTermForSearch', 5);
-        assert.ok(results.length > 0, 'Expected at least one search result');
-        const expectedSource = path.relative(config.wikiDir, filePath);
-        const match = results.find((r) => r.chunk.source === expectedSource);
-        assert.ok(match, `Expected result with source=${expectedSource}, got: ${results.map((r) => r.chunk.source).join(', ')}`);
-        assert.equal(match.chunk.content, fileContent);
-        assert.equal(match.contentSource, 'file');
+    // BC13: delegation — vecAvailable=true embeds query and calls searchHybrid with correct options
+    test('BC13: search delegates to searchHybrid with embedding and constants when vecAvailable', async () => {
+        const chunk = makeChunkFull();
+        let capturedOptions;
+        const fakeStore = {
+            vecAvailable: true,
+            searchHybrid: (opts) => {
+                capturedOptions = opts;
+                return [makeHybridRow(chunk, 'both')];
+            },
+        };
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bc13-'));
+        const testCfg = makeConfig(path.join(testDir, 'wiki'));
+        try {
+            const compiledEntities = path.join(testCfg.wikiDir, 'compiled', 'entities');
+            fs.mkdirSync(compiledEntities, { recursive: true });
+            fs.writeFileSync(path.join(compiledEntities, 'test.md'), 'test content', 'utf8');
+            const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+            const results = await testIndexer.search('hello', 3);
+            assert.ok(capturedOptions, 'searchHybrid must be called');
+            assert.equal(capturedOptions.query, 'hello');
+            assert.equal(capturedOptions.topK, 3);
+            assert.equal(capturedOptions.fetchLimit, 3 * FETCH_MULTIPLIER);
+            assert.equal(capturedOptions.denseScoreFloor, DENSE_SCORE_FLOOR);
+            assert.equal(capturedOptions.recencyWeight, RECENCY_WEIGHT);
+            assert.equal(capturedOptions.rrfK, RRF_K);
+            assert.ok(capturedOptions.embedding instanceof Float32Array, 'embedding must be provided when vecAvailable');
+            assert.equal(results.length, 1);
+        }
+        finally {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    // BC14: embedding failure → searchHybrid called without embedding
+    test('BC14: embedding failure causes search to call searchHybrid without embedding', async () => {
+        const chunk = makeChunkFull();
+        let capturedOptions;
+        const fakeStore = {
+            vecAvailable: true,
+            searchHybrid: (opts) => {
+                capturedOptions = opts;
+                return [makeHybridRow(chunk, 'bm25')];
+            },
+        };
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bc14-'));
+        const testCfg = makeConfig(path.join(testDir, 'wiki'));
+        try {
+            const compiledEntities = path.join(testCfg.wikiDir, 'compiled', 'entities');
+            fs.mkdirSync(compiledEntities, { recursive: true });
+            fs.writeFileSync(path.join(compiledEntities, 'test.md'), 'test content', 'utf8');
+            const testIndexer = new MemoryIndexer(fakeStore, new FailEmbedder(), testCfg);
+            const results = await testIndexer.search('hello', 5);
+            assert.ok(capturedOptions, 'searchHybrid must be called even after embedding failure');
+            assert.equal(capturedOptions.embedding, undefined, 'embedding must be absent after failure');
+            assert.equal(results.length, 1);
+        }
+        finally {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    // BC15: readable source file → full live content and contentSource: 'file'
+    test('BC15: readable source file is read asynchronously and contentSource is file', async () => {
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bc15-'));
+        const testCfg = makeConfig(path.join(testDir, 'wiki'));
+        const sourceRelative = 'compiled/entities/test.md';
+        const sourceAbsolute = path.join(testCfg.wikiDir, sourceRelative);
+        const fileContent = '# Full\nLive file content from disk.';
+        try {
+            fs.mkdirSync(path.dirname(sourceAbsolute), { recursive: true });
+            fs.writeFileSync(sourceAbsolute, fileContent, 'utf8');
+            const chunk = makeChunkFull({ source: sourceRelative, content: 'stored chunk only' });
+            const fakeStore = {
+                vecAvailable: false,
+                searchHybrid: () => [makeHybridRow(chunk, 'bm25')],
+            };
+            const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+            const results = await testIndexer.search('test', 5);
+            assert.equal(results.length, 1);
+            assert.equal(results[0].contentSource, 'file');
+            assert.equal(results[0].chunk.content, fileContent);
+        }
+        finally {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    // BC16: missing source file → stored chunk content and contentSource: 'fallback'
+    test('BC16: missing source file leaves stored chunk content and sets contentSource fallback', async () => {
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bc16-'));
+        const testCfg = makeConfig(path.join(testDir, 'wiki'));
+        try {
+            const chunk = makeChunkFull({
+                source: 'compiled/entities/missing.md',
+                content: 'stored chunk content',
+            });
+            const fakeStore = {
+                vecAvailable: false,
+                searchHybrid: () => [makeHybridRow(chunk, 'bm25')],
+            };
+            const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+            const results = await testIndexer.search('test', 5);
+            assert.equal(results.length, 1);
+            assert.equal(results[0].contentSource, 'fallback');
+            assert.equal(results[0].chunk.content, 'stored chunk content');
+        }
+        finally {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
     });
-    test('indexDirectory walks nested markdown files and excludes configured basenames', async () => {
+    // BC17: indexDirectory deterministic traversal and stale deletion
+    test('BC17: indexDirectory walks nested markdown files and excludes configured basenames', async () => {
         const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'recursive-index-'));
         const testCfg = makeConfig(path.join(testDir, 'wiki'));
         const testStore = new MemoryStore(path.join(testCfg.wikiDir, 'index.db'), testCfg);
@@ -123,209 +237,67 @@ describe('MemoryIndexer', () => {
             fs.rmSync(testDir, { recursive: true, force: true });
         }
     });
-    test('indexDirectory returns zero stats when root directory is missing', async () => {
+    // BC18: unreadable subtrees — log and continue
+    test('BC18: indexDirectory logs and continues when file or subdirectory is unreadable', async () => {
         const stats = await indexer.indexDirectory(path.join(config.wikiDir, 'missing'), {
             relativeBase: config.wikiDir,
         });
         assert.deepEqual(stats, { indexed: 0, deleted: 0, skipped: 0 });
     });
-    test('indexDirectory removes stale pre-migration daily-file sources', async () => {
-        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'recursive-stale-'));
+    // BC19: save appends content asynchronously
+    test('BC19: save appends manual content to daily wiki raw file asynchronously', async () => {
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'save-daily-'));
         const testCfg = makeConfig(path.join(testDir, 'wiki'));
         const testStore = new MemoryStore(path.join(testCfg.wikiDir, 'index.db'), testCfg);
         const testIndexer = new MemoryIndexer(testStore, new StubEmbedder(), testCfg);
-        const compiledDir = path.join(testCfg.wikiDir, 'compiled');
+        const datePart = new Date().toISOString().slice(0, 10);
+        const savePath = path.join(testCfg.wikiDir, 'raw', `conv_save_${datePart}.md`);
         try {
-            fs.mkdirSync(compiledDir, { recursive: true });
-            testStore.upsert([
-                {
-                    id: 'stale-daily-file-0001',
-                    source: '2026-05-18.md',
-                    sourceType: 'wiki',
-                    heading: 'Stale',
-                    headingLevel: 1,
-                    content: 'pre migration content',
-                    lineStart: 1,
-                    lineEnd: 2,
-                    fileMtimeAt: 1,
-                },
-            ], [new Float32Array(384)]);
-            assert.ok(testStore.hashesBySource('2026-05-18.md').size > 0);
-            const stats = await testIndexer.indexDirectory(compiledDir, {
-                relativeBase: testCfg.wikiDir,
-            });
-            assert.equal(stats.deleted, 1);
-            assert.equal(testStore.hashesBySource('2026-05-18.md').size, 0);
+            const firstStats = await testIndexer.save('first manual save');
+            const secondStats = await testIndexer.save('second manual save');
+            assert.deepEqual(firstStats, { indexed: 0, deleted: 0, skipped: 0 });
+            assert.deepEqual(secondStats, { indexed: 0, deleted: 0, skipped: 0 });
+            assert.equal(fs.existsSync(savePath), true);
+            const content = fs.readFileSync(savePath, 'utf8');
+            assert.match(content, /first manual save/);
+            assert.match(content, /second manual save/);
+            assert.equal(fs.readdirSync(path.dirname(savePath)).filter((name) => /^conv_save_.*\.md$/.test(name)).length, 1);
         }
         finally {
             testStore.close();
             fs.rmSync(testDir, { recursive: true, force: true });
         }
     });
-    test('search deduplicates sources and reads each matched source once', async () => {
-        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'search-dedup-'));
-        const testCfg = {
-            ...makeConfig(path.join(testDir, 'wiki')),
-            chunkSize: 40,
-            overlapLines: 0,
-        };
-        const testStore = new MemoryStore(path.join(testCfg.wikiDir, 'index.db'), testCfg);
-        const testIndexer = new MemoryIndexer(testStore, new StubEmbedder(), testCfg);
-        const filePath = path.join(testCfg.wikiDir, 'compiled', 'entities', 'dedup.md');
-        const fileContent = [
-            '# Dedup',
-            'dedupUniqueTerm first chunk text',
-            'dedupUniqueTerm second chunk text',
-            'dedupUniqueTerm third chunk text',
-        ].join('\n');
-        const originalReadFileSync = fsDefault.readFileSync;
-        let readCount = 0;
-        try {
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, fileContent, 'utf8');
-            await testIndexer.indexDirectory(path.join(testCfg.wikiDir, 'compiled'), {
-                relativeBase: testCfg.wikiDir,
-            });
-            const expectedPath = path.join(testCfg.wikiDir, 'compiled/entities/dedup.md');
-            fsDefault.readFileSync = ((targetPath, options) => {
-                if (targetPath === expectedPath)
-                    readCount += 1;
-                return originalReadFileSync(targetPath, options);
-            });
-            syncBuiltinESMExports();
-            const results = await testIndexer.search('dedupUniqueTerm', 5);
-            assert.equal(results.filter((r) => r.chunk.source === 'compiled/entities/dedup.md').length, 1);
-            assert.equal(readCount, 1);
-            assert.equal(results[0].chunk.content, fileContent);
-            assert.equal(results[0].contentSource, 'file');
-        }
-        finally {
-            fsDefault.readFileSync = originalReadFileSync;
-            syncBuiltinESMExports();
-            testStore.close();
-            fs.rmSync(testDir, { recursive: true, force: true });
-        }
+    test('search returns result with correct source for indexed content', async () => {
+        const filePath = path.join(config.wikiDir, 'compiled', 'searchable.md');
+        const fileContent = '# Searchable\nspecialUniqueTermForSearch is in this document.';
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, fileContent, 'utf8');
+        await indexer.indexDirectory(path.join(config.wikiDir, 'compiled'), {
+            relativeBase: config.wikiDir,
+        });
+        const results = await indexer.search('specialUniqueTermForSearch', 5);
+        assert.ok(results.length > 0, 'Expected at least one search result');
+        const expectedSource = path.relative(config.wikiDir, filePath);
+        const match = results.find((r) => r.chunk.source === expectedSource);
+        assert.ok(match, `Expected result with source=${expectedSource}, got: ${results.map((r) => r.chunk.source).join(', ')}`);
+        assert.equal(match.chunk.content, fileContent);
+        assert.equal(match.contentSource, 'file');
     });
-    test('search continues past duplicate sources until topK unique sources are returned', async () => {
-        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'search-unique-topk-'));
-        const testCfg = makeConfig(path.join(testDir, 'wiki'));
-        const firstPath = path.join(testCfg.wikiDir, 'compiled', 'entities', 'first.md');
-        const secondPath = path.join(testCfg.wikiDir, 'compiled', 'entities', 'second.md');
-        const firstContent = '# First\nfirst source full content';
-        const secondContent = '# Second\nsecond source full content';
-        const chunks = [
-            {
-                id: 'first-1',
-                source: 'compiled/entities/first.md',
-                heading: 'First',
-                headingLevel: 1,
-                content: 'first matching chunk one',
-                lineStart: 1,
-                lineEnd: 2,
-            },
-            {
-                id: 'first-2',
-                source: 'compiled/entities/first.md',
-                heading: 'First',
-                headingLevel: 1,
-                content: 'first matching chunk two',
-                lineStart: 3,
-                lineEnd: 4,
-            },
-            {
-                id: 'second-1',
-                source: 'compiled/entities/second.md',
-                heading: 'Second',
-                headingLevel: 1,
-                content: 'second matching chunk',
-                lineStart: 1,
-                lineEnd: 2,
-            },
-        ];
-        const fakeStore = {
-            vecAvailable: false,
-            searchBm25: () => [
-                { id: 'first-1', score: 1 },
-                { id: 'first-2', score: 0.9 },
-                { id: 'second-1', score: 0.8 },
-            ],
-            getChunksByIds: (ids) => chunks.filter((chunk) => ids.includes(chunk.id)),
-        };
-        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
+    test('search on empty store returns []', async () => {
+        const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'empty-store-'));
+        const emptyCfg = makeConfig(emptyDir);
+        const emptyStore = new MemoryStore(path.join(emptyCfg.wikiDir, 'index.db'), emptyCfg);
+        const emptyIndexer = new MemoryIndexer(emptyStore, new StubEmbedder(), emptyCfg);
         try {
-            fs.mkdirSync(path.dirname(firstPath), { recursive: true });
-            fs.writeFileSync(firstPath, firstContent, 'utf8');
-            fs.writeFileSync(secondPath, secondContent, 'utf8');
-            const results = await testIndexer.search('duplicate source query', 2);
-            assert.equal(results.length, 2);
-            assert.deepEqual(results.map((result) => result.chunk.source), ['compiled/entities/first.md', 'compiled/entities/second.md']);
-            assert.equal(results[0].chunk.content, firstContent);
-            assert.equal(results[1].chunk.content, secondContent);
+            const results = await emptyIndexer.search('anything', 5);
+            assert.deepEqual(results, []);
         }
         finally {
-            fs.rmSync(testDir, { recursive: true, force: true });
+            emptyStore.close();
+            fs.rmSync(emptyDir, { recursive: true, force: true });
         }
     });
-    test('search does not include dense-only results when BM25 has matches', async () => {
-        const testCfg = makeConfig('/tmp/search-dense-filter');
-        const chunks = [
-            {
-                id: 'preference-1',
-                source: 'compiled/preferences.md',
-                heading: '',
-                headingLevel: 0,
-                content: 'I like fish',
-                lineStart: 1,
-                lineEnd: 1,
-            },
-            {
-                id: 'dense-only-1',
-                source: 'compiled/entities/worktree.md',
-                heading: 'Worktree',
-                headingLevel: 1,
-                content: 'Unrelated worktree lifecycle content',
-                lineStart: 1,
-                lineEnd: 2,
-            },
-        ];
-        const fakeStore = {
-            vecAvailable: true,
-            searchDense: () => [
-                { id: 'dense-only-1', score: 0.99 },
-                { id: 'preference-1', score: 0.98 },
-            ],
-            searchBm25: () => [{ id: 'preference-1', score: 1 }],
-            getChunksByIds: (ids) => chunks.filter((chunk) => ids.includes(chunk.id)),
-        };
-        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']);
-        assert.equal(results[0].retriever, 'both');
-    });
-    test('search still returns dense-only results when BM25 has no matches', async () => {
-        const testCfg = makeConfig('/tmp/search-dense-fallback');
-        const chunks = [
-            {
-                id: 'semantic-1',
-                source: 'compiled/preferences.md',
-                heading: '',
-                headingLevel: 0,
-                content: 'I like fish',
-                lineStart: 1,
-                lineEnd: 1,
-            },
-        ];
-        const fakeStore = {
-            vecAvailable: true,
-            searchDense: () => [{ id: 'semantic-1', score: 0.99 }],
-            searchBm25: () => [],
-            getChunksByIds: (ids) => chunks.filter((chunk) => ids.includes(chunk.id)),
-        };
-        const testIndexer = new MemoryIndexer(fakeStore, new StubEmbedder(), testCfg);
-        const results = await testIndexer.search('favorite dish', 5);
-        assert.deepEqual(results.map((result) => result.chunk.id), ['semantic-1']);
-        assert.equal(results[0].retriever, 'dense');
-    });
     test('search falls back to stored chunk content when source file is missing', async () => {
         const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'search-fallback-'));
         const testCfg = makeConfig(path.join(testDir, 'wiki'));
@@ -350,37 +322,56 @@ describe('MemoryIndexer', () => {
             fs.rmSync(testDir, { recursive: true, force: true });
         }
     });
-    test('search on empty store returns []', async () => {
-        const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'empty-store-'));
-        const emptyCfg = makeConfig(emptyDir);
-        const emptyStore = new MemoryStore(path.join(emptyCfg.wikiDir, 'index.db'), emptyCfg);
-        const emptyIndexer = new MemoryIndexer(emptyStore, new StubEmbedder(), emptyCfg);
+    test('search returns distinct sources — one result per source', async () => {
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'search-dedup-'));
+        const testCfg = makeConfig(path.join(testDir, 'wiki'));
+        const testStore = new MemoryStore(path.join(testCfg.wikiDir, 'index.db'), testCfg);
+        const testIndexer = new MemoryIndexer(testStore, new StubEmbedder(), testCfg);
+        const filePath = path.join(testCfg.wikiDir, 'compiled', 'entities', 'dedup.md');
+        // Multiple paragraphs create multiple chunks
+        const fileContent = '# Dedup\n\ndedupUniqueTermXYZ first chunk content\n\n---\n\ndedupUniqueTermXYZ second chunk content';
         try {
-            const results = await emptyIndexer.search('anything', 5);
-            assert.deepEqual(results, []);
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, fileContent, 'utf8');
+            await testIndexer.indexDirectory(path.join(testCfg.wikiDir, 'compiled'), {
+                relativeBase: testCfg.wikiDir,
+            });
+            const results = await testIndexer.search('dedupUniqueTermXYZ', 5);
+            const dedupSources = results.filter((r) => r.chunk.source === 'compiled/entities/dedup.md');
+            assert.equal(dedupSources.length, 1, 'At most one result per source after dedup');
         }
         finally {
-            emptyStore.close();
-            fs.rmSync(emptyDir, { recursive: true, force: true });
+            testStore.close();
+            fs.rmSync(testDir, { recursive: true, force: true });
         }
     });
-    test('save appends manual content to daily wiki raw save file without indexing it', async () => {
-        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'save-daily-'));
+    test('indexDirectory removes stale pre-migration daily-file sources', async () => {
+        const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'recursive-stale-'));
         const testCfg = makeConfig(path.join(testDir, 'wiki'));
         const testStore = new MemoryStore(path.join(testCfg.wikiDir, 'index.db'), testCfg);
         const testIndexer = new MemoryIndexer(testStore, new StubEmbedder(), testCfg);
-        const datePart = new Date().toISOString().slice(0, 10);
-        const savePath = path.join(testCfg.wikiDir, 'raw', `conv_save_${datePart}.md`);
+        const compiledDir = path.join(testCfg.wikiDir, 'compiled');
         try {
-            const firstStats = await testIndexer.save('first manual save');
-            const secondStats = await testIndexer.save('second manual save');
-            assert.deepEqual(firstStats, { indexed: 0, deleted: 0, skipped: 0 });
-            assert.deepEqual(secondStats, { indexed: 0, deleted: 0, skipped: 0 });
-            assert.equal(fs.existsSync(savePath), true);
-            const content = fs.readFileSync(savePath, 'utf8');
-            assert.match(content, /first manual save/);
-            assert.match(content, /second manual save/);
-            assert.equal(fs.readdirSync(path.dirname(savePath)).filter((name) => /^conv_save_.*\.md$/.test(name)).length, 1);
+            fs.mkdirSync(compiledDir, { recursive: true });
+            testStore.upsert([
+                {
+                    id: 'stale-daily-file-0001',
+                    source: '2026-05-18.md',
+                    sourceType: 'wiki',
+                    heading: 'Stale',
+                    headingLevel: 1,
+                    content: 'pre migration content',
+                    lineStart: 1,
+                    lineEnd: 2,
+                    fileMtimeAt: 1,
+                },
+            ], [new Float32Array(384)]);
+            assert.ok(testStore.hashesBySource('2026-05-18.md').size > 0);
+            const stats = await testIndexer.indexDirectory(compiledDir, {
+                relativeBase: testCfg.wikiDir,
+            });
+            assert.equal(stats.deleted, 1);
+            assert.equal(testStore.hashesBySource('2026-05-18.md').size, 0);
         }
         finally {
             testStore.close();
@@ -410,11 +401,18 @@ describe('MemoryIndexer', () => {
             assert.ok(stats.indexed > 0, `Expected indexed > 0, got ${stats.indexed}`);
             const ids = [...testStore.hashesBySource('compiled/provisional/conversation-digests/digest.md')];
             assert.ok(ids.length > 0);
-            const chunks = testStore.getChunksByIds(ids);
-            for (const chunk of chunks) {
-                assert.equal(chunk.sourceType, 'digest');
-                assert.equal(chunk.fileMtimeAt, expectedMtime);
-            }
+            const results = testStore.searchHybrid({
+                query: 'mtime metadata unique',
+                topK: 5,
+                fetchLimit: 20,
+                denseScoreFloor: 0,
+                recencyWeight: RECENCY_WEIGHT,
+                rrfK: RRF_K,
+            });
+            const match = results.find((r) => r.chunk.source === 'compiled/provisional/conversation-digests/digest.md');
+            assert.ok(match, 'Expected searchHybrid to find the indexed chunk');
+            assert.equal(match.chunk.sourceType, 'digest');
+            assert.equal(match.chunk.fileMtimeAt, expectedMtime);
         }
         finally {
             testStore.close();

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

@@ -1,4 +1,4 @@
-import type { MemoryChunk, MemoryConfig, RecentSource, SourceType } from './types.js';
+import type { HybridSearchOptions, HybridSearchRow, MemoryChunk, MemoryConfig, RecentSource, SourceType } from './types.js';
 export declare const SCHEMA_VERSION = 4;
 export declare class StoreError extends Error {
     constructor(message: string, cause?: unknown);
@@ -13,7 +13,6 @@ export declare class MemoryStore {
     private readUserVersion;
     upsert(chunks: MemoryChunk[], embeddings: Float32Array[]): void;
     private toVectorBinding;
-    private normalizeVectorDistance;
     hashesBySource(source: string): Set<string>;
     indexedSources(): string[];
     getRecentSources(options: {
@@ -22,15 +21,9 @@ export declare class MemoryStore {
     }): RecentSource[];
     deleteBySource(source: string): void;
     deleteByIds(ids: string[]): void;
-    searchDense(embedding: Float32Array, limit: number): Array<{
-        id: string;
-        score: number;
-    }>;
-    searchBm25(query: string, limit: number): Array<{
-        id: string;
-        score: number;
-    }>;
-    getChunksByIds(ids: string[]): MemoryChunk[];
+    private buildFtsQuery;
+    private mapMemoryChunkRow;
+    searchHybrid(options: HybridSearchOptions): HybridSearchRow[];
     get vecAvailable(): boolean;
     close(): void;
 }