@andespindola/brainlink 1.0.6 → 1.1.0

package/dist/domain/markdown.js

@@ -188,7 +188,15 @@ const splitLongParagraph = (paragraph, maxCharacters) => {
         return [...state, sentence];
     }, []);
 };
+const headingParagraphPattern = /^#{1,6}\s/;
+const startsWithHeading = (paragraph) => headingParagraphPattern.test(paragraph);
 export const splitIntoChunks = (documentId, content, maxCharacters = 1200) => {
+    // A heading should begin a new chunk so a section's body is not glued onto the
+    // tail of the previous section — but only once the current chunk already holds
+    // substantial content. This keeps large notes split on topical (heading)
+    // boundaries while small notes (and trailing metadata sections like
+    // "## Context Links") stay in a single chunk instead of fragmenting.
+    const minChunkCharacters = Math.floor(maxCharacters / 2);
     const paragraphs = normalizeChunkContent(stripFrontmatter(content))
         .split(/\n{2,}/)
         .filter(Boolean)
@@ -198,8 +206,9 @@ export const splitIntoChunks = (documentId, content, maxCharacters = 1200) => {
         if (!lastChunk) {
             return [paragraph];
         }
+        const startsNewSection = startsWithHeading(paragraph) && lastChunk.length >= minChunkCharacters;
         const merged = `${lastChunk}\n\n${paragraph}`;
-        if (merged.length <= maxCharacters) {
+        if (!startsNewSection && merged.length <= maxCharacters) {
             return [...state.slice(0, -1), merged];
         }
         return [...state, paragraph];

package/dist/domain/scoring.js

@@ -0,0 +1,42 @@
+// Pure retrieval scoring primitives: BM25 lexical relevance and min-max
+// normalization. Kept dependency-free and deterministic so the hot retrieval
+// loop in the infrastructure layer stays testable and the domain owns the
+// ranking math.
+export const defaultBm25Parameters = {
+    k1: 1.2,
+    b: 0.75
+};
+// Robertson/Sparck-Jones probabilistic IDF with the +0.5 smoothing that keeps
+// the value finite for terms present in every chunk. Floored at 0 so a term
+// shared by the whole candidate set can never push a score negative.
+export const inverseDocumentFrequency = (documentCount, documentFrequency) => {
+    if (documentCount <= 0) {
+        return 0;
+    }
+    const raw = Math.log(1 + (documentCount - documentFrequency + 0.5) / (documentFrequency + 0.5));
+    return raw > 0 ? raw : 0;
+};
+// BM25 contribution for a single query term given its (field-weighted)
+// frequency in a chunk. `documentLength` and `averageLength` are in the same
+// weighted unit so length normalization stays consistent with how the caller
+// counts terms.
+export const bm25TermScore = (params) => {
+    if (params.termFrequency <= 0) {
+        return 0;
+    }
+    const { k1, b } = params.parameters ?? defaultBm25Parameters;
+    const idf = inverseDocumentFrequency(params.documentCount, params.documentFrequency);
+    const normalizedLength = params.averageLength > 0 ? params.documentLength / params.averageLength : 1;
+    const denominator = params.termFrequency + k1 * (1 - b + b * normalizedLength);
+    return denominator > 0 ? (idf * (params.termFrequency * (k1 + 1))) / denominator : 0;
+};
+// Scale a value into [0, 1] given the observed range. When every candidate
+// shares the same score (range collapses) a positive score maps to 1 and a
+// zero score to 0, so a single result is never silently nulled out.
+export const minMaxNormalize = (value, minimum, maximum) => {
+    if (maximum <= minimum) {
+        return value > 0 ? 1 : 0;
+    }
+    const scaled = (value - minimum) / (maximum - minimum);
+    return scaled < 0 ? 0 : scaled > 1 ? 1 : scaled;
+};

package/dist/domain/tokens.js

@@ -1 +1,17 @@
-export const estimateTokenCount = (content) => Math.ceil(content.trim().split(/\s+/).filter(Boolean).join(' ').length / 4);
+// Subword tokenizers emit roughly 1.3 tokens per whitespace word for natural
+// language. Pure prose tracks that ratio; punctuation- or symbol-dense content
+// (code, URLs, long unbroken strings) tokenizes far denser, which the word
+// count alone underestimates. Taking the max with the character heuristic keeps
+// the estimate conservative — never below chars/4 — so callers that budget
+// against it can rely on the rendered output staying within the token limit.
+const tokensPerWord = 1.3;
+const charactersPerToken = 4;
+export const estimateTokenCount = (content) => {
+    const words = content.trim().split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+        return 0;
+    }
+    const characterEstimate = Math.ceil(words.join(' ').length / charactersPerToken);
+    const wordEstimate = Math.ceil(words.length * tokensPerWord);
+    return Math.max(characterEstimate, wordEstimate);
+};

package/dist/infrastructure/config.js

@@ -18,8 +18,10 @@ export const defaultBrainlinkConfig = {
     defaultContextStrategy: 'auto',
     defaultContextCacheTtlMs: 120_000,
     embeddingProvider: 'local',
+    embedding: {},
     defaultSearchMode: 'hybrid',
     chunkSize: 1200,
+    storageBackend: 'json',
     searchPack: {
         rowChunkSize: 5_000,
         compressionLevel: 5,
@@ -43,10 +45,36 @@ const safeCwd = () => {
     }
 };
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const embeddingProviders = new Set(['none', 'local']);
+const embeddingProviders = new Set(['none', 'local', 'ollama', 'openai']);
 const searchModes = new Set(['fts', 'semantic', 'hybrid']);
 const contextStrategies = new Set(['rag', 'cag', 'auto']);
+const storageBackends = new Set(['json', 'binary', 'lmdb']);
+const sanitizeStorageBackend = (value) => typeof value === 'string' && storageBackends.has(value) ? value : defaultBrainlinkConfig.storageBackend;
 const sanitizeEmbeddingProvider = (value) => typeof value === 'string' && embeddingProviders.has(value) ? value : defaultBrainlinkConfig.embeddingProvider;
+const sanitizeOptionalString = (value) => typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+const sanitizeEmbeddingConfig = (value) => {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const url = sanitizeOptionalString(value.url);
+    const model = sanitizeOptionalString(value.model);
+    const apiKeyEnv = sanitizeOptionalString(value.apiKeyEnv);
+    const timeoutMs = sanitizePositiveNumber(value.timeoutMs);
+    const batchSize = sanitizePositiveNumber(value.batchSize);
+    return {
+        ...(url ? { url } : {}),
+        ...(model ? { model } : {}),
+        ...(apiKeyEnv ? { apiKeyEnv } : {}),
+        ...(timeoutMs ? { timeoutMs: Math.floor(timeoutMs) } : {}),
+        ...(batchSize ? { batchSize: Math.floor(batchSize) } : {})
+    };
+};
+// Stable identity of the embedding space, used to decide when stored vectors
+// must be rebuilt. A model swap on an external provider changes the space even
+// though the provider name is unchanged, so the model is folded in.
+export const embeddingSignature = (config) => config.embeddingProvider === 'ollama' || config.embeddingProvider === 'openai'
+    ? `${config.embeddingProvider}:${config.embedding.model?.trim() || 'default'}`
+    : config.embeddingProvider;
 export const sanitizeSearchMode = (value, fallback = defaultBrainlinkConfig.defaultSearchMode) => typeof value === 'string' && searchModes.has(value) ? value : fallback;
 export const sanitizeContextStrategy = (value, fallback = defaultBrainlinkConfig.defaultContextStrategy) => typeof value === 'string' && contextStrategies.has(value) ? value : fallback;
 const sanitizeAllowedVaults = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
@@ -195,8 +223,10 @@ const sanitizeConfig = (value) => ({
         : defaultBrainlinkConfig.defaultContextCacheTtlMs,
     allowedVaults: [...sanitizeAllowedVaults(value.allowedVaults), ...readAllowedVaultsFromEnv()],
     chunkSize: typeof value.chunkSize === 'number' && value.chunkSize > 0 ? value.chunkSize : defaultBrainlinkConfig.chunkSize,
+    storageBackend: sanitizeStorageBackend(value.storageBackend),
     searchPack: sanitizeSearchPackConfig(value.searchPack),
     embeddingProvider: sanitizeEmbeddingProvider(value.embeddingProvider),
+    embedding: sanitizeEmbeddingConfig(value.embedding),
     defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode),
     agentProfiles: sanitizeAgentProfiles(value.agentProfiles)
 });

package/dist/infrastructure/file-index.js

@@ -1,19 +1,55 @@
 import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { createEmbeddingBuckets, dotProduct } from '../domain/embeddings.js';
-import { selectSemanticCandidates } from './semantic-prefilter.js';
-const queryTokenPattern = /[\p{L}\p{N}_-]+/gu;
+import { createStoredIndexQueries, emptyIndex, toStoredIndex } from './knowledge-store/stored-index.js';
 const indexCacheMaxEntries = 16;
 const indexCache = new Map();
-const emptyIndex = () => ({
-    version: 1,
-    updatedAt: new Date().toISOString(),
-    documents: [],
-    chunks: [],
-    links: []
-});
+// Raised when index.json exists but cannot be parsed. Search treats it as a
+// signal to fall back to the independent compressed search packs instead of
+// silently returning an empty result set.
+export class IndexCorruptionError extends Error {
+    indexPath;
+    constructor(indexPath, cause) {
+        super(`Corrupted index at ${indexPath}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        this.indexPath = indexPath;
+        this.name = 'IndexCorruptionError';
+    }
+}
 export const indexStoragePath = (vaultPath) => join(vaultPath, '.brainlink', 'index.json');
-const readIndex = async (vaultPath) => {
+const isMissingFileError = (error) => error instanceof Error && 'code' in error && error.code === 'ENOENT';
+// Paths already reported as corrupt, so a non-removable corrupt index (read-only
+// vault, locked file) does not spam stderr on every read. Cleared when a fresh
+// index is written to the path.
+const warnedCorruptIndexPaths = new Set();
+// Move a corrupt index aside so it is not read again and the next index run
+// rebuilds from Markdown source, and surface a warning instead of failing
+// silently. Quarantine is best-effort: a read-only vault simply keeps the file.
+const quarantineCorruptIndex = async (path, cause) => {
+    indexCache.delete(path);
+    if (!warnedCorruptIndexPaths.has(path)) {
+        warnedCorruptIndexPaths.add(path);
+        process.stderr.write(`brainlink: index at ${path} is unreadable and was quarantined; rebuild with 'index --full' (${cause instanceof Error ? cause.message : String(cause)})\n`);
+    }
+    try {
+        await rename(path, `${path}.corrupt`);
+    }
+    catch {
+        // The primary name can already exist (a prior corruption on a filesystem
+        // where rename does not overwrite, e.g. Windows). Fall back to a unique name
+        // so the damaged file is still moved out of the read path.
+        try {
+            await rename(path, `${path}.corrupt-${Date.now()}`);
+        }
+        catch {
+            // Leave the file in place when it cannot be renamed; the warning still fired.
+        }
+    }
+};
+// Exposed so the binary backend can serve reads from a legacy index.json until
+// the next index run materializes the binary store (seamless migration).
+export function readJsonStoredIndex(vaultPath, strict = false) {
+    return readIndex(vaultPath, strict);
+}
+const readIndex = async (vaultPath, strict = false) => {
     const path = indexStoragePath(vaultPath);
     let stats = null;
     try {
@@ -21,9 +57,8 @@ const readIndex = async (vaultPath) => {
         stats = { mtimeMs: fileStats.mtimeMs, size: fileStats.size };
     }
     catch (error) {
-        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+        if (isMissingFileError(error)) {
             indexCache.delete(path);
-            return emptyIndex();
         }
         return emptyIndex();
     }
@@ -31,31 +66,46 @@ const readIndex = async (vaultPath) => {
     if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
         return cached.index;
     }
+    let raw;
     try {
-        const parsed = JSON.parse(await readFile(path, 'utf8'));
-        const loaded = {
-            version: 1,
-            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
-            documents: Array.isArray(parsed.documents) ? parsed.documents : [],
-            chunks: Array.isArray(parsed.chunks) ? parsed.chunks : [],
-            links: Array.isArray(parsed.links) ? parsed.links : []
-        };
-        indexCache.set(path, { ...stats, index: loaded });
-        if (indexCache.size > indexCacheMaxEntries) {
-            const oldest = indexCache.keys().next().value;
-            if (typeof oldest === 'string') {
-                indexCache.delete(oldest);
-            }
+        raw = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        indexCache.delete(path);
+        // The file existed at stat but vanished before the read — a concurrent
+        // rebuild or quarantine. Strict (search) callers throw so they fall back to
+        // packs rather than racing to an empty result; tolerant callers get empty.
+        if (strict) {
+            throw new IndexCorruptionError(path, error);
         }
-        return loaded;
+        return emptyIndex();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
     }
     catch (error) {
-        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-            indexCache.delete(path);
-            return emptyIndex();
+        await quarantineCorruptIndex(path, error);
+        if (strict) {
+            throw new IndexCorruptionError(path, error);
         }
         return emptyIndex();
     }
+    const loaded = {
+        version: 1,
+        updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+        documents: Array.isArray(parsed.documents) ? parsed.documents : [],
+        chunks: Array.isArray(parsed.chunks) ? parsed.chunks : [],
+        links: Array.isArray(parsed.links) ? parsed.links : []
+    };
+    indexCache.set(path, { ...stats, index: loaded });
+    if (indexCache.size > indexCacheMaxEntries) {
+        const oldest = indexCache.keys().next().value;
+        if (typeof oldest === 'string') {
+            indexCache.delete(oldest);
+        }
+    }
+    return loaded;
 };
 const writeIndex = async (vaultPath, index) => {
     const target = indexStoragePath(vaultPath);
@@ -63,6 +113,7 @@ const writeIndex = async (vaultPath, index) => {
     await mkdir(dirname(target), { recursive: true, mode: 0o700 });
     await writeFile(temp, `${JSON.stringify(index)}\n`, { encoding: 'utf8', mode: 0o600 });
     await rename(temp, target);
+    warnedCorruptIndexPaths.delete(target);
     const fileStats = await stat(target);
     indexCache.set(target, {
         mtimeMs: fileStats.mtimeMs,
@@ -70,301 +121,21 @@ const writeIndex = async (vaultPath, index) => {
         index
     });
 };
-const normalizeToken = (value) => value
-    .normalize('NFKD')
-    .replace(/\p{Diacritic}/gu, '')
-    .toLowerCase();
-const tokenize = (query) => query
-    .match(queryTokenPattern)
-    ?.map(normalizeToken)
-    .filter((token) => token.length > 1) ?? [];
-const countOccurrences = (text, token) => {
-    let hits = 0;
-    let cursor = 0;
-    while (cursor < text.length) {
-        const index = text.indexOf(token, cursor);
-        if (index < 0) {
-            break;
-        }
-        hits += 1;
-        cursor = index + token.length;
-    }
-    return hits;
-};
-const textScore = (row, tokens) => {
-    if (tokens.length === 0) {
-        return 0;
+// JSON file backend: the original single `index.json` store. Loading/persisting
+// is its own concern; the graph/search/link reads come from the shared query
+// core so this backend stays behavior-identical to the binary backend.
+export const openFileIndex = (vaultPath) => ({
+    reset: async () => {
+        await writeIndex(vaultPath, emptyIndex());
+    },
+    saveDocuments: async (documents) => {
+        await writeIndex(vaultPath, toStoredIndex(documents));
+    },
+    ...createStoredIndexQueries({
+        load: () => readIndex(vaultPath),
+        loadStrict: () => readIndex(vaultPath, true)
+    }),
+    close: () => {
+        // File-based index has no persistent connection.
     }
-    const title = normalizeToken(row.title);
-    const path = normalizeToken(row.path);
-    const content = normalizeToken(row.content);
-    const tags = normalizeToken(row.tags.join(' '));
-    return tokens.reduce((score, token) => {
-        const titleHits = countOccurrences(title, token);
-        const tagHits = countOccurrences(tags, token);
-        const pathHits = countOccurrences(path, token);
-        const contentHits = countOccurrences(content, token);
-        return score + titleHits * 5 + tagHits * 4 + pathHits * 2 + Math.min(contentHits, 6);
-    }, 0);
-};
-const semanticScore = (row, queryEmbedding) => queryEmbedding.length > 0 && row.embedding.length > 0 ? dotProduct(queryEmbedding, row.embedding) : 0;
-const toResult = (row, mode, text, semantic) => {
-    const score = mode === 'fts' ? text : mode === 'semantic' ? semantic : text + semantic * 8;
-    return {
-        documentId: row.documentId,
-        agentId: row.agentId,
-        title: row.title,
-        path: row.path,
-        chunkId: row.chunkId,
-        chunkOrdinal: row.chunkOrdinal,
-        content: row.content,
-        score,
-        textScore: text,
-        semanticScore: semantic,
-        searchMode: mode,
-        tags: row.tags
-    };
-};
-const toGraphLink = (link, documentsById) => {
-    const source = documentsById.get(link.fromDocumentId);
-    const target = link.toDocumentId ? documentsById.get(link.toDocumentId) : undefined;
-    return {
-        agentId: source?.agentId ?? 'shared',
-        fromTitle: source?.title ?? 'Unknown',
-        fromPath: source?.path ?? 'Unknown',
-        toTitle: target?.title ?? link.toTitle,
-        toPath: target?.path ?? null,
-        weight: link.weight,
-        priority: link.priority
-    };
-};
-export const openFileIndex = (vaultPath) => {
-    const load = async () => readIndex(vaultPath);
-    const persist = async (index) => writeIndex(vaultPath, index);
-    return {
-        reset: async () => {
-            await persist(emptyIndex());
-        },
-        saveDocuments: async (documents) => {
-            const chunks = documents.flatMap((document) => document.chunks);
-            const links = documents.flatMap((document) => document.links);
-            await persist({
-                version: 1,
-                updatedAt: new Date().toISOString(),
-                documents: documents.map((document) => document.document),
-                chunks,
-                links
-            });
-        },
-        getIndexedDocuments: async (agentId) => {
-            const index = await load();
-            const documents = agentId ? index.documents.filter((document) => document.agentId === agentId) : index.documents;
-            const selectedDocumentIds = new Set(documents.map((document) => document.id));
-            const chunksByDocumentId = index.chunks.reduce((state, chunk) => {
-                if (!selectedDocumentIds.has(chunk.documentId)) {
-                    return state;
-                }
-                const current = state.get(chunk.documentId) ?? [];
-                current.push(chunk);
-                state.set(chunk.documentId, current);
-                return state;
-            }, new Map());
-            const linksByDocumentId = index.links.reduce((state, link) => {
-                if (!selectedDocumentIds.has(link.fromDocumentId)) {
-                    return state;
-                }
-                const current = state.get(link.fromDocumentId) ?? [];
-                current.push(link);
-                state.set(link.fromDocumentId, current);
-                return state;
-            }, new Map());
-            return documents
-                .map((document) => ({
-                document,
-                chunks: [...(chunksByDocumentId.get(document.id) ?? [])].sort((left, right) => left.ordinal - right.ordinal),
-                links: linksByDocumentId.get(document.id) ?? []
-            }))
-                .sort((left, right) => left.document.path.localeCompare(right.document.path));
-        },
-        search: async (query, limit, agentId, mode = 'hybrid', queryEmbedding = []) => {
-            const index = await load();
-            const documentsById = new Map(index.documents.map((document) => [document.id, document]));
-            const rows = index.chunks.flatMap((chunk) => {
-                const document = documentsById.get(chunk.documentId);
-                if (!document) {
-                    return [];
-                }
-                if (agentId && document.agentId !== agentId) {
-                    return [];
-                }
-                return [
-                    {
-                        documentId: document.id,
-                        agentId: document.agentId,
-                        title: document.title,
-                        path: document.path,
-                        chunkId: chunk.id,
-                        chunkOrdinal: chunk.ordinal,
-                        content: chunk.content,
-                        tags: document.tags,
-                        embedding: chunk.embedding,
-                        buckets: chunk.buckets
-                    }
-                ];
-            });
-            const tokens = tokenize(query);
-            // Pure-semantic scoring on a large vault can skip chunks that share no
-            // embedding bucket with the query. Hybrid/fts keep every row so lexical
-            // matches are never dropped; the prefilter also falls back to a full scan
-            // on small or partially-indexed vaults.
-            const scored = mode === 'semantic' && queryEmbedding.length > 0
-                ? selectSemanticCandidates(rows, createEmbeddingBuckets(queryEmbedding), limit)
-                : rows;
-            const results = scored
-                .map((row) => {
-                const text = textScore(row, tokens);
-                const semantic = semanticScore(row, queryEmbedding);
-                return toResult(row, mode, text, semantic);
-            })
-                .filter((row) => row.score > 0 || tokens.length === 0)
-                .sort((left, right) => right.score - left.score || left.title.localeCompare(right.title))
-                .slice(0, Math.max(0, limit));
-            return results;
-        },
-        listLinks: async (agentId) => {
-            const index = await load();
-            const documentsById = new Map(index.documents.map((document) => [document.id, document]));
-            return index.links
-                .filter((link) => {
-                const source = documentsById.get(link.fromDocumentId);
-                return agentId ? source?.agentId === agentId : true;
-            })
-                .map((link) => toGraphLink(link, documentsById))
-                .sort((left, right) => left.fromTitle.localeCompare(right.fromTitle));
-        },
-        listBacklinks: async (title, agentId) => {
-            const index = await load();
-            const titleKey = title.toLowerCase();
-            const documentsById = new Map(index.documents.map((document) => [document.id, document]));
-            return index.links
-                .filter((link) => link.toTitle.toLowerCase() === titleKey)
-                .filter((link) => {
-                const source = documentsById.get(link.fromDocumentId);
-                return agentId ? source?.agentId === agentId : true;
-            })
-                .map((link) => toGraphLink(link, documentsById))
-                .sort((left, right) => right.weight - left.weight || left.fromTitle.localeCompare(right.fromTitle));
-        },
-        getGraph: async (agentId) => {
-            const index = await load();
-            const documents = agentId ? index.documents.filter((document) => document.agentId === agentId) : index.documents;
-            const documentIds = new Set(documents.map((document) => document.id));
-            const edges = index.links
-                .filter((link) => documentIds.has(link.fromDocumentId))
-                .map((link) => ({
-                source: link.fromDocumentId,
-                target: link.toDocumentId,
-                targetTitle: link.toTitle,
-                weight: link.weight,
-                priority: link.priority
-            }));
-            return {
-                nodes: documents.map((document) => ({
-                    id: document.id,
-                    agentId: document.agentId,
-                    title: document.title,
-                    path: document.path,
-                    content: document.content,
-                    tags: document.tags,
-                    contextLinks: document.contextLinks ?? []
-                })),
-                edges
-            };
-        },
-        getGraphSummary: async (agentId) => {
-            const graph = await (async () => {
-                const index = await load();
-                const documents = agentId ? index.documents.filter((document) => document.agentId === agentId) : index.documents;
-                const documentIds = new Set(documents.map((document) => document.id));
-                const edges = index.links
-                    .filter((link) => documentIds.has(link.fromDocumentId))
-                    .map((link) => ({
-                    source: link.fromDocumentId,
-                    target: link.toDocumentId,
-                    targetTitle: link.toTitle,
-                    weight: link.weight,
-                    priority: link.priority
-                }));
-                return {
-                    nodes: documents.map((document) => ({
-                        id: document.id,
-                        agentId: document.agentId,
-                        title: document.title,
-                        path: document.path,
-                        content: '',
-                        tags: document.tags,
-                        contextLinks: document.contextLinks ?? []
-                    })),
-                    edges
-                };
-            })();
-            return graph;
-        },
-        getGraphNode: async (id, agentId) => {
-            const index = await load();
-            const document = index.documents.find((row) => row.id === id && (!agentId || row.agentId === agentId));
-            return document
-                ? {
-                    id: document.id,
-                    agentId: document.agentId,
-                    title: document.title,
-                    path: document.path,
-                    content: document.content,
-                    tags: document.tags,
-                    contextLinks: document.contextLinks ?? []
-                }
-                : undefined;
-        },
-        searchGraphNodeIds: async (query, limit, agentId) => {
-            const index = await load();
-            const normalized = normalizeToken(query);
-            if (normalized.length === 0 || limit <= 0) {
-                return [];
-            }
-            const tokens = tokenize(query);
-            const scored = index.documents
-                .filter((document) => (!agentId || document.agentId === agentId))
-                .map((document) => {
-                const score = textScore({
-                    documentId: document.id,
-                    agentId: document.agentId,
-                    title: document.title,
-                    path: document.path,
-                    chunkId: document.id,
-                    chunkOrdinal: 0,
-                    content: document.content,
-                    tags: document.tags,
-                    embedding: []
-                }, tokens);
-                return { id: document.id, score };
-            })
-                .filter((row) => row.score > 0)
-                .sort((left, right) => right.score - left.score || left.id.localeCompare(right.id))
-                .slice(0, limit);
-            return scored.map((row) => row.id);
-        },
-        listAgents: async () => {
-            const index = await load();
-            const counts = index.documents.reduce((state, document) => {
-                state.set(document.agentId, (state.get(document.agentId) ?? 0) + 1);
-                return state;
-            }, new Map());
-            return Array.from(counts.entries())
-                .sort((left, right) => left[0].localeCompare(right[0]))
-                .map(([id, documentCount]) => ({ id, documentCount }));
-        },
-        close: () => {
-            // File-based index has no persistent connection.
-        }
-    };
-};
+});