@andespindola/brainlink 0.1.0-beta.98 → 1.0.0

package/dist/application/server/routes.js

@@ -1,26 +1,46 @@
 import { getBrokenLinksReport, getOrphansReport, getStats, validateVault } from '../analyze-vault.js';
 import { buildContextPackage } from '../build-context.js';
 import { getGraph } from '../get-graph.js';
+import { getGraphContexts } from '../get-graph-contexts.js';
 import { getGraphNode } from '../get-graph-node.js';
 import { getGraphLayout } from '../get-graph-layout.js';
+import { getGraphView } from '../get-graph-view.js';
+import { getGraphStreamChunk } from '../get-graph-stream-chunk.js';
+import { deleteGraphViewState, getGraphViewState, saveGraphViewState } from '../graph-view-state.js';
 import { listAgents } from '../list-agents.js';
 import { listBacklinks, listLinks } from '../list-links.js';
 import { searchGraphNodeIds } from '../search-graph-node-ids.js';
 import { searchKnowledge } from '../search-knowledge.js';
-import { loadBrainlinkConfig, sanitizeSearchMode } from '../../infrastructure/config.js';
+import { loadBrainlinkConfig, resolveAgentRuntimeDefaults, sanitizeContextStrategy, sanitizeSearchMode } from '../../infrastructure/config.js';
 import { createClientCss } from '../frontend/client-css.js';
 import { createClientHtml } from '../frontend/client-html.js';
 import { createClientJs } from '../frontend/client-js.js';
 import { createClientWorkerJs } from '../frontend/client-worker-js.js';
+import { createClientRenderWorkerJs } from '../frontend/client-render-worker-js.js';
 import { contentTypes, createJsonResponse, isReadMethod, parsePositiveInteger } from './http.js';
 const readSearchMode = async (url) => {
     const config = await loadBrainlinkConfig();
-    return sanitizeSearchMode(url.searchParams.get('mode'), config.defaultSearchMode);
+    const defaults = resolveAgentRuntimeDefaults(config, readAgentQuery(url));
+    return sanitizeSearchMode(url.searchParams.get('mode'), defaults.defaultSearchMode);
+};
+const readContextStrategy = async (url) => {
+    const config = await loadBrainlinkConfig();
+    const defaults = resolveAgentRuntimeDefaults(config, readAgentQuery(url));
+    return sanitizeContextStrategy(url.searchParams.get('strategy'), defaults.defaultContextStrategy);
+};
+const readContextCacheTtlMs = async (url) => {
+    const config = await loadBrainlinkConfig();
+    const defaults = resolveAgentRuntimeDefaults(config, readAgentQuery(url));
+    return defaults.defaultContextCacheTtlMs;
 };
 const hasInvalidSearchMode = (url) => {
     const mode = url.searchParams.get('mode');
     return mode !== null && !['fts', 'semantic', 'hybrid'].includes(mode);
 };
+const hasInvalidContextStrategy = (url) => {
+    const strategy = url.searchParams.get('strategy');
+    return strategy !== null && !['rag', 'cag', 'auto'].includes(strategy);
+};
 const createResponse = (body, statusCode = 200, contentType = 'text/plain; charset=utf-8') => ({
     body,
     statusCode,
@@ -52,8 +72,68 @@ const sameEntityTag = (candidate, signature) => {
     return decodeEntityTag(candidate) === signature;
 };
 const readAgentQuery = (url) => url.searchParams.get('agent') ?? undefined;
+const readContextQuery = (url) => {
+    const value = url.searchParams.get('context')?.trim() ?? '';
+    return value.length > 0 ? value : undefined;
+};
+const parseNumber = (value, fallback) => {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+};
+const readJsonBody = async (request, limitBytes = 1_000_000) => {
+    let body = '';
+    for await (const chunk of request) {
+        body += String(chunk);
+        if (Buffer.byteLength(body, 'utf8') > limitBytes) {
+            throw Object.assign(new Error('Request body too large'), { statusCode: 413 });
+        }
+    }
+    return body.trim().length > 0 ? JSON.parse(body) : {};
+};
+const readGraphViewStateInput = (url) => ({
+    signature: url.searchParams.get('signature')?.trim() ?? '',
+    agentId: readAgentQuery(url),
+    context: readContextQuery(url)
+});
 const compactGraphLayoutThreshold = 12_000;
 const compactGraphLayoutEdgeLimit = 60_000;
+const graphLayoutBodyCacheLimit = 8;
+const graphLayoutBodyCache = new Map();
+let cachedClientHtml = null;
+let cachedClientCss = null;
+let cachedClientJs = null;
+let cachedClientWorkerJs = null;
+let cachedClientRenderWorkerJs = null;
+const readClientHtml = () => {
+    if (cachedClientHtml === null) {
+        cachedClientHtml = createClientHtml();
+    }
+    return cachedClientHtml;
+};
+const readClientCss = () => {
+    if (cachedClientCss === null) {
+        cachedClientCss = createClientCss();
+    }
+    return cachedClientCss;
+};
+const readClientJs = () => {
+    if (cachedClientJs === null) {
+        cachedClientJs = createClientJs();
+    }
+    return cachedClientJs;
+};
+const readClientWorkerJs = () => {
+    if (cachedClientWorkerJs === null) {
+        cachedClientWorkerJs = createClientWorkerJs();
+    }
+    return cachedClientWorkerJs;
+};
+const readClientRenderWorkerJs = () => {
+    if (cachedClientRenderWorkerJs === null) {
+        cachedClientRenderWorkerJs = createClientRenderWorkerJs();
+    }
+    return cachedClientRenderWorkerJs;
+};
 const compactGraphLayoutEdgeLimitFor = (nodeCount) => {
     if (nodeCount > 100_000)
         return 15_000;
@@ -114,11 +194,25 @@ const compactLayoutPayload = (layout) => {
     const compactNodes = layout.nodes.map((node) => [node.id, node.title, node.x, node.y, node.group, node.segment]);
     const compactEdgeRows = compactEdges
         .map((edge) => [edge.source, edge.target, edge.weight, edge.priority]);
+    const compactGroups = layout.groups?.map((group) => [
+        group.id,
+        group.level,
+        group.parentId,
+        group.title,
+        group.x,
+        group.y,
+        group.radius,
+        group.segment,
+        group.group,
+        group.nodeIds,
+        group.childGroupIds
+    ]);
     return {
         compact: true,
         layout: {
             nodes: compactNodes,
-            edges: compactEdgeRows
+            edges: compactEdgeRows,
+            ...(compactGroups && compactGroups.length > 0 ? { groups: compactGroups } : {})
         },
         totals: {
             nodes: layout.nodes.length,
@@ -127,29 +221,46 @@ const compactLayoutPayload = (layout) => {
     };
 };
 const encodeLayoutPayload = (layout) => layout.nodes.length > compactGraphLayoutThreshold ? compactLayoutPayload(layout) : { compact: false, layout: stripLayoutContent(layout) };
+const readGraphLayoutBody = (signature) => graphLayoutBodyCache.get(signature) ?? null;
+const storeGraphLayoutBody = (signature, body) => {
+    if (graphLayoutBodyCache.has(signature)) {
+        graphLayoutBodyCache.delete(signature);
+    }
+    graphLayoutBodyCache.set(signature, body);
+    while (graphLayoutBodyCache.size > graphLayoutBodyCacheLimit) {
+        const oldest = graphLayoutBodyCache.keys().next().value;
+        if (!oldest)
+            break;
+        graphLayoutBodyCache.delete(oldest);
+    }
+};
 export const route = async (request, url, vaultPath) => {
     if (isReadMethod(request) && (url.pathname === '/' || url.pathname === '/index.html')) {
-        return createResponse(createClientHtml(), 200, contentTypes['.html']);
+        return createResponse(readClientHtml(), 200, contentTypes['.html']);
     }
     if (isReadMethod(request) && url.pathname === '/styles.css') {
-        return createResponse(createClientCss(), 200, contentTypes['.css']);
+        return createResponse(readClientCss(), 200, contentTypes['.css']);
     }
     if (isReadMethod(request) && url.pathname === '/app.js') {
-        return createResponse(createClientJs(), 200, contentTypes['.js']);
+        return createResponse(readClientJs(), 200, contentTypes['.js']);
     }
     if (isReadMethod(request) && url.pathname === '/app-worker.js') {
-        return createResponse(createClientWorkerJs(), 200, contentTypes['.js']);
+        return createResponse(readClientWorkerJs(), 200, contentTypes['.js']);
+    }
+    if (isReadMethod(request) && url.pathname === '/render-worker.js') {
+        return createResponse(readClientRenderWorkerJs(), 200, contentTypes['.js']);
     }
     if (isReadMethod(request) && url.pathname === '/api/graph') {
         return createResponse(createJsonResponse(await getGraph(vaultPath, readAgentQuery(url))), 200, contentTypes['.json']);
     }
     if (isReadMethod(request) && url.pathname === '/api/graph-layout') {
-        const { signature, layout } = await getGraphLayout(vaultPath, readAgentQuery(url));
+        const { signature, layout } = await getGraphLayout(vaultPath, {
+            agentId: readAgentQuery(url),
+            context: readContextQuery(url)
+        });
         const requestEtags = request.headers['if-none-match'];
         const notModified = sameEntityTag(requestEtags, signature);
         const etag = encodeEntityTag(signature);
-        const body = createJsonResponse({ signature, ...encodeLayoutPayload(layout) });
-        const jsonResponse = createResponse(body, 200, contentTypes['.json']);
         const notModifiedResponse = createResponse('', 304, contentTypes['.json']);
         if (notModified) {
             return {
@@ -160,6 +271,12 @@ export const route = async (request, url, vaultPath) => {
                 }
             };
         }
+        const cachedBody = readGraphLayoutBody(signature);
+        const body = cachedBody ?? createJsonResponse({ signature, ...encodeLayoutPayload(layout) });
+        if (!cachedBody) {
+            storeGraphLayoutBody(signature, body);
+        }
+        const jsonResponse = createResponse(body, 200, contentTypes['.json']);
         return {
             ...jsonResponse,
             headers: {
@@ -168,6 +285,66 @@ export const route = async (request, url, vaultPath) => {
             }
         };
     }
+    if (isReadMethod(request) && url.pathname === '/api/graph-view') {
+        return createResponse(createJsonResponse(await getGraphView(vaultPath, {
+            x: parseNumber(url.searchParams.get('x'), -1000),
+            y: parseNumber(url.searchParams.get('y'), -1000),
+            width: parseNumber(url.searchParams.get('w'), 2000),
+            height: parseNumber(url.searchParams.get('h'), 2000),
+            scale: parseNumber(url.searchParams.get('scale'), 1),
+            agentId: readAgentQuery(url),
+            context: readContextQuery(url)
+        })), 200, contentTypes['.json']);
+    }
+    if (isReadMethod(request) && url.pathname === '/api/graph-stream') {
+        const x = parseNumber(url.searchParams.get('x'), -1000);
+        const y = parseNumber(url.searchParams.get('y'), -1000);
+        const width = parseNumber(url.searchParams.get('w'), 2000);
+        const height = parseNumber(url.searchParams.get('h'), 2000);
+        const scale = parseNumber(url.searchParams.get('scale'), 0.24);
+        const nodeBudget = parsePositiveInteger(url.searchParams.get('nodeBudget'), 1800);
+        const edgeBudget = parsePositiveInteger(url.searchParams.get('edgeBudget'), 5000);
+        return createResponse(createJsonResponse(await getGraphStreamChunk(vaultPath, {
+            x,
+            y,
+            width,
+            height,
+            scale,
+            nodeBudget,
+            edgeBudget,
+            agentId: readAgentQuery(url),
+            context: readContextQuery(url)
+        })), 200, contentTypes['.json']);
+    }
+    if (isReadMethod(request) && url.pathname === '/api/graph-view-state') {
+        const input = readGraphViewStateInput(url);
+        if (!input.signature) {
+            return createResponse(createJsonResponse({ error: 'Missing signature query parameter' }), 400, contentTypes['.json']);
+        }
+        return createResponse(createJsonResponse(await getGraphViewState(vaultPath, input)), 200, contentTypes['.json']);
+    }
+    if (request.method === 'POST' && url.pathname === '/api/graph-view-state') {
+        const input = readGraphViewStateInput(url);
+        if (!input.signature) {
+            return createResponse(createJsonResponse({ error: 'Missing signature query parameter' }), 400, contentTypes['.json']);
+        }
+        const body = await readJsonBody(request);
+        const positions = Array.isArray(body.positions)
+            ? body.positions.map((position) => ({
+                id: String(position.id ?? ''),
+                x: Number(position.x),
+                y: Number(position.y)
+            }))
+            : [];
+        return createResponse(createJsonResponse(await saveGraphViewState(vaultPath, { ...input, positions })), 200, contentTypes['.json']);
+    }
+    if (request.method === 'DELETE' && url.pathname === '/api/graph-view-state') {
+        const input = readGraphViewStateInput(url);
+        if (!input.signature) {
+            return createResponse(createJsonResponse({ error: 'Missing signature query parameter' }), 400, contentTypes['.json']);
+        }
+        return createResponse(createJsonResponse(await deleteGraphViewState(vaultPath, input)), 200, contentTypes['.json']);
+    }
     if (isReadMethod(request) && url.pathname === '/api/graph-node') {
         const id = url.searchParams.get('id')?.trim() ?? '';
         if (!id) {
@@ -185,12 +362,15 @@ export const route = async (request, url, vaultPath) => {
         if (!query) {
             return createResponse(createJsonResponse({ query, nodeIds: [] }), 200, contentTypes['.json']);
         }
-        const nodeIds = await searchGraphNodeIds(vaultPath, query, limit, readAgentQuery(url));
+        const nodeIds = await searchGraphNodeIds(vaultPath, query, limit, readAgentQuery(url), readContextQuery(url));
         return createResponse(createJsonResponse({ query, nodeIds }), 200, contentTypes['.json']);
     }
     if (isReadMethod(request) && url.pathname === '/api/agents') {
         return createResponse(createJsonResponse({ agents: await listAgents(vaultPath) }), 200, contentTypes['.json']);
     }
+    if (isReadMethod(request) && url.pathname === '/api/graph-contexts') {
+        return createResponse(createJsonResponse({ contexts: await getGraphContexts(vaultPath, readAgentQuery(url)) }), 200, contentTypes['.json']);
+    }
     if (isReadMethod(request) && url.pathname === '/api/search') {
         const query = url.searchParams.get('q') ?? '';
         const limit = parsePositiveInteger(url.searchParams.get('limit'), 10);
@@ -205,10 +385,15 @@ export const route = async (request, url, vaultPath) => {
         const limit = parsePositiveInteger(url.searchParams.get('limit'), 12);
         const tokens = parsePositiveInteger(url.searchParams.get('tokens'), 2000);
         const mode = await readSearchMode(url);
+        const strategy = await readContextStrategy(url);
+        const contextCacheTtlMs = await readContextCacheTtlMs(url);
         if (hasInvalidSearchMode(url)) {
             return createResponse(createJsonResponse({ error: 'Invalid mode. Use fts, semantic or hybrid.' }), 400, contentTypes['.json']);
         }
-        return createResponse(createJsonResponse(await buildContextPackage(vaultPath, query, limit, tokens, readAgentQuery(url), mode)), 200, contentTypes['.json']);
+        if (hasInvalidContextStrategy(url)) {
+            return createResponse(createJsonResponse({ error: 'Invalid strategy. Use rag, cag or auto.' }), 400, contentTypes['.json']);
+        }
+        return createResponse(createJsonResponse(await buildContextPackage(vaultPath, query, limit, tokens, readAgentQuery(url), mode, strategy, contextCacheTtlMs)), 200, contentTypes['.json']);
     }
     if (isReadMethod(request) && url.pathname === '/api/links') {
         return createResponse(createJsonResponse({ links: await listLinks(vaultPath, readAgentQuery(url)) }), 200, contentTypes['.json']);

package/dist/cli/commands/read-commands.js

@@ -1,10 +1,11 @@
 import { getBrokenLinksReport, getExtendedStats, getOrphansReport, getStats, validateVault } from '../../application/analyze-vault.js';
-import { buildContextPackage } from '../../application/build-context.js';
+import { buildContextPackage, readContextDataSignature } from '../../application/build-context.js';
 import { getGraph } from '../../application/get-graph.js';
 import { listAgents } from '../../application/list-agents.js';
 import { listBacklinks, listLinks } from '../../application/list-links.js';
 import { searchKnowledge } from '../../application/search-knowledge.js';
-import { sanitizeSearchMode } from '../../infrastructure/config.js';
+import { sanitizeContextStrategy, sanitizeSearchMode } from '../../infrastructure/config.js';
+import { clearContextPacks, listContextPacks } from '../../infrastructure/context-packs.js';
 import { parsePositiveInteger, print, resolveOptions } from '../runtime.js';
 export const registerReadCommands = (program) => {
     program
@@ -61,14 +62,49 @@ export const registerReadCommands = (program) => {
         .option('-l, --limit <limit>', 'maximum search results before context selection')
         .option('-t, --tokens <tokens>', 'maximum estimated context tokens')
         .option('-m, --mode <mode>', 'search mode: fts, semantic or hybrid')
+        .option('--strategy <strategy>', 'context strategy: rag, cag or auto')
         .option('--json', 'print machine-readable JSON')
         .description('build a compact context package for an agent')
         .action(async (query, options) => {
         const resolved = await resolveOptions(options);
         const mode = sanitizeSearchMode(options.mode, resolved.defaults.defaultSearchMode);
-        const contextPackage = await buildContextPackage(resolved.vault, query, parsePositiveInteger(options.limit ?? String(resolved.defaults.defaultSearchLimit), resolved.defaults.defaultSearchLimit), parsePositiveInteger(options.tokens ?? String(resolved.defaults.defaultContextTokens), resolved.defaults.defaultContextTokens), resolved.agent, mode);
+        const strategy = sanitizeContextStrategy(options.strategy, resolved.defaults.defaultContextStrategy);
+        const contextPackage = await buildContextPackage(resolved.vault, query, parsePositiveInteger(options.limit ?? String(resolved.defaults.defaultSearchLimit), resolved.defaults.defaultSearchLimit), parsePositiveInteger(options.tokens ?? String(resolved.defaults.defaultContextTokens), resolved.defaults.defaultContextTokens), resolved.agent, mode, strategy, resolved.defaults.defaultContextCacheTtlMs);
         print(options.json, contextPackage, () => contextPackage.content);
     });
+    program
+        .command('context-packs')
+        .option('-v, --vault <vault>', 'vault directory')
+        .option('-a, --agent <agent>', 'accepted for consistency; context packs are already keyed by agent')
+        .option('--stale', 'operate only on packs stale for the current index and volatile-memory signature')
+        .option('--clear', 'remove context packs instead of listing them')
+        .option('--json', 'print machine-readable JSON')
+        .description('list or clear persisted CAG context packs')
+        .action(async (options) => {
+        const resolved = await resolveOptions(options);
+        const dataSignature = await readContextDataSignature(resolved.vault);
+        if (options.clear) {
+            const result = await clearContextPacks(resolved.vault, {
+                staleOnly: options.stale === true,
+                dataSignature
+            });
+            print(options.json, { vault: resolved.vault, dataSignature, ...result }, () => [
+                `Removed context packs: ${result.removed.length}`,
+                `Kept context packs: ${result.kept.length}`
+            ].join('\n'));
+            return;
+        }
+        const packs = await listContextPacks(resolved.vault, dataSignature);
+        const visiblePacks = options.stale ? packs.filter((pack) => pack.stale) : packs;
+        print(options.json, { vault: resolved.vault, dataSignature, packs: visiblePacks }, () => visiblePacks.length === 0
+            ? 'No context packs found.'
+            : visiblePacks
+                .map((pack) => [
+                `${pack.filename} ${pack.stale ? 'stale' : 'fresh'} ${pack.sizeBytes} bytes`,
+                pack.key ? `query="${pack.key.query}" agent=${pack.key.agentId ?? '*'} mode=${pack.key.mode ?? 'default'} limit=${pack.key.limit} tokens=${pack.key.maxTokens}` : 'unreadable pack'
+            ].join('\n'))
+                .join('\n\n'));
+    });
     program
         .command('graph')
         .option('-v, --vault <vault>', 'vault directory')

package/dist/cli/commands/vault-commands.js

@@ -0,0 +1,182 @@
+import { readdir, readFile, rm, stat } from 'node:fs/promises';
+import { extname, isAbsolute, join } from 'node:path';
+import { doctorVault } from '../../application/analyze-vault.js';
+import { defaultBrainlinkConfig, loadBrainlinkConfig, loadRawConfig, writeRawConfig } from '../../infrastructure/config.js';
+import { assertVaultAllowed, isBucketVaultPath, resolveVaultPath } from '../../infrastructure/file-system-vault.js';
+import { print } from '../runtime.js';
+const excludedDirectories = new Set(['.git', 'node_modules', 'dist']);
+const resolveScope = (globalOption) => globalOption ? 'global' : 'local';
+const normalizeVaultPath = (vault) => assertVaultAllowed(vault, []);
+const uniqueValues = (values) => Array.from(new Set(values));
+const sameVault = (left, right) => normalizeVaultPath(left) === normalizeVaultPath(right);
+const isDirectory = async (path) => {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+const countMarkdownFiles = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const counts = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return excludedDirectories.has(entry.name) ? 0 : countMarkdownFiles(absolutePath);
+        }
+        return entry.isFile() && extname(entry.name).toLowerCase() === '.md' ? 1 : 0;
+    }));
+    return counts.reduce((total, count) => total + count, 0);
+};
+const readIndexedDocumentCount = async (vaultPath) => {
+    try {
+        const raw = await readFile(join(vaultPath, '.brainlink', 'index.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.documents) ? parsed.documents.length : null;
+    }
+    catch {
+        return null;
+    }
+};
+const addCandidate = (state, path, source) => {
+    const normalized = normalizeVaultPath(path);
+    const current = state.get(normalized);
+    return new Map(state).set(normalized, {
+        path: normalized,
+        sources: uniqueValues([...(current?.sources ?? []), source])
+    });
+};
+const listVaultEntries = async () => {
+    const config = await loadBrainlinkConfig();
+    const candidates = [config.vault, ...config.allowedVaults, defaultBrainlinkConfig.vault].reduce((state, path, index) => addCandidate(state, path, index === 0 ? 'configured' : path === defaultBrainlinkConfig.vault ? 'default' : 'allowed'), new Map());
+    const entries = await Promise.all(Array.from(candidates.values()).map(async (candidate) => {
+        if (isBucketVaultPath(candidate.path)) {
+            return {
+                path: candidate.path,
+                sources: candidate.sources,
+                current: sameVault(candidate.path, config.vault),
+                kind: 'bucket',
+                exists: null,
+                markdownCount: null,
+                indexedDocumentCount: null
+            };
+        }
+        const path = resolveVaultPath(candidate.path);
+        const exists = await isDirectory(path);
+        return {
+            path,
+            sources: candidate.sources,
+            current: sameVault(path, config.vault),
+            kind: 'local',
+            exists,
+            markdownCount: exists ? await countMarkdownFiles(path) : null,
+            indexedDocumentCount: exists ? await readIndexedDocumentCount(path) : null
+        };
+    }));
+    return entries.sort((left, right) => Number(right.current) - Number(left.current) || left.path.localeCompare(right.path));
+};
+const removeVaultFromAllowedVaults = async (vaultPath) => {
+    const scopes = ['local', 'global'];
+    await Promise.all(scopes.map(async (scope) => {
+        const rawConfig = await loadRawConfig(scope);
+        const allowedVaults = Array.isArray(rawConfig.allowedVaults)
+            ? rawConfig.allowedVaults.filter((path) => typeof path === 'string')
+            : [];
+        const nextAllowedVaults = allowedVaults.filter((path) => !sameVault(path, vaultPath));
+        if (nextAllowedVaults.length === allowedVaults.length) {
+            return;
+        }
+        await writeRawConfig(scope, {
+            ...rawConfig,
+            allowedVaults: nextAllowedVaults
+        });
+    }));
+};
+export const registerVaultCommands = (program) => {
+    const vaultsCommand = program.command('vaults').description('list, choose and delete Brainlink vaults');
+    vaultsCommand
+        .command('list')
+        .option('--json', 'print machine-readable JSON')
+        .description('list known Brainlink vaults from config and defaults')
+        .action(async (options) => {
+        const config = await loadBrainlinkConfig();
+        const vaults = await listVaultEntries();
+        print(options.json, {
+            currentVault: config.vault,
+            vaults
+        }, () => vaults
+            .map((vault) => {
+            const status = vault.exists === null ? 'remote' : vault.exists ? 'exists' : 'missing';
+            const counts = vault.markdownCount === null
+                ? ''
+                : ` markdown=${vault.markdownCount} indexed=${vault.indexedDocumentCount ?? 'unknown'}`;
+            return `${vault.current ? '* ' : '  '}${vault.path} [${vault.sources.join(',')}; ${status}; ${vault.kind}]${counts}`;
+        })
+            .join('\n'));
+    });
+    vaultsCommand
+        .command('use <vault>')
+        .option('--global', 'write to global config in $BRAINLINK_HOME/brainlink.config.json')
+        .option('--no-allowlist', 'do not append the vault to allowedVaults in the target config file')
+        .option('--json', 'print machine-readable JSON')
+        .description('choose the default Brainlink vault without migrating memory')
+        .action(async (vault, options) => {
+        const scope = resolveScope(options.global);
+        const before = await loadBrainlinkConfig();
+        const targetVault = normalizeVaultPath(vault);
+        const rawConfig = await loadRawConfig(scope);
+        const shouldAllowlist = options.allowlist !== false;
+        const allowedVaults = Array.isArray(rawConfig.allowedVaults)
+            ? rawConfig.allowedVaults.filter((path) => typeof path === 'string')
+            : [];
+        const nextAllowedVaults = shouldAllowlist ? uniqueValues([...allowedVaults, targetVault]) : allowedVaults;
+        const configPath = await writeRawConfig(scope, {
+            ...rawConfig,
+            vault: targetVault,
+            allowedVaults: nextAllowedVaults
+        });
+        const doctor = await doctorVault(targetVault);
+        print(options.json, {
+            scope,
+            configPath,
+            previousVault: before.vault,
+            vault: targetVault,
+            doctor
+        }, () => `Default ${scope} vault set to ${targetVault} in ${configPath}.`);
+    });
+    vaultsCommand
+        .command('delete <vault>')
+        .option('--yes', 'confirm destructive vault deletion')
+        .option('--prune-config', 'remove the vault from allowedVaults after deletion')
+        .option('--json', 'print machine-readable JSON')
+        .description('delete a local filesystem vault after explicit confirmation')
+        .action(async (vault, options) => {
+        const config = await loadBrainlinkConfig();
+        const targetVault = normalizeVaultPath(vault);
+        if (isBucketVaultPath(targetVault)) {
+            throw new Error('Refusing to delete bucket vaults from the CLI. Remove bucket data with your storage provider tooling.');
+        }
+        const absoluteVault = resolveVaultPath(targetVault);
+        if (!isAbsolute(absoluteVault)) {
+            throw new Error(`Refusing to delete non-absolute vault path: ${absoluteVault}`);
+        }
+        if (sameVault(absoluteVault, config.vault)) {
+            throw new Error('Refusing to delete the current default vault. Choose another default with `blink vaults use <vault>` first.');
+        }
+        if (options.yes !== true) {
+            throw new Error('Refusing to delete vault without --yes.');
+        }
+        const existed = await isDirectory(absoluteVault);
+        if (existed) {
+            await rm(absoluteVault, { recursive: true, force: false });
+        }
+        if (options.pruneConfig) {
+            await removeVaultFromAllowedVaults(absoluteVault);
+        }
+        print(options.json, {
+            vault: absoluteVault,
+            deleted: existed,
+            prunedConfig: options.pruneConfig === true
+        }, () => `${existed ? 'Deleted' : 'Vault did not exist'}: ${absoluteVault}`);
+    });
+};