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

package/dist/infrastructure/search-packs.js

@@ -0,0 +1,452 @@
+import { gunzipSync } from 'node:zlib';
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { middleOutIndices } from '../domain/middle-out.js';
+import { decodePrivatePack, encodePrivatePack, isPrivatePackPayload } from './private-pack-codec.js';
+const packsDirectoryName = 'search-packs';
+const manifestFileName = 'manifest.json';
+const defaultBuildOptions = {
+    rowChunkSize: 5_000,
+    compressionLevel: 5,
+    useDictionary: true
+};
+const queryTokenPattern = /[\p{L}\p{N}_-]+/gu;
+const bloomBytes = 256;
+const bloomBitSize = bloomBytes * 8;
+const bloomSeeds = [0x9e3779b1, 0x85ebca6b, 0xc2b2ae35];
+const toPackDirectory = (vaultPath) => join(vaultPath, '.brainlink', packsDirectoryName);
+const toManifestPath = (vaultPath) => join(toPackDirectory(vaultPath), manifestFileName);
+const parseRowsFromPack = async (vaultPath, content) => {
+    const raw = isPrivatePackPayload(content) ? await decodePrivatePack(vaultPath, content) : gunzipSync(content);
+    return raw
+        .toString('utf8')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map((line) => JSON.parse(line))
+        .flatMap((row) => {
+        if (typeof row.documentId !== 'string' ||
+            typeof row.agentId !== 'string' ||
+            typeof row.title !== 'string' ||
+            typeof row.path !== 'string' ||
+            typeof row.chunkId !== 'string' ||
+            typeof row.content !== 'string') {
+            return [];
+        }
+        return [
+            {
+                documentId: row.documentId,
+                agentId: row.agentId,
+                title: row.title,
+                path: row.path,
+                chunkId: row.chunkId,
+                chunkOrdinal: typeof row.chunkOrdinal === 'number' ? row.chunkOrdinal : 0,
+                content: row.content,
+                tags: Array.isArray(row.tags) ? row.tags.filter((item) => typeof item === 'string') : []
+            }
+        ];
+    });
+};
+const toRows = (documents) => documents.flatMap((document) => document.chunks.map((chunk) => ({
+    documentId: document.document.id,
+    agentId: document.document.agentId,
+    title: document.document.title,
+    path: document.document.path,
+    chunkId: chunk.id,
+    chunkOrdinal: chunk.ordinal,
+    content: chunk.content,
+    tags: document.document.tags
+})));
+const writeManifest = async (vaultPath, manifest) => {
+    await writeFile(toManifestPath(vaultPath), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+};
+const readManifest = async (vaultPath) => {
+    try {
+        const parsed = JSON.parse(await readFile(toManifestPath(vaultPath), 'utf8'));
+        if (parsed.version === 2 && parsed.format === 'private-v2') {
+            return {
+                version: 2,
+                createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : new Date().toISOString(),
+                packCount: typeof parsed.packCount === 'number' ? parsed.packCount : 0,
+                recordCount: typeof parsed.recordCount === 'number' ? parsed.recordCount : 0,
+                format: 'private-v2'
+            };
+        }
+        if (parsed.version === 3 && parsed.format === 'private-v2') {
+            const packIndex = Array.isArray(parsed.packIndex)
+                ? parsed.packIndex.flatMap((entry) => {
+                    if (!entry || typeof entry !== 'object') {
+                        return [];
+                    }
+                    const candidate = entry;
+                    if (typeof candidate.fileName !== 'string' || typeof candidate.tokenBloomB64 !== 'string') {
+                        return [];
+                    }
+                    return [
+                        {
+                            fileName: candidate.fileName,
+                            recordCount: typeof candidate.recordCount === 'number' ? candidate.recordCount : 0,
+                            agents: Array.isArray(candidate.agents) ? candidate.agents.filter((item) => typeof item === 'string') : [],
+                            tokenBloomB64: candidate.tokenBloomB64
+                        }
+                    ];
+                })
+                : [];
+            return {
+                version: 3,
+                createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : new Date().toISOString(),
+                packCount: typeof parsed.packCount === 'number' ? parsed.packCount : packIndex.length,
+                recordCount: typeof parsed.recordCount === 'number' ? parsed.recordCount : 0,
+                format: 'private-v2',
+                packIndex,
+                ...(parsed.packConfig && typeof parsed.packConfig === 'object'
+                    ? {
+                        packConfig: {
+                            rowChunkSize: typeof parsed.packConfig.rowChunkSize === 'number'
+                                ? parsed.packConfig.rowChunkSize
+                                : defaultBuildOptions.rowChunkSize,
+                            compressionLevel: typeof parsed.packConfig.compressionLevel === 'number'
+                                ? parsed.packConfig.compressionLevel
+                                : defaultBuildOptions.compressionLevel,
+                            useDictionary: typeof parsed.packConfig.useDictionary === 'boolean'
+                                ? parsed.packConfig.useDictionary
+                                : defaultBuildOptions.useDictionary
+                        }
+                    }
+                    : {}),
+                ...(parsed.compression &&
+                    typeof parsed.compression === 'object' &&
+                    typeof parsed.compression.inputBytes === 'number' &&
+                    typeof parsed.compression.outputBytes === 'number' &&
+                    typeof parsed.compression.ratio === 'number' &&
+                    typeof parsed.compression.savedBytes === 'number'
+                    ? {
+                        compression: {
+                            inputBytes: parsed.compression.inputBytes,
+                            outputBytes: parsed.compression.outputBytes,
+                            ratio: parsed.compression.ratio,
+                            savedBytes: parsed.compression.savedBytes
+                        }
+                    }
+                    : {})
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+export const ensureSearchPackManifest = async (vaultPath) => {
+    const manifest = await readManifest(vaultPath);
+    if (manifest) {
+        return {
+            repaired: false,
+            source: 'not-needed',
+            packCount: manifest.packCount
+        };
+    }
+    const files = await sortedPackFiles(vaultPath);
+    const packFiles = files.filter((file) => file.endsWith('.blpk'));
+    if (packFiles.length === 0) {
+        return {
+            repaired: false,
+            source: 'no-packs',
+            packCount: 0
+        };
+    }
+    await writeManifest(vaultPath, {
+        version: 2,
+        createdAt: new Date().toISOString(),
+        packCount: packFiles.length,
+        recordCount: 0,
+        format: 'private-v2'
+    });
+    return {
+        repaired: true,
+        source: 'existing-packs',
+        packCount: packFiles.length
+    };
+};
+const chunkRows = (rows, size) => {
+    const chunks = [];
+    for (let index = 0; index < rows.length; index += size) {
+        chunks.push(rows.slice(index, index + size));
+    }
+    return chunks;
+};
+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 start = 0;
+    while (start < text.length) {
+        const index = text.indexOf(token, start);
+        if (index < 0) {
+            break;
+        }
+        hits += 1;
+        start = index + token.length;
+    }
+    return hits;
+};
+const hashToken = (token, seed) => {
+    let hash = seed >>> 0;
+    for (let index = 0; index < token.length; index += 1) {
+        hash ^= token.charCodeAt(index);
+        hash = Math.imul(hash, 16777619) >>> 0;
+    }
+    return hash >>> 0;
+};
+const createBloom = () => new Uint8Array(bloomBytes);
+const bloomAdd = (bloom, token) => {
+    bloomSeeds.forEach((seed) => {
+        const bit = hashToken(token, seed) % bloomBitSize;
+        bloom[Math.floor(bit / 8)] |= 1 << (bit % 8);
+    });
+};
+const bloomMayContain = (bloom, token) => bloomSeeds.every((seed) => {
+    const bit = hashToken(token, seed) % bloomBitSize;
+    return (bloom[Math.floor(bit / 8)] & (1 << (bit % 8))) !== 0;
+});
+const bloomFromRows = (rows) => {
+    const bloom = createBloom();
+    rows.forEach((row) => {
+        tokenize([row.title, row.path, row.tags.join(' '), row.content].join(' ')).forEach((token) => bloomAdd(bloom, token));
+    });
+    return bloom;
+};
+const bloomToBase64 = (bloom) => Buffer.from(bloom).toString('base64url');
+const bloomFromBase64 = (value) => {
+    try {
+        const decoded = Buffer.from(value, 'base64url');
+        if (decoded.byteLength === bloomBytes) {
+            return {
+                bloom: new Uint8Array(decoded),
+                valid: true
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    return {
+        bloom: createBloom(),
+        valid: false
+    };
+};
+const computeTextScore = (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, 5);
+    }, 0);
+};
+const toSearchResult = (row, score) => ({
+    documentId: row.documentId,
+    agentId: row.agentId,
+    title: row.title,
+    path: row.path,
+    chunkId: row.chunkId,
+    chunkOrdinal: row.chunkOrdinal,
+    content: row.content,
+    score,
+    textScore: score,
+    semanticScore: 0,
+    searchMode: 'fts',
+    tags: row.tags
+});
+const sortedPackFiles = async (vaultPath) => {
+    try {
+        const files = await readdir(toPackDirectory(vaultPath));
+        return files
+            .filter((file) => file.endsWith('.blpk') || file.endsWith('.jsonl.gz'))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+};
+const writeRowsAsPrivatePacks = async (vaultPath, rows, clearExisting, options) => {
+    const startedAt = process.hrtime.bigint();
+    const directory = toPackDirectory(vaultPath);
+    await mkdir(directory, { recursive: 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, options.rowChunkSize);
+    const packIndex = [];
+    let inputBytes = 0;
+    let outputBytes = 0;
+    for (let index = 0; index < chunks.length; index += 1) {
+        const chunk = chunks[index];
+        const fileName = `pack-${String(index + 1).padStart(4, '0')}.blpk`;
+        const serialized = `${chunk.map((row) => JSON.stringify(row)).join('\n')}\n`;
+        const compressed = await encodePrivatePack(vaultPath, Buffer.from(serialized, 'utf8'), {
+            compressionLevel: options.compressionLevel,
+            useDictionary: options.useDictionary
+        });
+        const tokenBloomB64 = bloomToBase64(bloomFromRows(chunk));
+        await writeFile(join(directory, fileName), compressed);
+        inputBytes += Buffer.byteLength(serialized, 'utf8');
+        outputBytes += compressed.byteLength;
+        packIndex.push({
+            fileName,
+            recordCount: chunk.length,
+            agents: Array.from(new Set(chunk.map((row) => row.agentId))).sort((left, right) => left.localeCompare(right)),
+            tokenBloomB64
+        });
+    }
+    await writeManifest(vaultPath, {
+        version: 3,
+        createdAt: new Date().toISOString(),
+        packCount: chunks.length,
+        recordCount: rows.length,
+        format: 'private-v2',
+        packIndex,
+        packConfig: {
+            rowChunkSize: options.rowChunkSize,
+            compressionLevel: options.compressionLevel,
+            useDictionary: options.useDictionary
+        },
+        compression: {
+            inputBytes,
+            outputBytes,
+            ratio: outputBytes / Math.max(inputBytes, 1),
+            savedBytes: Math.max(inputBytes - outputBytes, 0)
+        }
+    });
+    const durationMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+    const safeInput = Math.max(inputBytes, 1);
+    const savedBytes = Math.max(inputBytes - outputBytes, 0);
+    return {
+        packCount: chunks.length,
+        recordCount: rows.length,
+        compression: {
+            inputBytes,
+            outputBytes,
+            ratio: outputBytes / safeInput,
+            savedBytes
+        },
+        durationMs
+    };
+};
+const selectCandidatePackFiles = async (vaultPath, tokens, agentId) => {
+    const allFiles = await sortedPackFiles(vaultPath);
+    if (allFiles.length === 0) {
+        return [];
+    }
+    const manifest = await readManifest(vaultPath);
+    if (!manifest || manifest.version !== 3 || !Array.isArray(manifest.packIndex)) {
+        return allFiles;
+    }
+    const normalizedAgent = agentId?.trim();
+    const byAgent = manifest.packIndex.filter((entry) => normalizedAgent ? entry.agents.includes(normalizedAgent) : true);
+    if (tokens.length === 0) {
+        return byAgent.map((entry) => entry.fileName);
+    }
+    let hasInvalidBloomIndex = false;
+    const byToken = byAgent.filter((entry) => {
+        const decoded = bloomFromBase64(entry.tokenBloomB64);
+        if (!decoded.valid) {
+            hasInvalidBloomIndex = true;
+            return true;
+        }
+        return tokens.some((token) => bloomMayContain(decoded.bloom, token));
+    });
+    // Lossless guarantee: if compressed metadata is partially invalid, do not prune packs.
+    if (hasInvalidBloomIndex) {
+        return byAgent.map((entry) => entry.fileName);
+    }
+    if (byToken.length > 0) {
+        return byToken.map((entry) => entry.fileName);
+    }
+    return byAgent.length > 0 ? byAgent.map((entry) => entry.fileName) : allFiles;
+};
+export const buildSearchPacks = async (vaultPath, documents, options) => {
+    const resolvedOptions = {
+        rowChunkSize: options?.rowChunkSize ?? defaultBuildOptions.rowChunkSize,
+        compressionLevel: options?.compressionLevel ?? defaultBuildOptions.compressionLevel,
+        useDictionary: options?.useDictionary ?? defaultBuildOptions.useDictionary
+    };
+    return writeRowsAsPrivatePacks(vaultPath, toRows(documents), true, resolvedOptions);
+};
+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, defaultBuildOptions);
+        return {
+            imported: true,
+            source: 'legacy-packs',
+            ...report
+        };
+    }
+    return { imported: false };
+};
+export const toSearchPackBuildOptions = (config) => ({
+    rowChunkSize: config.searchPack.rowChunkSize,
+    compressionLevel: config.searchPack.compressionLevel,
+    useDictionary: config.searchPack.useDictionary
+});
+export const searchInPacks = async (vaultPath, query, limit, agentId) => {
+    const normalizedAgent = agentId?.trim();
+    const tokens = tokenize(query);
+    if (limit <= 0 || tokens.length === 0) {
+        return [];
+    }
+    const files = await selectCandidatePackFiles(vaultPath, tokens, normalizedAgent);
+    if (files.length === 0) {
+        return [];
+    }
+    const scored = [];
+    for (const file of files) {
+        const rows = await parseRowsFromPack(vaultPath, await readFile(join(toPackDirectory(vaultPath), file)));
+        const traversal = middleOutIndices(rows.length, Math.floor(rows.length / 2));
+        traversal.forEach((rowIndex) => {
+            const row = rows[rowIndex];
+            if (!row) {
+                return;
+            }
+            if (normalizedAgent && row.agentId !== normalizedAgent) {
+                return;
+            }
+            const score = computeTextScore(row, tokens);
+            if (score > 0) {
+                scored.push(toSearchResult(row, score));
+            }
+        });
+    }
+    return scored
+        .sort((left, right) => right.score - left.score || left.title.localeCompare(right.title))
+        .slice(0, limit);
+};

package/dist/infrastructure/session-state.js

@@ -0,0 +1,172 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getBrainlinkHomePath } from './paths.js';
+const defaultPolicy = {
+    enforceBootstrap: true,
+    enforceContextFirst: true,
+    autoBootstrapOnRead: true,
+    autoBootstrapOnStartup: true,
+    staleAfterMinutes: 120
+};
+const defaultState = {
+    policy: defaultPolicy,
+    bootstraps: [],
+    contexts: []
+};
+const sessionStatePath = () => join(getBrainlinkHomePath(), 'session-state.json');
+const normalizeAgent = (agent) => agent?.trim() ? agent.trim() : '*';
+const safePositive = (value, fallback) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+const sanitizeState = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return defaultState;
+    }
+    const record = value;
+    const policyRecord = typeof record.policy === 'object' && record.policy !== null ? record.policy : {};
+    const rawBootstraps = Array.isArray(record.bootstraps) ? record.bootstraps : [];
+    const rawContexts = Array.isArray(record.contexts) ? record.contexts : [];
+    const bootstraps = rawBootstraps.flatMap((entry) => {
+        if (typeof entry !== 'object' || entry === null) {
+            return [];
+        }
+        const row = entry;
+        const vault = typeof row.vault === 'string' && row.vault.trim().length > 0 ? row.vault.trim() : undefined;
+        const agent = typeof row.agent === 'string' && row.agent.trim().length > 0 ? row.agent.trim() : undefined;
+        const lastBootstrappedAt = typeof row.lastBootstrappedAt === 'string' && row.lastBootstrappedAt.trim().length > 0 ? row.lastBootstrappedAt.trim() : undefined;
+        return vault && agent && lastBootstrappedAt ? [{ vault, agent, lastBootstrappedAt }] : [];
+    });
+    const contexts = rawContexts.flatMap((entry) => {
+        if (typeof entry !== 'object' || entry === null) {
+            return [];
+        }
+        const row = entry;
+        const vault = typeof row.vault === 'string' && row.vault.trim().length > 0 ? row.vault.trim() : undefined;
+        const agent = typeof row.agent === 'string' && row.agent.trim().length > 0 ? row.agent.trim() : undefined;
+        const lastContextAt = typeof row.lastContextAt === 'string' && row.lastContextAt.trim().length > 0 ? row.lastContextAt.trim() : undefined;
+        return vault && agent && lastContextAt ? [{ vault, agent, lastContextAt }] : [];
+    });
+    return {
+        policy: {
+            enforceBootstrap: typeof policyRecord.enforceBootstrap === 'boolean' ? policyRecord.enforceBootstrap : defaultPolicy.enforceBootstrap,
+            enforceContextFirst: typeof policyRecord.enforceContextFirst === 'boolean'
+                ? policyRecord.enforceContextFirst
+                : defaultPolicy.enforceContextFirst,
+            autoBootstrapOnRead: typeof policyRecord.autoBootstrapOnRead === 'boolean'
+                ? policyRecord.autoBootstrapOnRead
+                : defaultPolicy.autoBootstrapOnRead,
+            autoBootstrapOnStartup: typeof policyRecord.autoBootstrapOnStartup === 'boolean'
+                ? policyRecord.autoBootstrapOnStartup
+                : defaultPolicy.autoBootstrapOnStartup,
+            staleAfterMinutes: safePositive(policyRecord.staleAfterMinutes, defaultPolicy.staleAfterMinutes)
+        },
+        bootstraps,
+        contexts
+    };
+};
+const readState = async () => {
+    try {
+        const content = await readFile(sessionStatePath(), 'utf8');
+        return sanitizeState(JSON.parse(content));
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return defaultState;
+        }
+        throw error;
+    }
+};
+const writeState = async (state) => {
+    const path = sessionStatePath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+};
+export const getSessionStatePath = () => sessionStatePath();
+export const getBootstrapPolicy = async () => (await readState()).policy;
+export const setBootstrapPolicy = async (patch) => {
+    const state = await readState();
+    const next = {
+        enforceBootstrap: typeof patch.enforceBootstrap === 'boolean' ? patch.enforceBootstrap : state.policy.enforceBootstrap,
+        enforceContextFirst: typeof patch.enforceContextFirst === 'boolean' ? patch.enforceContextFirst : state.policy.enforceContextFirst,
+        autoBootstrapOnRead: typeof patch.autoBootstrapOnRead === 'boolean' ? patch.autoBootstrapOnRead : state.policy.autoBootstrapOnRead,
+        autoBootstrapOnStartup: typeof patch.autoBootstrapOnStartup === 'boolean' ? patch.autoBootstrapOnStartup : state.policy.autoBootstrapOnStartup,
+        staleAfterMinutes: safePositive(patch.staleAfterMinutes, state.policy.staleAfterMinutes)
+    };
+    await writeState({
+        ...state,
+        policy: next
+    });
+    return next;
+};
+export const touchBootstrapSession = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const entry = {
+        vault,
+        agent: normalizedAgent,
+        lastBootstrappedAt: new Date().toISOString()
+    };
+    const bootstraps = [
+        entry,
+        ...state.bootstraps.filter((item) => !(item.vault === entry.vault && item.agent === entry.agent))
+    ].slice(0, 500);
+    await writeState({
+        ...state,
+        bootstraps
+    });
+    return entry;
+};
+export const touchContextSession = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const entry = {
+        vault,
+        agent: normalizedAgent,
+        lastContextAt: new Date().toISOString()
+    };
+    const contexts = [
+        entry,
+        ...state.contexts.filter((item) => !(item.vault === entry.vault && item.agent === entry.agent))
+    ].slice(0, 500);
+    await writeState({
+        ...state,
+        contexts
+    });
+    return entry;
+};
+export const getBootstrapSessionStatus = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const match = state.bootstraps.find((entry) => entry.vault === vault && entry.agent === normalizedAgent);
+    if (!match) {
+        return {
+            ready: false,
+            stale: true
+        };
+    }
+    const ageMinutes = Math.max(0, (Date.now() - new Date(match.lastBootstrappedAt).getTime()) / 60000);
+    const stale = ageMinutes > state.policy.staleAfterMinutes;
+    return {
+        ready: !stale,
+        stale,
+        lastBootstrappedAt: match.lastBootstrappedAt,
+        ageMinutes
+    };
+};
+export const getContextSessionStatus = async (vault, agent) => {
+    const state = await readState();
+    const normalizedAgent = normalizeAgent(agent);
+    const match = state.contexts.find((entry) => entry.vault === vault && entry.agent === normalizedAgent);
+    if (!match) {
+        return {
+            ready: false,
+            stale: true
+        };
+    }
+    const ageMinutes = Math.max(0, (Date.now() - new Date(match.lastContextAt).getTime()) / 60000);
+    const stale = ageMinutes > state.policy.staleAfterMinutes;
+    return {
+        ready: !stale,
+        stale,
+        lastContextAt: match.lastContextAt,
+        ageMinutes
+    };
+};

package/dist/mcp/main.js

@@ -1,9 +1,17 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createBrainlinkMcpServer } from './server.js';
-const server = createBrainlinkMcpServer();
-const transport = new StdioServerTransport();
-server.connect(transport).catch((error) => {
+import { runStartupBootstrap } from './startup.js';
+const start = async () => {
+    const startup = await runStartupBootstrap();
+    if (startup.error) {
+        console.error(`Brainlink MCP startup bootstrap warning: ${startup.error}`);
+    }
+    const server = createBrainlinkMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+};
+start().catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(message);
     process.exitCode = 1;