@andespindola/brainlink 0.1.0-beta.13 → 0.1.0-beta.15

package/dist/infrastructure/file-index.js

@@ -0,0 +1,291 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { cosineSimilarity } from '../domain/embeddings.js';
+const queryTokenPattern = /[\p{L}\p{N}_-]+/gu;
+const emptyIndex = () => ({
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    documents: [],
+    chunks: [],
+    links: []
+});
+export const indexStoragePath = (vaultPath) => join(vaultPath, '.brainlink', 'index.json');
+const readIndex = async (vaultPath) => {
+    try {
+        const parsed = JSON.parse(await readFile(indexStoragePath(vaultPath), 'utf8'));
+        return {
+            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 : []
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return emptyIndex();
+        }
+        return emptyIndex();
+    }
+};
+const writeIndex = async (vaultPath, index) => {
+    const target = indexStoragePath(vaultPath);
+    const temp = `${target}.tmp`;
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(temp, `${JSON.stringify(index)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temp, target);
+};
+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;
+    }
+    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 ? cosineSimilarity(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,
+        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
+            });
+        },
+        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,
+                        content: chunk.content,
+                        tags: document.tags,
+                        embedding: chunk.embedding
+                    }
+                ];
+            });
+            const tokens = tokenize(query);
+            const results = rows
+                .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
+                })),
+                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
+                    })),
+                    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
+                }
+                : 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,
+                    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.
+        }
+    };
+};

package/dist/infrastructure/search-packs.js

@@ -100,14 +100,15 @@ const sortedPackFiles = async (vaultPath) => {
         throw error;
     }
 };
-export const buildSearchPacks = async (vaultPath, documents) => {
+const writeRowsAsPrivatePacks = async (vaultPath, rows, clearExisting) => {
     const directory = toPackDirectory(vaultPath);
-    const rows = toRows(documents);
     await mkdir(directory, { recursive: true });
-    const current = await readdir(directory);
-    await Promise.all(current
-        .filter((name) => name.endsWith('.blpk') || name.endsWith('.jsonl.gz') || name === manifestFileName)
-        .map((name) => rm(join(directory, name), { force: true })));
+    if (clearExisting) {
+        const current = await readdir(directory);
+        await Promise.all(current
+            .filter((name) => name.endsWith('.blpk') || name.endsWith('.jsonl.gz') || name === manifestFileName)
+            .map((name) => rm(join(directory, name), { force: true })));
+    }
     const chunks = chunkRows(rows, rowChunkSize);
     await Promise.all(chunks.map(async (chunk, index) => {
         const fileName = `pack-${String(index + 1).padStart(4, '0')}.blpk`;
@@ -127,6 +128,30 @@ export const buildSearchPacks = async (vaultPath, documents) => {
         recordCount: rows.length
     };
 };
+export const buildSearchPacks = async (vaultPath, documents) => {
+    return writeRowsAsPrivatePacks(vaultPath, toRows(documents), true);
+};
+export const ensurePrivatePacksFromLegacyIndex = async (vaultPath) => {
+    const files = await sortedPackFiles(vaultPath);
+    if (files.some((file) => file.endsWith('.blpk'))) {
+        return { imported: false };
+    }
+    const legacyPackFiles = files.filter((file) => file.endsWith('.jsonl.gz'));
+    if (legacyPackFiles.length > 0) {
+        const rows = [];
+        for (const file of legacyPackFiles) {
+            const parsed = await parseRowsFromPack(vaultPath, await readFile(join(toPackDirectory(vaultPath), file)));
+            rows.push(...parsed);
+        }
+        const report = await writeRowsAsPrivatePacks(vaultPath, rows, true);
+        return {
+            imported: true,
+            source: 'legacy-packs',
+            ...report
+        };
+    }
+    return { imported: false };
+};
 export const searchInPacks = async (vaultPath, query, limit, agentId) => {
     const normalizedAgent = agentId?.trim();
     const tokens = tokenize(query);

package/docs/AGENT_USAGE.md

@@ -18,7 +18,7 @@ The correct dependency direction is:
 agent -> Brainlink CLI -> Markdown vault + derived index
 ```
 
-Agents should never depend on the internal SQLite schema as a public API.
+Agents should never depend on internal index persistence files as a public API.
 
 The installed CLI exposes two equivalent binaries:
 
@@ -180,16 +180,16 @@ Required write behavior:
 Good linked note:
 
 ```bash
-blink add "SQLite Index Rebuild" \
+blink add "Index Rebuild" \
   --agent coding-agent \
-  --content "Legacy derived indexes without agent columns are rebuilt because SQLite is disposable. Related: [[Architecture]], [[Agent Namespaces]]. #sqlite #architecture #decision"
+  --content "Derived index artifacts are rebuildable and disposable. Related: [[Architecture]], [[Agent Namespaces]]. #index #architecture #decision"
 blink validate --agent coding-agent
 ```
 
 Poor disconnected note:
 
 ```bash
-blink add "SQLite Index Rebuild" \
+blink add "Index Rebuild" \
   --agent coding-agent \
   --content "We rebuild old indexes now."
 ```
@@ -460,11 +460,11 @@ If `--mode`/`--limit` are omitted, Brainlink resolves those values from the acti
 
 Search modes:
 
-- `hybrid`: default; combines SQLite FTS and local embedding similarity.
-- `fts`: lexical SQLite full-text search only.
-- `semantic`: local deterministic embedding similarity with SQLite bucket candidate narrowing.
+- `hybrid`: default; combines lexical matching and local embedding similarity.
+- `fts`: lexical full-text matching only.
+- `semantic`: local deterministic embedding similarity.
 
-Hybrid results are cached in-memory for a short TTL and invalidated when `.brainlink/brainlink.db` changes.
+Hybrid results are cached in-memory for a short TTL and invalidated when `.brainlink/index.json` changes.
 
 ### Build Agent Context
 
@@ -634,8 +634,7 @@ GET  /api/validate
 
 The HTTP API is read-only. Use the CLI for writes and indexing.
 
-Brainlink maintains an automatic SQLite rollback snapshot at `.brainlink/brainlink.db.backup` and rotating snapshots in `.brainlink/brainlink.db.backup.snapshots/`. When `.brainlink/brainlink.db` is corrupted, Brainlink restores the newest valid snapshot automatically or recreates a clean index if no snapshot exists yet.
-Indexing also writes private encrypted search packs at `.brainlink/search-packs/*.blpk`; when SQLite cannot be opened, Brainlink falls back to pack-based search automatically.
+Indexing writes private encrypted search packs at `.brainlink/search-packs/*.blpk` for resilient retrieval and portability.
 Pack decryption keys are resolved from `$BRAINLINK_HOME/keys` (or `BRAINLINK_SEARCH_PACK_KEY` when explicitly set).
 
 ## Agent Integration Contract
@@ -669,9 +668,9 @@ Non-goals:
 ## Operational Rules
 
 - Re-run `index` after modifying notes.
-- Treat `.brainlink/brainlink.db` as disposable.
-- Commit Markdown notes, not local database files.
-- Do not manually edit the database.
+- Treat `.brainlink/index.json` and `.brainlink/search-packs/` as disposable.
+- Commit Markdown notes, not local index files.
+- Do not manually edit generated index artifacts.
 - Keep generated context short enough for the target model.
 - Prefer specific queries over broad queries.
 - Write explicit `[[wiki links]]` when durable memory should be connected.
@@ -701,9 +700,9 @@ Weak retrieval usually means:
 
 ## Current Limits
 
-- Search supports FTS, local semantic embeddings, SQLite semantic buckets and hybrid ranking.
+- Search supports FTS, local semantic embeddings and hybrid ranking.
 - Local embeddings are deterministic and provider-free; remote embedding providers are not implemented yet.
 - MCP integration is available through the `brainlink-mcp` stdio server.
 - HTTP API is local and unauthenticated.
-- Bucket vaults support S3-compatible `s3://bucket/prefix` URIs and use a local cache for SQLite indexes.
+- Bucket vaults support S3-compatible `s3://bucket/prefix` URIs and use local cache/index artifacts.
 - Watch mode depends on platform filesystem watcher behavior and is only supported for local filesystem vaults.

package/docs/ARCHITECTURE.md

@@ -8,7 +8,7 @@ CLI -> application use cases -> domain functions -> infrastructure adapters
 
 The core rule is simple:
 
-Domain code must not know about the CLI, filesystem, or SQLite.
+Domain code must not know about the CLI, filesystem, or index persistence format.
 
 ## Modules
 
@@ -53,14 +53,11 @@ src/
     types.ts
 
   infrastructure/
-    sqlite/
-      document-writer.ts
-      graph-reader.ts
-      schema.ts
-      search-reader.ts
+    file-index.ts
     file-system-vault.ts
+    private-pack-codec.ts
+    search-packs.ts
     session-state.ts
-    sqlite-index.ts
 
   mcp/
     main.ts
@@ -80,7 +77,6 @@ The domain layer contains pure knowledge rules:
 - extract `#tags`
 - split documents into chunks
 - create deterministic local embeddings
-- create deterministic embedding buckets for semantic candidate retrieval
 - calculate cosine similarity
 - estimate token counts
 - select context sections
@@ -116,12 +112,11 @@ The infrastructure layer handles side effects:
 - mirroring S3-compatible bucket Markdown into a local cache
 - writing Markdown notes
 - creating `.brainlink`
-- writing and querying SQLite
-- running FTS, semantic and hybrid retrieval
-- narrowing semantic candidates through SQLite embedding buckets before cosine scoring
+- writing and querying file-based indexes
+- running lexical, semantic and hybrid retrieval
 
-SQLite is an index, not the canonical storage model. For bucket vaults, Markdown
-objects in the bucket remain canonical and SQLite is still local derived data.
+
+Index artifacts are rebuildable and are not canonical storage. For bucket vaults, Markdown objects in the bucket remain canonical and local index files are derived data.
 
 ## Indexing Flow
 
@@ -132,11 +127,9 @@ read markdown files
   -> resolve links
   -> split chunks
   -> create chunk embeddings
-  -> reset SQLite index
+  -> reset file index
   -> persist documents, chunks and links
-  -> populate FTS records
-  -> persist embedding vectors
-  -> persist embedding buckets
+  -> persist chunks, links and embeddings in file index
 ```
 
 ## Retrieval Flow
@@ -145,7 +138,7 @@ read markdown files
 question
   -> selected mode: fts | semantic | hybrid
   -> optional query embedding
-  -> FTS query and/or embedding bucket candidate lookup
+  -> lexical scoring and/or semantic cosine scoring
   -> cosine similarity over candidate chunks
   -> ranked chunks with textScore and semanticScore
   -> token-budget selection
@@ -163,7 +156,7 @@ server command
   -> browser renders graph canvas
 ```
 
-The graph UI is intentionally read-only. Markdown remains the write interface and SQLite remains a derived index.
+The graph UI is intentionally read-only. Markdown remains the write interface and index artifacts remain derived data.
 
 ## HTTP API Flow
 
@@ -171,7 +164,7 @@ The graph UI is intentionally read-only. Markdown remains the write interface an
 HTTP request
   -> route handler
   -> application use case
-  -> filesystem and SQLite adapters
+  -> filesystem and index adapters
   -> JSON response
 ```
 
@@ -282,11 +275,10 @@ vault/agents/<agent-id>/**/*.md
 
 Rebuildable:
 
-- `.brainlink/brainlink.db`
+- `.brainlink/index.json`
+- `.brainlink/search-packs/*.blpk`
 - `$BRAINLINK_HOME/bucket-cache`
-- FTS records
 - local embedding vectors
-- local embedding bucket index
 - chunks
 - resolved links
 
@@ -296,13 +288,13 @@ Rebuildable:
 
 Markdown keeps the system portable, inspectable, Git-friendly, and compatible with Obsidian-like workflows.
 
-### SQLite As Local Index
+### File Index As Local Index
 
-SQLite gives fast local search, local vector storage and rebuildable retrieval without forcing users to run external infrastructure.
+Brainlink uses a local JSON index plus encrypted pack exports for fast rebuildable retrieval without external infrastructure.
 Hybrid retrieval also uses a short-lived in-memory cache keyed by vault/query/agent and invalidated by index file mtime to reduce repeated query latency.
-Brainlink also writes a local rollback snapshot (`.brainlink/brainlink.db.backup`) plus rotating point-in-time snapshots (`.brainlink/brainlink.db.backup.snapshots/`) after successful indexing. On corruption detection (`quick_check`/SQLite malformed errors), Brainlink restores the newest valid snapshot automatically before reopening the index.
-Indexing additionally exports private encrypted pack files (`.brainlink/search-packs/*.blpk`) from indexed chunks. Search falls back to these packs when SQLite is unavailable, preserving retrieval continuity in degraded mode.
+Indexing exports private encrypted pack files (`.brainlink/search-packs/*.blpk`) from indexed chunks for fast retrieval and recovery continuity.
 Pack encryption keys are resolved from `$BRAINLINK_HOME/keys` or from `BRAINLINK_SEARCH_PACK_KEY` when configured.
+Legacy `.jsonl.gz` search packs are auto-upgraded to `.blpk` on first retrieval flow.
 
 ### CLI First
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/brainlink",
-  "version": "0.1.0-beta.13",
+  "version": "0.1.0-beta.15",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",
@@ -58,12 +58,10 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1038.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "better-sqlite3": "^12.9.0",
     "commander": "^14.0.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^24.9.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",

package/dist/infrastructure/sqlite/document-writer.js

@@ -1,51 +0,0 @@
-import { createEmbeddingBuckets } from '../../domain/embeddings.js';
-const toTitleKey = (title) => title.toLowerCase();
-export const createIndexWriter = (database) => ({
-    reset: () => {
-        database.exec(`
-      DELETE FROM embedding_buckets;
-      DELETE FROM chunks_fts;
-      DELETE FROM links;
-      DELETE FROM chunks;
-      DELETE FROM documents;
-    `);
-    },
-    saveDocuments: (documents) => {
-        const insertDocument = database.prepare(`
-      INSERT INTO documents (id, agent_id, title, path, content, tags_json, frontmatter_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        const insertChunk = database.prepare(`
-      INSERT INTO chunks (id, document_id, ordinal, content, token_count, embedding_provider, embedding_json)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-        const insertChunkFts = database.prepare(`
-      INSERT INTO chunks_fts (chunk_id, document_id, agent_id, title, content)
-      VALUES (?, ?, ?, ?, ?)
-    `);
-        const insertEmbeddingBucket = database.prepare(`
-      INSERT OR IGNORE INTO embedding_buckets (bucket, chunk_id)
-      VALUES (?, ?)
-    `);
-        const insertLink = database.prepare(`
-      INSERT INTO links (from_document_id, to_title, to_title_key, to_document_id, weight, priority)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-        const transaction = database.transaction(() => {
-            documents.forEach(({ document, chunks, links }) => {
-                insertDocument.run(document.id, document.agentId, document.title, document.path, document.content, JSON.stringify(document.tags), JSON.stringify(document.frontmatter), document.createdAt, document.updatedAt);
-                chunks.forEach((chunk) => {
-                    insertChunk.run(chunk.id, chunk.documentId, chunk.ordinal, chunk.content, chunk.tokenCount, chunk.embeddingProvider, JSON.stringify(chunk.embedding));
-                    insertChunkFts.run(chunk.id, chunk.documentId, document.agentId, document.title, chunk.content);
-                    createEmbeddingBuckets(chunk.embedding).forEach((bucket) => insertEmbeddingBucket.run(bucket, chunk.id));
-                });
-            });
-            documents.forEach(({ links }) => {
-                links.forEach((link) => {
-                    insertLink.run(link.fromDocumentId, link.toTitle, toTitleKey(link.toTitle), link.toDocumentId, link.weight, link.priority);
-                });
-            });
-        });
-        transaction();
-    }
-});