@andespindola/brainlink 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/application/migrate-vault.js

@@ -0,0 +1,91 @@
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, extname, isAbsolute, join, relative } from 'node:path';
+import { ensureVault, isBucketVaultPath, listVaultFiles, resolveVaultPath, writeMarkdownFile } from '../infrastructure/file-system-vault.js';
+const directoryMode = 0o700;
+const fileMode = 0o600;
+const isMarkdownPath = (path) => extname(path).toLowerCase() === '.md';
+const timestamp = () => new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, 'Z');
+const isPathInside = (parent, child) => {
+    const path = relative(parent, child);
+    return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+};
+const conflictPath = (targetPath) => {
+    const extension = extname(targetPath);
+    const base = extension ? targetPath.slice(0, -extension.length) : targetPath;
+    return `${base}.conflict-${timestamp()}${extension}`;
+};
+const writePreservedFile = async (absolutePath, content) => {
+    await mkdir(dirname(absolutePath), { recursive: true, mode: directoryMode });
+    await writeFile(absolutePath, content, { mode: fileMode });
+    await chmod(absolutePath, fileMode);
+};
+const writeMigratedFile = async (targetVault, targetRoot, absolutePath, content) => {
+    if (isBucketVaultPath(targetVault)) {
+        await writeMarkdownFile(targetVault, relative(targetRoot, absolutePath), content.toString('utf8'));
+        return;
+    }
+    await writePreservedFile(absolutePath, content);
+};
+export const planVaultMigration = async (source, target) => {
+    const sourceFiles = (await listVaultFiles(source)).filter(isMarkdownPath);
+    return sourceFiles.reduce(async (statePromise, sourceFile) => {
+        const state = await statePromise;
+        const targetFile = join(target, relative(source, sourceFile));
+        if (!isPathInside(target, targetFile)) {
+            return state;
+        }
+        const sourceContent = await readFile(sourceFile);
+        try {
+            const targetContent = await readFile(targetFile);
+            if (sourceContent.equals(targetContent)) {
+                return [...state, { kind: 'unchanged', sourcePath: sourceFile, targetPath: targetFile, sourceContent }];
+            }
+            return [...state, { kind: 'conflict', sourcePath: sourceFile, targetPath: conflictPath(targetFile), sourceContent }];
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+                throw error;
+            }
+            return [...state, { kind: 'copy', sourcePath: sourceFile, targetPath: targetFile, sourceContent }];
+        }
+    }, Promise.resolve([]));
+};
+export const previewVaultMigration = async (sourceVault, targetVault) => {
+    const source = await ensureVault(sourceVault);
+    const target = await ensureVault(targetVault);
+    if (source === target) {
+        return { source, target, copied: 0, unchanged: 0, conflicted: 0 };
+    }
+    const actions = await planVaultMigration(source, target);
+    const copied = actions.filter((action) => action.kind === 'copy').length;
+    const unchanged = actions.filter((action) => action.kind === 'unchanged').length;
+    const conflicted = actions.filter((action) => action.kind === 'conflict').length;
+    return { source, target, copied, unchanged, conflicted };
+};
+export const migrateVaultContent = async (sourceVault, targetVault) => {
+    const source = await ensureVault(sourceVault);
+    const target = await ensureVault(targetVault);
+    if (source === target) {
+        return { source, target, copied: 0, unchanged: 0, conflicted: 0 };
+    }
+    const actions = await planVaultMigration(source, target);
+    for (const action of actions) {
+        if (action.kind === 'unchanged') {
+            continue;
+        }
+        await writeMigratedFile(targetVault, target, action.targetPath, action.sourceContent);
+    }
+    const copied = actions.filter((action) => action.kind === 'copy').length;
+    const unchanged = actions.filter((action) => action.kind === 'unchanged').length;
+    const conflicted = actions.filter((action) => action.kind === 'conflict').length;
+    return { source, target, copied, unchanged, conflicted };
+};
+export const shouldMigrateDefaultVault = async (sourceVault, targetVault) => {
+    const source = resolveVaultPath(sourceVault);
+    const target = resolveVaultPath(targetVault);
+    if (source === target) {
+        return false;
+    }
+    const [sourceFiles, targetFiles] = await Promise.all([listVaultFiles(source), listVaultFiles(target)]);
+    return sourceFiles.filter(isMarkdownPath).length > 0 && targetFiles.filter(isMarkdownPath).length === 0;
+};

package/dist/application/search-graph-node-ids.js

@@ -0,0 +1,12 @@
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
+export const searchGraphNodeIds = async (vaultPath, query, limit, agentId) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const index = openFileIndex(absoluteVaultPath);
+    try {
+        return await index.searchGraphNodeIds(query, limit, agentId);
+    }
+    finally {
+        index.close();
+    }
+};

package/dist/application/search-knowledge.js

@@ -1,19 +1,89 @@
+import { stat } from 'node:fs/promises';
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { ensurePrivatePacksFromLegacyIndex, searchInPacks } from '../infrastructure/search-packs.js';
+import { indexStoragePath, openFileIndex } from '../infrastructure/file-index.js';
 import { createEmbeddingProvider } from '../domain/embeddings.js';
 import { loadBrainlinkConfig, sanitizeSearchMode } from '../infrastructure/config.js';
+const hybridCacheTtlMs = 30_000;
+const hybridCacheMaxEntries = 200;
+const hybridSearchCache = new Map();
+const readIndexMtimeMs = async (vaultPath) => {
+    try {
+        return (await stat(indexStoragePath(vaultPath))).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+};
+const toCacheKey = (vaultPath, query, limit, agentId) => JSON.stringify({
+    vaultPath,
+    query: query.trim().toLowerCase(),
+    limit,
+    agentId: agentId?.trim().toLowerCase() ?? '*'
+});
+const cacheGet = (key, indexMtimeMs) => {
+    const entry = hybridSearchCache.get(key);
+    if (!entry) {
+        return undefined;
+    }
+    const fresh = Date.now() - entry.createdAt <= hybridCacheTtlMs && entry.indexMtimeMs === indexMtimeMs;
+    if (!fresh) {
+        hybridSearchCache.delete(key);
+        return undefined;
+    }
+    return entry.results;
+};
+const cacheSet = (entry) => {
+    hybridSearchCache.set(entry.key, entry);
+    if (hybridSearchCache.size <= hybridCacheMaxEntries) {
+        return;
+    }
+    const overflow = hybridSearchCache.size - hybridCacheMaxEntries;
+    const keys = Array.from(hybridSearchCache.keys()).slice(0, overflow);
+    keys.forEach((key) => hybridSearchCache.delete(key));
+};
 export const searchKnowledge = async (vaultPath, query, limit, agentId, mode) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
     const config = await loadBrainlinkConfig();
     const searchMode = sanitizeSearchMode(mode, config.defaultSearchMode);
+    await ensurePrivatePacksFromLegacyIndex(absoluteVaultPath);
+    const cacheKey = searchMode === 'hybrid' ? toCacheKey(absoluteVaultPath, query, limit, agentId) : undefined;
+    const indexMtimeMs = cacheKey ? await readIndexMtimeMs(absoluteVaultPath) : 0;
+    const cached = cacheKey ? cacheGet(cacheKey, indexMtimeMs) : undefined;
+    if (cached) {
+        return cached;
+    }
     const provider = createEmbeddingProvider(config.embeddingProvider);
     const shouldEmbedQuery = searchMode !== 'fts' && provider.name !== 'none';
     const queryEmbedding = shouldEmbedQuery ? (await provider.embed([query]))[0] ?? [] : [];
-    const index = openSqliteIndex(absoluteVaultPath);
     try {
-        return index.search(query, limit, agentId, searchMode, queryEmbedding);
+        const index = openFileIndex(absoluteVaultPath);
+        try {
+            const results = await index.search(query, limit, agentId, searchMode, queryEmbedding);
+            if (cacheKey) {
+                cacheSet({
+                    key: cacheKey,
+                    createdAt: Date.now(),
+                    indexMtimeMs,
+                    results
+                });
+            }
+            return results;
+        }
+        finally {
+            index.close();
+        }
     }
-    finally {
-        index.close();
+    catch {
+        const fallbackResults = await searchInPacks(absoluteVaultPath, query, limit, agentId);
+        if (cacheKey) {
+            cacheSet({
+                key: cacheKey,
+                createdAt: Date.now(),
+                indexMtimeMs,
+                results: fallbackResults
+            });
+        }
+        return fallbackResults;
     }
 };

package/dist/application/server/routes.js

@@ -1,9 +1,11 @@
 import { getBrokenLinksReport, getOrphansReport, getStats, validateVault } from '../analyze-vault.js';
 import { buildContextPackage } from '../build-context.js';
 import { getGraph } from '../get-graph.js';
+import { getGraphNode } from '../get-graph-node.js';
 import { getGraphLayout } from '../get-graph-layout.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 { createClientCss } from '../frontend/client-css.js';
@@ -49,6 +51,10 @@ const sameEntityTag = (candidate, signature) => {
     return decodeEntityTag(candidate) === signature;
 };
 const readAgentQuery = (url) => url.searchParams.get('agent') ?? undefined;
+const stripLayoutContent = (layout) => ({
+    ...layout,
+    nodes: layout.nodes.map(({ content, ...node }) => node)
+});
 export const route = async (request, url, vaultPath) => {
     if (isReadMethod(request) && (url.pathname === '/' || url.pathname === '/index.html')) {
         return createResponse(createClientHtml(), 200, contentTypes['.html']);
@@ -67,7 +73,7 @@ export const route = async (request, url, vaultPath) => {
         const requestEtags = request.headers['if-none-match'];
         const notModified = sameEntityTag(requestEtags, signature);
         const etag = encodeEntityTag(signature);
-        const body = createJsonResponse({ signature, layout });
+        const body = createJsonResponse({ signature, layout: stripLayoutContent(layout) });
         const jsonResponse = createResponse(body, 200, contentTypes['.json']);
         const notModifiedResponse = createResponse('', 304, contentTypes['.json']);
         if (notModified) {
@@ -87,6 +93,26 @@ export const route = async (request, url, vaultPath) => {
             }
         };
     }
+    if (isReadMethod(request) && url.pathname === '/api/graph-node') {
+        const id = url.searchParams.get('id')?.trim() ?? '';
+        if (!id) {
+            return createResponse(createJsonResponse({ error: 'Missing id query parameter' }), 400, contentTypes['.json']);
+        }
+        const node = await getGraphNode(vaultPath, id, readAgentQuery(url));
+        if (!node) {
+            return createResponse(createJsonResponse({ error: 'Node not found' }), 404, contentTypes['.json']);
+        }
+        return createResponse(createJsonResponse({ node }), 200, contentTypes['.json']);
+    }
+    if (isReadMethod(request) && url.pathname === '/api/graph-filter') {
+        const query = url.searchParams.get('q')?.trim() ?? '';
+        const limit = parsePositiveInteger(url.searchParams.get('limit'), 1200);
+        if (!query) {
+            return createResponse(createJsonResponse({ query, nodeIds: [] }), 200, contentTypes['.json']);
+        }
+        const nodeIds = await searchGraphNodeIds(vaultPath, query, limit, readAgentQuery(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']);
     }

package/dist/benchmarks/large-vault.js

@@ -21,7 +21,7 @@ const readOptions = (args) => ({
 });
 const topics = [
     'authentication jwt token refresh policy',
-    'sqlite graph backlinks markdown vault indexing',
+    'graph backlinks markdown vault indexing',
     'frontend canvas layout graph interaction',
     'agent memory context retrieval summarization',
     'security local server vault path allowlist',

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

@@ -0,0 +1,412 @@
+import { access, lstat, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { loadBrainlinkConfig } from '../../infrastructure/config.js';
+import { getBootstrapPolicy, getBootstrapSessionStatus, getContextSessionStatus, getSessionStatePath, setBootstrapPolicy } from '../../infrastructure/session-state.js';
+import { print } from '../runtime.js';
+const getCodexConfigPath = () => join(homedir(), '.codex', 'config.toml');
+const getMarketplacePath = () => join(homedir(), '.agents', 'plugins', 'marketplace.json');
+const getDefaultPluginSourcePath = () => resolve(process.cwd(), 'plugins', 'brainlink');
+const getPluginSymlinkPath = () => join(homedir(), 'plugins', 'brainlink');
+const execFileAsync = promisify(execFile);
+const toTomlValue = (value) => `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+const removeBrainlinkMcpSection = (content) => {
+    const lines = content.split('\n');
+    const output = [];
+    let skip = false;
+    for (const line of lines) {
+        const sectionMatch = line.match(/^\[(.+)\]\s*$/);
+        if (!skip && sectionMatch?.[1] === 'mcp_servers.brainlink') {
+            skip = true;
+            continue;
+        }
+        if (skip && sectionMatch) {
+            skip = false;
+        }
+        if (!skip) {
+            output.push(line);
+        }
+    }
+    return output.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+};
+const buildBrainlinkMcpSection = (options) => {
+    const envEntries = [];
+    if (options.allowedVaults) {
+        envEntries.push(`BRAINLINK_ALLOWED_VAULTS = ${toTomlValue(options.allowedVaults)}`);
+    }
+    if (options.brainlinkHome) {
+        envEntries.push(`BRAINLINK_HOME = ${toTomlValue(options.brainlinkHome)}`);
+    }
+    return [
+        '[mcp_servers.brainlink]',
+        `command = ${toTomlValue('brainlink-mcp')}`,
+        ...(envEntries.length > 0 ? [`env = { ${envEntries.join(', ')} }`] : [])
+    ].join('\n');
+};
+const upsertCodexMcpConfig = async (configPath, options) => {
+    let existing = '';
+    try {
+        existing = await readFile(configPath, 'utf8');
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const withoutSection = removeBrainlinkMcpSection(existing);
+    const section = buildBrainlinkMcpSection(options);
+    const merged = `${withoutSection}\n\n${section}\n`.replace(/^\n+/, '');
+    await mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
+    await writeFile(configPath, merged, { encoding: 'utf8', mode: 0o600 });
+};
+const ensurePluginSymlink = async (sourcePath, symlinkPath) => {
+    await access(sourcePath);
+    await mkdir(dirname(symlinkPath), { recursive: true, mode: 0o700 });
+    try {
+        const info = await lstat(symlinkPath);
+        if (info.isSymbolicLink()) {
+            await rm(symlinkPath, { force: true });
+        }
+        else {
+            await rm(symlinkPath, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await symlink(sourcePath, symlinkPath);
+};
+const loadMarketplace = async (path) => {
+    try {
+        const content = await readFile(path, 'utf8');
+        const parsed = JSON.parse(content);
+        const plugins = Array.isArray(parsed.plugins) ? parsed.plugins : [];
+        return {
+            name: typeof parsed.name === 'string' ? parsed.name : 'local',
+            interface: {
+                displayName: typeof parsed.interface?.displayName === 'string' ? parsed.interface.displayName : 'Local'
+            },
+            plugins: plugins
+        };
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+        return {
+            name: 'local',
+            interface: {
+                displayName: 'Local'
+            },
+            plugins: []
+        };
+    }
+};
+const upsertMarketplacePlugin = async (marketplacePath) => {
+    const marketplace = await loadMarketplace(marketplacePath);
+    const pluginEntry = {
+        name: 'brainlink',
+        source: {
+            source: 'local',
+            path: './plugins/brainlink'
+        },
+        policy: {
+            installation: 'AVAILABLE',
+            authentication: 'ON_INSTALL'
+        },
+        category: 'Productivity'
+    };
+    const plugins = marketplace.plugins.filter((plugin) => plugin?.name !== 'brainlink');
+    const next = {
+        ...marketplace,
+        plugins: [...plugins, pluginEntry]
+    };
+    await mkdir(dirname(marketplacePath), { recursive: true, mode: 0o700 });
+    await writeFile(marketplacePath, `${JSON.stringify(next, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+};
+const parseAllowedVaults = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return normalized.length > 0 ? normalized.join(',') : undefined;
+};
+export const installAgentIntegration = async (input) => {
+    const codexConfigPath = getCodexConfigPath();
+    const allowedVaults = parseAllowedVaults(input.allowedVaults);
+    await upsertCodexMcpConfig(codexConfigPath, {
+        allowedVaults,
+        brainlinkHome: input.brainlinkHome
+    });
+    const warnings = [];
+    const pluginSourcePath = input.pluginPath ? resolve(input.pluginPath) : getDefaultPluginSourcePath();
+    const pluginSymlinkPath = getPluginSymlinkPath();
+    const marketplacePath = getMarketplacePath();
+    if (input.mcpOnly !== true) {
+        try {
+            await ensurePluginSymlink(pluginSourcePath, pluginSymlinkPath);
+            await upsertMarketplacePlugin(marketplacePath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Plugin marketplace setup skipped: ${message}. MCP is configured, but install repository plugin files to enable local gallery auto-discovery.`);
+        }
+    }
+    const selfTestResult = input.selfTest
+        ? await (async () => {
+            const codexConfig = await readFile(codexConfigPath, 'utf8');
+            const mcp = isBrainlinkConfigured(codexConfig);
+            const mcpCommandInPath = await hasMcpCommandInPath();
+            const pluginSymlinkExists = input.mcpOnly === true
+                ? null
+                : await (async () => {
+                    try {
+                        return (await lstat(pluginSymlinkPath)).isSymbolicLink();
+                    }
+                    catch {
+                        return false;
+                    }
+                })();
+            const marketplaceEntryExists = input.mcpOnly === true
+                ? null
+                : (await loadMarketplace(marketplacePath)).plugins.some((plugin) => plugin?.name === 'brainlink');
+            return {
+                ok: mcp.hasMcpSection &&
+                    mcp.hasCommand &&
+                    mcpCommandInPath &&
+                    (input.mcpOnly === true || (Boolean(pluginSymlinkExists) && Boolean(marketplaceEntryExists))),
+                mcpCommandInPath,
+                hasMcpSection: mcp.hasMcpSection,
+                hasCommand: mcp.hasCommand,
+                pluginSymlinkExists,
+                marketplaceEntryExists
+            };
+        })()
+        : undefined;
+    return {
+        installed: true,
+        codexConfigPath,
+        mcpServer: 'brainlink',
+        command: 'brainlink-mcp',
+        ...(input.mcpOnly !== true ? { pluginSourcePath, pluginSymlinkPath, marketplacePath } : {}),
+        ...(selfTestResult ? { selfTest: selfTestResult } : {}),
+        ...(warnings.length > 0 ? { warnings } : {})
+    };
+};
+const hasMcpCommandInPath = async () => {
+    try {
+        const { stdout } = await execFileAsync('sh', ['-lc', 'command -v brainlink-mcp'], { maxBuffer: 1024 * 1024 });
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+};
+const isBrainlinkConfigured = (codexConfig) => {
+    const hasMcpSection = codexConfig.includes('[mcp_servers.brainlink]');
+    const hasCommand = /(^|\n)\s*command\s*=\s*"brainlink-mcp"\s*(\n|$)/m.test(codexConfig);
+    return { hasMcpSection, hasCommand };
+};
+const parseBooleanOption = (value, name) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    throw new Error(`Invalid value for ${name}: ${value}. Use true or false.`);
+};
+const parsePositiveIntegerOption = (value, name) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid value for ${name}: ${value}. Use a positive integer.`);
+    }
+    return parsed;
+};
+const applyPolicyPreset = (preset) => {
+    if (!preset) {
+        return {};
+    }
+    if (preset === 'fully-auto') {
+        return {
+            enforceBootstrap: true,
+            enforceContextFirst: true,
+            autoBootstrapOnRead: true,
+            autoBootstrapOnStartup: true
+        };
+    }
+    if (preset === 'strict') {
+        return {
+            enforceBootstrap: true,
+            enforceContextFirst: true,
+            autoBootstrapOnRead: false,
+            autoBootstrapOnStartup: false
+        };
+    }
+    throw new Error(`Unknown policy preset: ${preset}. Use "fully-auto" or "strict".`);
+};
+export const registerAgentCommands = (program) => {
+    const agent = program.command('agent').description('install or inspect Brainlink agent integration');
+    agent
+        .command('install')
+        .option('--mcp-only', 'only configure MCP server in Codex config')
+        .option('--plugin-path <path>', 'custom source path for Brainlink plugin files')
+        .option('--allowed-vaults <paths>', 'comma separated vault allowlist to inject in MCP env')
+        .option('--brainlink-home <path>', 'BRAINLINK_HOME value to inject in MCP env')
+        .option('--self-test', 'run post-install checks and include diagnostics in the result')
+        .option('--json', 'print machine-readable JSON')
+        .description('install Brainlink as default MCP memory integration for the local agent')
+        .action(async (options) => {
+        const result = await installAgentIntegration({
+            mcpOnly: options.mcpOnly,
+            pluginPath: options.pluginPath,
+            allowedVaults: options.allowedVaults,
+            brainlinkHome: options.brainlinkHome,
+            selfTest: options.selfTest
+        });
+        print(options.json, result, () => [
+            `Installed Brainlink MCP at ${result.codexConfigPath}`,
+            ...(options.mcpOnly === true ? [] : [`Plugin symlink: ${result.pluginSymlinkPath}`, `Marketplace: ${result.marketplacePath}`]),
+            ...(result.selfTest ? [`Self-test: ${result.selfTest.ok ? 'ok' : 'failed'}`] : []),
+            ...(result.warnings && result.warnings.length > 0 ? ['Warnings:', ...result.warnings.map((warning) => `- ${warning}`)] : [])
+        ].join('\n'));
+    });
+    agent
+        .command('upgrade')
+        .option('--mcp-only', 'only configure MCP server in Codex config')
+        .option('--plugin-path <path>', 'custom source path for Brainlink plugin files')
+        .option('--allowed-vaults <paths>', 'comma separated vault allowlist to inject in MCP env')
+        .option('--brainlink-home <path>', 'BRAINLINK_HOME value to inject in MCP env')
+        .option('--json', 'print machine-readable JSON')
+        .description('reapply latest Brainlink agent integration defaults for legacy installs')
+        .action(async (options) => {
+        const result = await installAgentIntegration({
+            mcpOnly: options.mcpOnly,
+            pluginPath: options.pluginPath,
+            allowedVaults: options.allowedVaults,
+            brainlinkHome: options.brainlinkHome,
+            selfTest: true
+        });
+        print(options.json, {
+            upgraded: true,
+            ...result
+        }, () => `Upgraded Brainlink agent integration at ${result.codexConfigPath}. Self-test: ${result.selfTest?.ok ? 'ok' : 'failed'}`);
+    });
+    agent
+        .command('policy')
+        .option('--preset <preset>', 'policy preset: fully-auto or strict')
+        .option('--enforce-bootstrap <true|false>', 'override enforceBootstrap')
+        .option('--enforce-context-first <true|false>', 'override enforceContextFirst')
+        .option('--auto-bootstrap-on-read <true|false>', 'override autoBootstrapOnRead')
+        .option('--auto-bootstrap-on-startup <true|false>', 'override autoBootstrapOnStartup')
+        .option('--stale-after-minutes <minutes>', 'override staleAfterMinutes with positive integer')
+        .option('--json', 'print machine-readable JSON')
+        .description('read or update Brainlink MCP bootstrap policy')
+        .action(async (options) => {
+        const presetPatch = applyPolicyPreset(options.preset);
+        const enforceBootstrap = parseBooleanOption(options.enforceBootstrap, '--enforce-bootstrap');
+        const enforceContextFirst = parseBooleanOption(options.enforceContextFirst, '--enforce-context-first');
+        const autoBootstrapOnRead = parseBooleanOption(options.autoBootstrapOnRead, '--auto-bootstrap-on-read');
+        const autoBootstrapOnStartup = parseBooleanOption(options.autoBootstrapOnStartup, '--auto-bootstrap-on-startup');
+        const staleAfterMinutes = parsePositiveIntegerOption(options.staleAfterMinutes, '--stale-after-minutes');
+        const overridePatch = {
+            ...(enforceBootstrap !== undefined ? { enforceBootstrap } : {}),
+            ...(enforceContextFirst !== undefined ? { enforceContextFirst } : {}),
+            ...(autoBootstrapOnRead !== undefined ? { autoBootstrapOnRead } : {}),
+            ...(autoBootstrapOnStartup !== undefined ? { autoBootstrapOnStartup } : {}),
+            ...(staleAfterMinutes !== undefined ? { staleAfterMinutes } : {})
+        };
+        const patch = {
+            ...presetPatch,
+            ...overridePatch
+        };
+        const policy = Object.keys(patch).length === 0 ? await getBootstrapPolicy() : await setBootstrapPolicy(patch);
+        print(options.json, {
+            policy,
+            ...(options.preset ? { presetApplied: options.preset } : {})
+        }, () => [
+            ...(options.preset ? [`presetApplied=${options.preset}`] : []),
+            `enforceBootstrap=${policy.enforceBootstrap}`,
+            `enforceContextFirst=${policy.enforceContextFirst}`,
+            `autoBootstrapOnRead=${policy.autoBootstrapOnRead}`,
+            `autoBootstrapOnStartup=${policy.autoBootstrapOnStartup}`,
+            `staleAfterMinutes=${policy.staleAfterMinutes}`
+        ].join('\n'));
+    });
+    agent
+        .command('status')
+        .option('-a, --agent <agent>', 'agent memory namespace for bootstrap session status')
+        .option('--json', 'print machine-readable JSON')
+        .description('check if Brainlink MCP integration is configured for the local agent')
+        .action(async (options) => {
+        const codexConfigPath = getCodexConfigPath();
+        let codexConfig = '';
+        try {
+            codexConfig = await readFile(codexConfigPath, 'utf8');
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        const { hasMcpSection, hasCommand } = isBrainlinkConfigured(codexConfig);
+        const pluginSymlinkPath = getPluginSymlinkPath();
+        const marketplacePath = getMarketplacePath();
+        let pluginSymlinkExists = false;
+        let marketplaceEntryExists = false;
+        try {
+            pluginSymlinkExists = (await lstat(pluginSymlinkPath)).isSymbolicLink();
+        }
+        catch { }
+        try {
+            const marketplace = await loadMarketplace(marketplacePath);
+            marketplaceEntryExists = marketplace.plugins.some((plugin) => plugin?.name === 'brainlink');
+        }
+        catch { }
+        const config = await loadBrainlinkConfig();
+        const policy = await getBootstrapPolicy();
+        const bootstrapStatus = await getBootstrapSessionStatus(config.vault, options.agent ?? config.defaultAgent);
+        const contextStatus = await getContextSessionStatus(config.vault, options.agent ?? config.defaultAgent);
+        const sessionStatePath = getSessionStatePath();
+        print(options.json, {
+            configured: hasMcpSection && hasCommand,
+            codexConfigPath,
+            hasMcpSection,
+            hasCommand,
+            pluginSymlinkPath,
+            pluginSymlinkExists,
+            marketplacePath,
+            marketplaceEntryExists,
+            sessionStatePath,
+            vault: config.vault,
+            agent: options.agent ?? config.defaultAgent ?? '*',
+            bootstrapPolicy: policy,
+            bootstrapStatus,
+            contextStatus
+        }, () => [
+            `codexConfigPath=${codexConfigPath}`,
+            `configured=${hasMcpSection && hasCommand}`,
+            `pluginSymlinkExists=${pluginSymlinkExists}`,
+            `marketplaceEntryExists=${marketplaceEntryExists}`,
+            `vault=${config.vault}`,
+            `agent=${options.agent ?? config.defaultAgent ?? '*'}`,
+            `bootstrapReady=${bootstrapStatus.ready}`,
+            `bootstrapStale=${bootstrapStatus.stale}`,
+            `contextReady=${contextStatus.ready}`,
+            `contextStale=${contextStatus.stale}`
+        ].join('\n'));
+    });
+};