@andespindola/brainlink 0.1.0-beta.7 → 0.1.0-beta.70

package/dist/application/index-vault.js

@@ -1,9 +1,12 @@
+import { readFile } from 'node:fs/promises';
 import { createIndexedDocument, parseMarkdownDocument } from '../domain/markdown.js';
 import { sharedAgentId } from '../domain/agents.js';
 import { createEmbeddingProvider } from '../domain/embeddings.js';
 import { loadBrainlinkConfig } from '../infrastructure/config.js';
-import { ensureVault, readMarkdownFiles } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { ensureVault, readMarkdownFileSummaries } from '../infrastructure/file-system-vault.js';
+import { readIndexState, writeIndexState } from '../infrastructure/index-state.js';
+import { buildSearchPacks, ensureSearchPackManifest, toSearchPackBuildOptions } from '../infrastructure/search-packs.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
 const toTitleKey = (title) => title.toLowerCase();
 const appendTitleEntry = (map, document) => {
     const key = toTitleKey(document.title);
@@ -33,6 +36,9 @@ const createScopedTitleResolver = (document, titleMaps) => ({
     get: (title) => titleMaps.byAgent.get(document.agentId)?.get(title)?.id ?? titleMaps.shared.get(title)?.id
 });
 const embedIndexedDocuments = async (documents, providerName) => {
+    if (documents.length === 0) {
+        return documents;
+    }
     const provider = createEmbeddingProvider(providerName);
     const chunks = documents.flatMap((document) => document.chunks);
     const embeddings = await provider.embed(chunks.map((chunk) => chunk.content));
@@ -46,28 +52,255 @@ const embedIndexedDocuments = async (documents, providerName) => {
         }))
     }));
 };
+const relinkIndexedDocument = (indexedDocument, titleMaps) => {
+    const resolver = createScopedTitleResolver(indexedDocument.document, titleMaps);
+    return {
+        ...indexedDocument,
+        links: indexedDocument.links
+            .map((link) => ({
+            ...link,
+            toDocumentId: resolver.get(link.toTitle.toLowerCase()) ?? null
+        }))
+            .filter((link) => link.toDocumentId !== indexedDocument.document.id)
+    };
+};
+const toIndexResult = (documents) => ({
+    documentCount: documents.length,
+    chunkCount: documents.reduce((total, document) => total + document.chunks.length, 0),
+    linkCount: documents.reduce((total, document) => total + document.links.length, 0)
+});
+const toSnapshot = (summaries) => summaries.map((summary) => ({
+    path: summary.relativePath,
+    mtimeMs: summary.updatedAt.getTime(),
+    size: summary.size
+}));
+const createSnapshotMap = (snapshot) => new Map(snapshot.map((entry) => [entry.path, entry]));
+const readChangedDocuments = async (absoluteVaultPath, changedSummaries) => {
+    const parsed = await Promise.all(changedSummaries.map(async (summary) => parseMarkdownDocument({
+        absolutePath: summary.absolutePath,
+        vaultPath: absoluteVaultPath,
+        content: await readFile(summary.absolutePath, 'utf8'),
+        createdAt: summary.createdAt,
+        updatedAt: summary.updatedAt
+    })));
+    return new Map(parsed.map((document) => [document.path, document]));
+};
 export const indexVault = async (vaultPath) => {
+    return indexVaultWithOptions(vaultPath, {});
+};
+export const indexVaultWithOptions = async (vaultPath, options) => {
+    const startedAt = process.hrtime.bigint();
+    const elapsedMs = () => Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+    const emit = (phase, status, message, details) => {
+        options.onProgress?.({
+            phase,
+            status,
+            message,
+            elapsedMs: elapsedMs(),
+            timestamp: new Date().toISOString(),
+            details
+        });
+    };
+    emit('start', 'start', 'Indexing started');
     const absoluteVaultPath = await ensureVault(vaultPath);
     const config = await loadBrainlinkConfig();
-    const files = await readMarkdownFiles(absoluteVaultPath);
-    const documents = files.map((file) => parseMarkdownDocument({
-        absolutePath: file.absolutePath,
-        vaultPath: absoluteVaultPath,
-        content: file.content,
-        createdAt: file.createdAt,
-        updatedAt: file.updatedAt
-    }));
-    const titleMaps = createTitleMaps(documents);
-    const indexedDocuments = await embedIndexedDocuments(documents.map((document) => createIndexedDocument(document, createScopedTitleResolver(document, titleMaps), config.chunkSize)), config.embeddingProvider);
-    const index = openSqliteIndex(absoluteVaultPath);
+    emit('scan', 'start', 'Scanning markdown files');
+    const [summaries, previousState] = await Promise.all([
+        readMarkdownFileSummaries(absoluteVaultPath),
+        readIndexState(absoluteVaultPath)
+    ]);
+    emit('scan', 'finish', 'Scan complete', {
+        markdownFiles: summaries.length,
+        hasPreviousState: previousState != null
+    });
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        index.reset();
-        index.saveDocuments(indexedDocuments);
-        return {
-            documentCount: indexedDocuments.length,
-            chunkCount: indexedDocuments.reduce((total, document) => total + document.chunks.length, 0),
-            linkCount: indexedDocuments.reduce((total, document) => total + document.links.length, 0)
+        const existingIndexedDocuments = await index.getIndexedDocuments();
+        const existingByPath = new Map(existingIndexedDocuments.map((document) => [document.document.path, document]));
+        const currentSnapshot = toSnapshot(summaries);
+        const currentSnapshotMap = createSnapshotMap(currentSnapshot);
+        const previousSnapshotMap = createSnapshotMap(previousState?.files ?? []);
+        const settingsChanged = previousState == null ||
+            previousState.chunkSize !== config.chunkSize ||
+            previousState.embeddingProvider !== config.embeddingProvider;
+        const packSettingsChanged = previousState == null ||
+            previousState.searchPackRowChunkSize !== config.searchPack.rowChunkSize ||
+            previousState.searchPackCompressionLevel !== config.searchPack.compressionLevel ||
+            previousState.searchPackUseDictionary !== config.searchPack.useDictionary;
+        const changedPaths = new Set();
+        for (let index = 0; index < summaries.length; index += 1) {
+            const summary = summaries[index];
+            const previous = previousSnapshotMap.get(summary.relativePath);
+            const changed = settingsChanged ||
+                previous == null ||
+                previous.mtimeMs !== summary.updatedAt.getTime() ||
+                previous.size !== summary.size ||
+                !existingByPath.has(summary.relativePath);
+            if (changed) {
+                changedPaths.add(summary.relativePath);
+            }
+        }
+        const hasDeletes = previousState
+            ? previousState.files.some((entry) => !currentSnapshotMap.has(entry.path))
+            : false;
+        const manifestRecovery = await ensureSearchPackManifest(absoluteVaultPath);
+        if (changedPaths.size === 0 &&
+            !hasDeletes &&
+            existingIndexedDocuments.length === summaries.length &&
+            previousState != null) {
+            const result = {
+                ...toIndexResult(existingIndexedDocuments),
+                elapsedMs: elapsedMs(),
+                changedDocumentCount: 0,
+                packs: {
+                    rebuilt: false,
+                    reason: manifestRecovery.repaired ? 'No changes detected; pack manifest repaired' : 'No changes detected'
+                }
+            };
+            emit('complete', 'skip', 'Index skipped: no changes detected', {
+                elapsedMs: result.elapsedMs,
+                manifestRepaired: manifestRecovery.repaired,
+                manifestRecoverySource: manifestRecovery.source
+            });
+            return result;
+        }
+        const changedSummaries = summaries.filter((summary) => changedPaths.has(summary.relativePath));
+        emit('parse', 'start', 'Parsing changed markdown files', {
+            changedFiles: changedSummaries.length
+        });
+        const changedDocumentsByPath = await readChangedDocuments(absoluteVaultPath, changedSummaries);
+        emit('parse', 'finish', 'Parse complete', {
+            changedDocuments: changedDocumentsByPath.size
+        });
+        const documents = summaries.flatMap((summary) => {
+            const changed = changedDocumentsByPath.get(summary.relativePath);
+            if (changed) {
+                return [changed];
+            }
+            const existing = existingByPath.get(summary.relativePath);
+            return existing ? [existing.document] : [];
+        });
+        const titleMaps = createTitleMaps(documents);
+        emit('embed', 'start', 'Embedding changed chunks', {
+            changedDocuments: changedDocumentsByPath.size
+        });
+        const changedIndexedDocuments = changedDocumentsByPath.size > 0
+            ? await embedIndexedDocuments(Array.from(changedDocumentsByPath.values()).map((document) => createIndexedDocument(document, createScopedTitleResolver(document, titleMaps), config.chunkSize)), config.embeddingProvider)
+            : [];
+        emit('embed', changedDocumentsByPath.size > 0 ? 'finish' : 'skip', changedDocumentsByPath.size > 0 ? 'Embedding complete' : 'Embedding skipped', {
+            changedIndexedDocuments: changedIndexedDocuments.length
+        });
+        const changedIndexedByPath = new Map(changedIndexedDocuments.map((document) => [document.document.path, document]));
+        const needsRelink = settingsChanged || hasDeletes || changedPaths.size > 0;
+        const indexedDocuments = documents.map((document) => {
+            const changed = changedIndexedByPath.get(document.path);
+            if (changed) {
+                return changed;
+            }
+            const existing = existingByPath.get(document.path);
+            if (!existing) {
+                return createIndexedDocument(document, createScopedTitleResolver(document, titleMaps), config.chunkSize);
+            }
+            return needsRelink ? relinkIndexedDocument(existing, titleMaps) : existing;
+        });
+        emit('persist', 'start', 'Persisting index');
+        await index.reset();
+        await index.saveDocuments(indexedDocuments);
+        emit('persist', 'finish', 'Index persisted', {
+            indexedDocuments: indexedDocuments.length
+        });
+        const existingPackManifest = manifestRecovery.repaired || manifestRecovery.source === 'not-needed';
+        const changedCount = changedPaths.size;
+        const documentCount = Math.max(indexedDocuments.length, 1);
+        const changeRatio = changedCount / documentCount;
+        const previousPendingPackChanges = previousState?.pendingPackChanges ?? 0;
+        const pendingPackChanges = previousPendingPackChanges + changedCount;
+        const shouldRebuildPacks = !existingPackManifest ||
+            settingsChanged ||
+            packSettingsChanged ||
+            hasDeletes ||
+            changedCount >= 400 ||
+            changeRatio >= 0.04 ||
+            pendingPackChanges >= 1200;
+        let packResult;
+        const packReason = !existingPackManifest
+            ? 'Missing pack manifest'
+            : manifestRecovery.repaired
+                ? 'Pack manifest repaired from existing packs'
+                : settingsChanged
+                    ? 'Index settings changed'
+                    : packSettingsChanged
+                        ? 'Search pack settings changed'
+                        : hasDeletes
+                            ? 'Document deletions detected'
+                            : changedCount >= 400
+                                ? 'Changed file count threshold reached'
+                                : changeRatio >= 0.04
+                                    ? 'Change ratio threshold reached'
+                                    : pendingPackChanges >= 1200
+                                        ? 'Pending pack changes threshold reached'
+                                        : 'Pack rebuild skipped';
+        if (shouldRebuildPacks) {
+            emit('packs', 'start', 'Rebuilding compressed search packs', {
+                reason: packReason
+            });
+            try {
+                packResult = await buildSearchPacks(absoluteVaultPath, indexedDocuments, toSearchPackBuildOptions(config));
+                emit('packs', 'finish', 'Compressed packs rebuilt', {
+                    reason: packReason,
+                    packCount: packResult.packCount,
+                    recordCount: packResult.recordCount,
+                    durationMs: packResult.durationMs,
+                    compressionRatio: packResult.compression.ratio
+                });
+            }
+            catch {
+                // Pack generation is best-effort. The JSON index remains the primary path.
+                emit('packs', 'skip', 'Pack rebuild failed; continuing with JSON index', {
+                    reason: packReason
+                });
+            }
+        }
+        else {
+            emit('packs', 'skip', 'Pack rebuild not required', {
+                reason: packReason
+            });
+        }
+        const packsRebuilt = packResult != null;
+        const packResultReason = shouldRebuildPacks && !packsRebuilt ? `${packReason} (failed)` : packReason;
+        await writeIndexState(absoluteVaultPath, {
+            chunkSize: config.chunkSize,
+            embeddingProvider: config.embeddingProvider,
+            searchPackRowChunkSize: config.searchPack.rowChunkSize,
+            searchPackCompressionLevel: config.searchPack.compressionLevel,
+            searchPackUseDictionary: config.searchPack.useDictionary,
+            files: currentSnapshot,
+            pendingPackChanges: packsRebuilt ? 0 : pendingPackChanges
+        });
+        const result = {
+            ...toIndexResult(indexedDocuments),
+            elapsedMs: elapsedMs(),
+            changedDocumentCount: changedDocumentsByPath.size,
+            packs: {
+                rebuilt: packsRebuilt,
+                reason: packResultReason,
+                ...(packResult
+                    ? {
+                        packCount: packResult.packCount,
+                        recordCount: packResult.recordCount,
+                        durationMs: packResult.durationMs,
+                        compression: packResult.compression
+                    }
+                    : {})
+            }
         };
+        emit('complete', 'finish', 'Indexing complete', {
+            documentCount: result.documentCount,
+            chunkCount: result.chunkCount,
+            linkCount: result.linkCount,
+            elapsedMs: result.elapsedMs
+        });
+        return result;
     }
     finally {
         index.close();

package/dist/application/list-agents.js

@@ -1,10 +1,10 @@
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
 export const listAgents = async (vaultPath) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.listAgents();
+        return await index.listAgents();
     }
     finally {
         index.close();

package/dist/application/list-links.js

@@ -1,10 +1,10 @@
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
 export const listLinks = async (vaultPath, agentId) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.listLinks(agentId);
+        return await index.listLinks(agentId);
     }
     finally {
         index.close();
@@ -12,9 +12,9 @@ export const listLinks = async (vaultPath, agentId) => {
 };
 export const listBacklinks = async (vaultPath, title, agentId) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.listBacklinks(title, agentId);
+        return await index.listBacklinks(title, agentId);
     }
     finally {
         index.close();

package/dist/application/migrate-vault.js

@@ -0,0 +1,91 @@
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, extname, isAbsolute, join, relative } from 'node:path';
+import { ensureVault, isBucketVaultPath, listVaultFiles, resolveVaultPath, writeMarkdownFile } from '../infrastructure/file-system-vault.js';
+const directoryMode = 0o700;
+const fileMode = 0o600;
+const isMarkdownPath = (path) => extname(path).toLowerCase() === '.md';
+const timestamp = () => new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, 'Z');
+const isPathInside = (parent, child) => {
+    const path = relative(parent, child);
+    return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+};
+const conflictPath = (targetPath) => {
+    const extension = extname(targetPath);
+    const base = extension ? targetPath.slice(0, -extension.length) : targetPath;
+    return `${base}.conflict-${timestamp()}${extension}`;
+};
+const writePreservedFile = async (absolutePath, content) => {
+    await mkdir(dirname(absolutePath), { recursive: true, mode: directoryMode });
+    await writeFile(absolutePath, content, { mode: fileMode });
+    await chmod(absolutePath, fileMode);
+};
+const writeMigratedFile = async (targetVault, targetRoot, absolutePath, content) => {
+    if (isBucketVaultPath(targetVault)) {
+        await writeMarkdownFile(targetVault, relative(targetRoot, absolutePath), content.toString('utf8'));
+        return;
+    }
+    await writePreservedFile(absolutePath, content);
+};
+export const planVaultMigration = async (source, target) => {
+    const sourceFiles = (await listVaultFiles(source)).filter(isMarkdownPath);
+    return sourceFiles.reduce(async (statePromise, sourceFile) => {
+        const state = await statePromise;
+        const targetFile = join(target, relative(source, sourceFile));
+        if (!isPathInside(target, targetFile)) {
+            return state;
+        }
+        const sourceContent = await readFile(sourceFile);
+        try {
+            const targetContent = await readFile(targetFile);
+            if (sourceContent.equals(targetContent)) {
+                return [...state, { kind: 'unchanged', sourcePath: sourceFile, targetPath: targetFile, sourceContent }];
+            }
+            return [...state, { kind: 'conflict', sourcePath: sourceFile, targetPath: conflictPath(targetFile), sourceContent }];
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+                throw error;
+            }
+            return [...state, { kind: 'copy', sourcePath: sourceFile, targetPath: targetFile, sourceContent }];
+        }
+    }, Promise.resolve([]));
+};
+export const previewVaultMigration = async (sourceVault, targetVault) => {
+    const source = await ensureVault(sourceVault);
+    const target = await ensureVault(targetVault);
+    if (source === target) {
+        return { source, target, copied: 0, unchanged: 0, conflicted: 0 };
+    }
+    const actions = await planVaultMigration(source, target);
+    const copied = actions.filter((action) => action.kind === 'copy').length;
+    const unchanged = actions.filter((action) => action.kind === 'unchanged').length;
+    const conflicted = actions.filter((action) => action.kind === 'conflict').length;
+    return { source, target, copied, unchanged, conflicted };
+};
+export const migrateVaultContent = async (sourceVault, targetVault) => {
+    const source = await ensureVault(sourceVault);
+    const target = await ensureVault(targetVault);
+    if (source === target) {
+        return { source, target, copied: 0, unchanged: 0, conflicted: 0 };
+    }
+    const actions = await planVaultMigration(source, target);
+    for (const action of actions) {
+        if (action.kind === 'unchanged') {
+            continue;
+        }
+        await writeMigratedFile(targetVault, target, action.targetPath, action.sourceContent);
+    }
+    const copied = actions.filter((action) => action.kind === 'copy').length;
+    const unchanged = actions.filter((action) => action.kind === 'unchanged').length;
+    const conflicted = actions.filter((action) => action.kind === 'conflict').length;
+    return { source, target, copied, unchanged, conflicted };
+};
+export const shouldMigrateDefaultVault = async (sourceVault, targetVault) => {
+    const source = resolveVaultPath(sourceVault);
+    const target = resolveVaultPath(targetVault);
+    if (source === target) {
+        return false;
+    }
+    const [sourceFiles, targetFiles] = await Promise.all([listVaultFiles(source), listVaultFiles(target)]);
+    return sourceFiles.filter(isMarkdownPath).length > 0 && targetFiles.filter(isMarkdownPath).length === 0;
+};

package/dist/application/offline-pack-backup.js

@@ -0,0 +1,44 @@
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { gzipSync } from 'node:zlib';
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+const packsDirectory = (vaultPath) => join(vaultPath, '.brainlink', 'search-packs');
+const toSortedBackupFiles = async (vaultPath) => {
+    const directory = packsDirectory(vaultPath);
+    const names = await readdir(directory);
+    return names
+        .filter((name) => name.endsWith('.blpk') || name === 'manifest.json')
+        .sort((left, right) => left.localeCompare(right));
+};
+export const createOfflinePackBackup = async (input) => {
+    const vaultPath = await ensureVault(input.vaultPath);
+    const fileNames = await toSortedBackupFiles(vaultPath);
+    const files = [];
+    let inputBytes = 0;
+    for (const name of fileNames) {
+        const content = await readFile(join(packsDirectory(vaultPath), name));
+        inputBytes += content.byteLength;
+        files.push({
+            name,
+            contentB64: content.toString('base64')
+        });
+    }
+    const envelope = {
+        version: 1,
+        createdAt: new Date().toISOString(),
+        files
+    };
+    const serialized = Buffer.from(JSON.stringify(envelope), 'utf8');
+    const compressed = gzipSync(serialized, { level: 9 });
+    await mkdir(dirname(input.outputPath), { recursive: true });
+    await writeFile(input.outputPath, compressed);
+    const safeInput = Math.max(inputBytes, 1);
+    return {
+        outputPath: input.outputPath,
+        fileCount: files.length,
+        inputBytes,
+        outputBytes: compressed.byteLength,
+        ratio: compressed.byteLength / safeInput,
+        savedBytes: Math.max(inputBytes - compressed.byteLength, 0)
+    };
+};

package/dist/application/search-graph-node-ids.js

@@ -0,0 +1,12 @@
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
+export const searchGraphNodeIds = async (vaultPath, query, limit, agentId) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const index = openFileIndex(absoluteVaultPath);
+    try {
+        return await index.searchGraphNodeIds(query, limit, agentId);
+    }
+    finally {
+        index.close();
+    }
+};

package/dist/application/search-knowledge.js

@@ -1,19 +1,89 @@
+import { stat } from 'node:fs/promises';
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { ensurePrivatePacksFromLegacyIndex, searchInPacks } from '../infrastructure/search-packs.js';
+import { indexStoragePath, openFileIndex } from '../infrastructure/file-index.js';
 import { createEmbeddingProvider } from '../domain/embeddings.js';
 import { loadBrainlinkConfig, sanitizeSearchMode } from '../infrastructure/config.js';
+const hybridCacheTtlMs = 30_000;
+const hybridCacheMaxEntries = 200;
+const hybridSearchCache = new Map();
+const readIndexMtimeMs = async (vaultPath) => {
+    try {
+        return (await stat(indexStoragePath(vaultPath))).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+};
+const toCacheKey = (vaultPath, query, limit, agentId) => JSON.stringify({
+    vaultPath,
+    query: query.trim().toLowerCase(),
+    limit,
+    agentId: agentId?.trim().toLowerCase() ?? '*'
+});
+const cacheGet = (key, indexMtimeMs) => {
+    const entry = hybridSearchCache.get(key);
+    if (!entry) {
+        return undefined;
+    }
+    const fresh = Date.now() - entry.createdAt <= hybridCacheTtlMs && entry.indexMtimeMs === indexMtimeMs;
+    if (!fresh) {
+        hybridSearchCache.delete(key);
+        return undefined;
+    }
+    return entry.results;
+};
+const cacheSet = (entry) => {
+    hybridSearchCache.set(entry.key, entry);
+    if (hybridSearchCache.size <= hybridCacheMaxEntries) {
+        return;
+    }
+    const overflow = hybridSearchCache.size - hybridCacheMaxEntries;
+    const keys = Array.from(hybridSearchCache.keys()).slice(0, overflow);
+    keys.forEach((key) => hybridSearchCache.delete(key));
+};
 export const searchKnowledge = async (vaultPath, query, limit, agentId, mode) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
     const config = await loadBrainlinkConfig();
     const searchMode = sanitizeSearchMode(mode, config.defaultSearchMode);
+    await ensurePrivatePacksFromLegacyIndex(absoluteVaultPath);
+    const cacheKey = searchMode === 'hybrid' ? toCacheKey(absoluteVaultPath, query, limit, agentId) : undefined;
+    const indexMtimeMs = cacheKey ? await readIndexMtimeMs(absoluteVaultPath) : 0;
+    const cached = cacheKey ? cacheGet(cacheKey, indexMtimeMs) : undefined;
+    if (cached) {
+        return cached;
+    }
     const provider = createEmbeddingProvider(config.embeddingProvider);
     const shouldEmbedQuery = searchMode !== 'fts' && provider.name !== 'none';
     const queryEmbedding = shouldEmbedQuery ? (await provider.embed([query]))[0] ?? [] : [];
-    const index = openSqliteIndex(absoluteVaultPath);
     try {
-        return index.search(query, limit, agentId, searchMode, queryEmbedding);
+        const index = openFileIndex(absoluteVaultPath);
+        try {
+            const results = await index.search(query, limit, agentId, searchMode, queryEmbedding);
+            if (cacheKey) {
+                cacheSet({
+                    key: cacheKey,
+                    createdAt: Date.now(),
+                    indexMtimeMs,
+                    results
+                });
+            }
+            return results;
+        }
+        finally {
+            index.close();
+        }
     }
-    finally {
-        index.close();
+    catch {
+        const fallbackResults = await searchInPacks(absoluteVaultPath, query, limit, agentId);
+        if (cacheKey) {
+            cacheSet({
+                key: cacheKey,
+                createdAt: Date.now(),
+                indexMtimeMs,
+                results: fallbackResults
+            });
+        }
+        return fallbackResults;
     }
 };