@andespindola/brainlink 0.1.0-beta.14 → 0.1.0-beta.16

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

@@ -1,8 +1,6 @@
-import Database from 'better-sqlite3';
 import { gunzipSync } from 'node:zlib';
 import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { existsSync } from 'node:fs';
 import { decodePrivatePack, encodePrivatePack, isPrivatePackPayload } from './private-pack-codec.js';
 const packsDirectoryName = 'search-packs';
 const manifestFileName = 'manifest.json';
@@ -10,7 +8,6 @@ const rowChunkSize = 5_000;
 const queryTokenPattern = /[\p{L}\p{N}_-]+/gu;
 const toPackDirectory = (vaultPath) => join(vaultPath, '.brainlink', packsDirectoryName);
 const toManifestPath = (vaultPath) => join(toPackDirectory(vaultPath), manifestFileName);
-const toDatabasePath = (vaultPath) => join(vaultPath, '.brainlink', 'brainlink.db');
 const parseRowsFromPack = async (vaultPath, content) => {
     const raw = isPrivatePackPayload(content) ? await decodePrivatePack(vaultPath, content) : gunzipSync(content);
     return raw
@@ -32,15 +29,6 @@ const toRows = (documents) => documents.flatMap((document) => document.chunks.ma
 const writeManifest = async (vaultPath, manifest) => {
     await writeFile(toManifestPath(vaultPath), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
 };
-const parseTags = (value) => {
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : [];
-    }
-    catch {
-        return [];
-    }
-};
 const chunkRows = (rows, size) => {
     const chunks = [];
     for (let index = 0; index < rows.length; index += size) {
@@ -140,67 +128,6 @@ const writeRowsAsPrivatePacks = async (vaultPath, rows, clearExisting) => {
         recordCount: rows.length
     };
 };
-const tableExists = (database, table) => {
-    const row = database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
-    return row?.name === table;
-};
-const tableColumns = (database, table) => {
-    const rows = database.prepare(`SELECT name FROM pragma_table_info('${table.replaceAll("'", "''")}')`).all();
-    return new Set(rows.map((row) => row.name));
-};
-const loadRowsFromLegacySqlite = (vaultPath) => {
-    const databasePath = toDatabasePath(vaultPath);
-    if (!existsSync(databasePath)) {
-        return [];
-    }
-    const database = new Database(databasePath, { readonly: true, fileMustExist: true });
-    try {
-        if (!tableExists(database, 'documents') || !tableExists(database, 'chunks')) {
-            return [];
-        }
-        const documentColumns = tableColumns(database, 'documents');
-        const chunkColumns = tableColumns(database, 'chunks');
-        if (!documentColumns.has('id') || !documentColumns.has('title') || !chunkColumns.has('document_id')) {
-            return [];
-        }
-        const agentExpr = documentColumns.has('agent_id') ? 'documents.agent_id' : "'shared'";
-        const pathExpr = documentColumns.has('path') ? 'documents.path' : "documents.title";
-        const tagsExpr = documentColumns.has('tags_json') ? 'documents.tags_json' : "'[]'";
-        const chunkIdExpr = chunkColumns.has('id') ? 'chunks.id' : "documents.id || ':' || chunks.rowid";
-        const chunkContentExpr = chunkColumns.has('content')
-            ? 'chunks.content'
-            : documentColumns.has('content')
-                ? 'documents.content'
-                : "''";
-        const chunkOrderExpr = chunkColumns.has('ordinal') ? 'chunks.ordinal' : 'chunks.rowid';
-        const statement = database.prepare(`
-      SELECT
-        documents.id AS document_id,
-        ${agentExpr} AS agent_id,
-        documents.title AS title,
-        ${pathExpr} AS path,
-        ${chunkIdExpr} AS chunk_id,
-        ${chunkContentExpr} AS content,
-        ${tagsExpr} AS tags_json
-      FROM chunks
-      JOIN documents ON documents.id = chunks.document_id
-      ORDER BY documents.title, ${chunkOrderExpr}
-    `);
-        const rows = statement.all();
-        return rows.map((row) => ({
-            documentId: row.document_id,
-            agentId: typeof row.agent_id === 'string' && row.agent_id.length > 0 ? row.agent_id : 'shared',
-            title: row.title,
-            path: row.path,
-            chunkId: row.chunk_id,
-            content: row.content ?? '',
-            tags: parseTags(row.tags_json)
-        }));
-    }
-    finally {
-        database.close();
-    }
-};
 export const buildSearchPacks = async (vaultPath, documents) => {
     return writeRowsAsPrivatePacks(vaultPath, toRows(documents), true);
 };
@@ -223,16 +150,7 @@ export const ensurePrivatePacksFromLegacyIndex = async (vaultPath) => {
             ...report
         };
     }
-    const legacyRows = loadRowsFromLegacySqlite(vaultPath);
-    if (legacyRows.length === 0) {
-        return { imported: false };
-    }
-    const report = await writeRowsAsPrivatePacks(vaultPath, legacyRows, true);
-    return {
-        imported: true,
-        source: 'legacy-sqlite',
-        ...report
-    };
+    return { imported: false };
 };
 export const searchInPacks = async (vaultPath, query, limit, agentId) => {
     const normalizedAgent = agentId?.trim();

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,10 +634,8 @@ 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).
-For legacy installations, when SQLite already exists but private packs are missing, Brainlink auto-imports index context rows from `brainlink.db` into `.blpk` on first retrieval.
 
 ## Agent Integration Contract
 
@@ -670,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.
@@ -702,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,14 +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 upgrades are automatic: when a vault has `brainlink.db` but no `.blpk` packs yet, Brainlink extracts indexed context rows from SQLite and writes private packs on first retrieval flow.
+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.14",
+  "version": "0.1.0-beta.16",
   "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",