@andespindola/brainlink 1.0.5 → 1.0.6

package/dist/mcp/tools.js

@@ -1,1357 +1,3 @@
-import { readFile } from 'node:fs/promises';
-import { basename, extname, resolve } from 'node:path';
-import { z } from 'zod';
-import { getBrokenLinksReport, getOrphansReport, getStats, validateVault } from '../application/analyze-vault.js';
-import { addNoteWithMetadata } from '../application/add-note.js';
-import { buildContextPackage, readContextDataSignature } from '../application/build-context.js';
-import { canonicalizeContextLinks } from '../application/canonical-context-links.js';
-import { deleteNote } from '../application/delete-note.js';
-import { resolveDuplicateNotes, scanDuplicateNotes } from '../application/dedupe-notes.js';
-import { getGraph } from '../application/get-graph.js';
-import { getGraphContexts } from '../application/get-graph-contexts.js';
-import { addInboxItem, listInboxItems, processInboxItems } from '../application/inbox.js';
-import { indexVault } from '../application/index-vault.js';
-import { buildRememberSuggestion, explainSearchResults, suggestBrokenLinkFixes, suggestContextLinks } from '../application/memory-suggestions.js';
-import { buildActionableDoctor, closeSession, initializeProjectMemory } from '../application/operational-workflows.js';
-import { repairBrokenLinks } from '../application/repair-broken-links.js';
-import { searchKnowledge } from '../application/search-knowledge.js';
-import { resolveAgentRuntimeDefaults, sanitizeContextStrategy, sanitizeSearchMode } from '../infrastructure/config.js';
-import { clearContextPacks, listContextPacks } from '../infrastructure/context-packs.js';
-import { loadBrainlinkConfig } from '../infrastructure/config.js';
-import { assertVaultAllowed } from '../infrastructure/file-system-vault.js';
-import { addVolatileMemory, clearVolatileMemory } from '../infrastructure/volatile-memory.js';
-import { getBootstrapPolicy, getBootstrapSessionStatus, getContextSessionStatus, setBootstrapPolicy, touchBootstrapSession, touchContextSession } from '../infrastructure/session-state.js';
-import { getRuntimeMetadata } from './runtime.js';
-const positiveInteger = (fallback) => z
-    .number()
-    .int()
-    .positive()
-    .optional()
-    .transform((value) => value ?? fallback);
-const optionalPositiveInteger = () => z
-    .number()
-    .int()
-    .positive()
-    .optional();
-const vaultInput = {
-    vault: z.string().min(1).optional().describe('Vault directory. Omit to use the configured Brainlink default vault.')
-};
-const agentInput = {
-    agent: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Agent memory namespace. Omit to use Brainlink.config defaultAgent, otherwise read all agent namespaces.')
-};
-const searchModeInput = {
-    mode: z.enum(['fts', 'semantic', 'hybrid']).optional().describe('Search mode. Defaults to the Brainlink config value.')
-};
-const contextStrategyInput = {
-    strategy: z
-        .enum(['rag', 'cag', 'auto'])
-        .optional()
-        .describe('Context strategy per call. Use rag for fresh retrieval assembly, cag to reuse persisted context packs when fresh, or auto to choose CAG on fresh pack hits and RAG otherwise. Defaults to the Brainlink config value.')
-};
-const resolveExecutionContext = async (input) => {
-    const config = await loadBrainlinkConfig();
-    const vault = await assertVaultAllowed(input.vault ?? config.vault, config.allowedVaults);
-    const agent = input.agent ?? config.defaultAgent;
-    const defaults = resolveAgentRuntimeDefaults(config, agent);
-    return {
-        config,
-        vault,
-        agent,
-        defaults
-    };
-};
-const inferTitleFromPath = (filePath) => {
-    const extension = extname(filePath);
-    const fromFileName = basename(filePath, extension);
-    return fromFileName
-        .trim()
-        .replace(/[-_]+/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim();
-};
-const isTruthy = (value) => value !== false;
-const jsonResult = (value) => ({
-    content: [
-        {
-            type: 'text',
-            text: JSON.stringify(value, null, 2)
-        }
-    ],
-    structuredContent: value
-});
-const preflightResult = (value) => jsonResult({
-    preflightRequired: true,
-    ...value
-});
-const withNextActions = (value, nextActions) => ({
-    ...value,
-    nextActions
-});
-const ensureBootstrapReady = async (context, input, toolName) => {
-    const policy = await getBootstrapPolicy();
-    if (!policy.enforceBootstrap) {
-        return {
-            bootstrap: {
-                autoBootstrapped: false,
-                policy,
-                statusBefore: {
-                    ready: true,
-                    stale: false
-                },
-                reason: 'Bootstrap enforcement is disabled by policy.'
-            }
-        };
-    }
-    const status = await getBootstrapSessionStatus(context.vault, context.agent);
-    if (status.ready) {
-        return {
-            bootstrap: {
-                autoBootstrapped: false,
-                policy,
-                statusBefore: status,
-                reason: 'Bootstrap session is already fresh for this vault/agent.'
-            }
-        };
-    }
-    if (policy.autoBootstrapOnRead) {
-        const index = await indexVault(context.vault);
-        const session = await touchBootstrapSession(context.vault, context.agent);
-        const statusAfter = await getBootstrapSessionStatus(context.vault, context.agent);
-        return {
-            bootstrap: {
-                autoBootstrapped: true,
-                policy,
-                statusBefore: status,
-                statusAfter,
-                session,
-                index,
-                reason: 'Auto-bootstrap was applied for this read call because bootstrap was missing or stale.'
-            }
-        };
-    }
-    const mode = typeof input.mode === 'string' && ['fts', 'semantic', 'hybrid'].includes(input.mode) ? input.mode : 'hybrid';
-    const strategy = sanitizeContextStrategy(typeof input.strategy === 'string' ? input.strategy : undefined, 'rag');
-    const query = typeof input.query === 'string' && input.query.trim().length > 0 ? input.query : undefined;
-    const bootstrapArgs = {
-        vault: context.vault,
-        ...(context.agent ? { agent: context.agent } : {}),
-        ...(query ? { query } : {}),
-        mode,
-        strategy
-    };
-    const nextActions = [
-        {
-            tool: 'brainlink_bootstrap',
-            reason: 'Bootstrap is required before read tools so retrieval stays grounded in current vault state.',
-            args: bootstrapArgs
-        }
-    ];
-    return {
-        preflight: preflightResult(withNextActions({
-            vault: context.vault,
-            agent: context.agent,
-            blockedTool: toolName,
-            policy,
-            bootstrapStatus: status,
-            guidance: 'Run brainlink_bootstrap first for this vault/agent before using read tools. This keeps retrieval grounded and memory state consistent.',
-            bootstrapArgs
-        }, nextActions))
-    };
-};
-const ensureContextReady = async (context, input, toolName) => {
-    const policy = await getBootstrapPolicy();
-    if (!policy.enforceContextFirst) {
-        return {
-            context: {
-                policy,
-                statusBefore: {
-                    ready: true,
-                    stale: false
-                },
-                reason: 'Context-first enforcement is disabled by policy.'
-            }
-        };
-    }
-    const status = await getContextSessionStatus(context.vault, context.agent);
-    if (status.ready) {
-        return {
-            context: {
-                policy,
-                statusBefore: status,
-                reason: 'Context session is already fresh for this vault/agent.'
-            }
-        };
-    }
-    const queryFromInput = typeof input.query === 'string' && input.query.trim().length > 0
-        ? input.query
-        : typeof input.contextQuery === 'string' && input.contextQuery.trim().length > 0
-            ? input.contextQuery
-            : '<task>';
-    const mode = sanitizeSearchMode(typeof input.mode === 'string' ? input.mode : undefined, context.defaults.defaultSearchMode);
-    const strategy = sanitizeContextStrategy(typeof input.strategy === 'string' ? input.strategy : undefined, context.defaults.defaultContextStrategy);
-    const limit = typeof input.limit === 'number' && Number.isFinite(input.limit) && input.limit > 0
-        ? input.limit
-        : typeof input.contextLimit === 'number' && Number.isFinite(input.contextLimit) && input.contextLimit > 0
-            ? input.contextLimit
-            : context.defaults.defaultSearchLimit;
-    const tokens = typeof input.tokens === 'number' && Number.isFinite(input.tokens) && input.tokens > 0
-        ? input.tokens
-        : typeof input.contextTokens === 'number' && Number.isFinite(input.contextTokens) && input.contextTokens > 0
-            ? input.contextTokens
-            : context.defaults.defaultContextTokens;
-    const contextArgs = {
-        vault: context.vault,
-        ...(context.agent ? { agent: context.agent } : {}),
-        query: queryFromInput,
-        mode,
-        strategy,
-        limit,
-        tokens
-    };
-    const nextActions = [
-        {
-            tool: 'brainlink_context',
-            reason: 'Context must be loaded first so Brainlink is the primary retrieval source before other read tools.',
-            args: contextArgs
-        }
-    ];
-    return {
-        preflight: preflightResult(withNextActions({
-            vault: context.vault,
-            agent: context.agent,
-            blockedTool: toolName,
-            policy,
-            contextStatus: status,
-            guidance: 'Run brainlink_context first for this vault/agent before other read tools so answers are grounded on Brainlink context.',
-            contextArgs
-        }, nextActions))
-    };
-};
-export const contextInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    ...searchModeInput,
-    ...contextStrategyInput,
-    query: z.string().min(1).describe('Task or question to retrieve Brainlink context for.'),
-    limit: optionalPositiveInteger().describe('Maximum search results before context selection.'),
-    tokens: optionalPositiveInteger().describe('Maximum estimated context tokens.')
-};
-export const contextPacksInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    action: z.enum(['list', 'clear']).optional().default('list').describe('Action to perform on persisted CAG context packs.'),
-    staleOnly: z.boolean().optional().default(false).describe('When clearing, remove only packs stale for the current index and volatile-memory signature.')
-};
-export const searchInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    ...searchModeInput,
-    query: z.string().min(1).describe('Search query.'),
-    limit: optionalPositiveInteger().describe('Maximum result count.')
-};
-export const explainInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    ...searchModeInput,
-    query: z.string().min(1).describe('Search query to explain.'),
-    limit: optionalPositiveInteger().describe('Maximum result count.')
-};
-export const addNoteInputSchema = {
-    ...vaultInput,
-    title: z.string().min(1).describe('Markdown note title.'),
-    content: z
-        .string()
-        .min(1)
-        .describe('Durable Markdown memory. Include explicit [[wiki links]] and #tags when the memory should be connected. Put priority markers near important links, for example priority: high, #important or #critical.'),
-    ...agentInput,
-    allowSensitive: z.boolean().optional().default(false).describe('Allow content that looks like a secret.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after writing note.'),
-    autoContextLinks: z
-        .boolean()
-        .optional()
-        .describe('Automatically add canonical Context Links to the inferred visual context hub. Defaults to Brainlink config.')
-};
-export const rememberInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    title: z.string().min(1).optional().describe('Optional note title. When omitted, Brainlink infers it from content.'),
-    content: z.string().min(1).describe('Memory content to capture as a durable Markdown note.'),
-    tags: z.array(z.string()).optional().default([]).describe('Extra tags to include.'),
-    links: z.array(z.string()).optional().default([]).describe('Explicit Context Links to include.'),
-    linkLimit: positiveInteger(5).describe('Maximum suggested Context Links to include.'),
-    dryRun: z.boolean().optional().default(false).describe('Preview inferred note without writing it.'),
-    allowSensitive: z.boolean().optional().default(false).describe('Allow content that looks like a secret.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after writing note.')
-};
-export const inboxAddInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    content: z.string().min(1).describe('Quick memory content to store as an untriaged inbox note.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after writing inbox item.')
-};
-export const inboxListInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    limit: positiveInteger(20).describe('Maximum inbox items to return.')
-};
-export const inboxProcessInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    limit: positiveInteger(10).describe('Maximum inbox items to inspect.')
-};
-export const deleteNoteInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    title: z.string().min(1).optional().describe('Note title to delete. Use agent to disambiguate namespaced notes.'),
-    path: z.string().min(1).optional().describe('Vault-relative or absolute Markdown note path to delete.'),
-    confirm: z.boolean().describe('Must be true to confirm deletion.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after deletion. Defaults to true.')
-};
-export const volatileAddInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    content: z
-        .string()
-        .min(1)
-        .describe('Temporary agent-decided memory. Use for current task state, hypotheses, transient user preferences and unconfirmed findings.'),
-    ttlMinutes: optionalPositiveInteger().describe('Minutes before this volatile memory expires. Defaults to 240.'),
-    tags: z.array(z.string()).optional().default([]).describe('Optional tags for volatile retrieval.')
-};
-export const volatileClearInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const addFileInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    title: z.string().min(1).optional().describe('Optional note title override. If omitted, uses file name.'),
-    filePath: z.string().min(1).describe('Filesystem path to markdown or text file to ingest.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after ingesting file.'),
-    allowSensitive: z.boolean().optional().default(false).describe('Allow content that looks like a secret.')
-};
-export const canonicalizeContextLinksInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    dryRun: z.boolean().optional().default(false).describe('Preview canonical context-link writes without changing Markdown.'),
-    createHubs: z.boolean().optional().default(true).describe('Create missing context hub notes when needed.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex after canonicalization when files changed.')
-};
-export const indexInputSchema = {
-    ...vaultInput,
-    full: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Force a complete reindex from Markdown source without reusing unchanged index entries.')
-};
-export const validateInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const doctorActionsInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const graphInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const graphContextsInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const brokenLinksInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const suggestLinksInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    content: z.string().min(1).optional().describe('Content to inspect for Context Link suggestions. Required unless broken=true.'),
-    broken: z.boolean().optional().default(false).describe('Suggest fixes for unresolved wiki links instead of content links.'),
-    limit: positiveInteger(5).describe('Maximum suggestions to return.')
-};
-export const repairLinksInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    dryRun: z.boolean().optional().default(false).describe('Preview repairs without writing files.'),
-    createMissing: z.boolean().optional().default(true).describe('Create placeholder notes for unresolved targets without a safe existing match.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after repairs.'),
-    minScore: z.number().min(0).max(1).optional().default(0.88).describe('Minimum similarity score for automatic retargeting.'),
-    margin: z.number().min(0).max(1).optional().default(0.12).describe('Minimum score gap between first and second candidate.')
-};
-export const orphansInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const statsInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const syncInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    contextQuery: z.string().min(1).optional().describe('Optional context smoke query. Omit to skip context probe.'),
-    mode: z.enum(['fts', 'semantic', 'hybrid']).optional().describe('Search mode for the optional context probe. Defaults to config value.'),
-    strategy: z.enum(['rag', 'cag', 'auto']).optional().describe('Context strategy for the optional context probe. Defaults to the Brainlink config value.'),
-    contextLimit: optionalPositiveInteger().describe('Context smoke result limit when contextQuery is provided.'),
-    contextTokens: optionalPositiveInteger().describe('Context smoke token target when contextQuery is provided.')
-};
-export const bootstrapInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    ...searchModeInput,
-    ...contextStrategyInput,
-    query: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Optional task query. When provided, Brainlink also returns a context package in the same call.'),
-    limit: optionalPositiveInteger().describe('Context limit used when query is provided.'),
-    tokens: optionalPositiveInteger().describe('Context token target used when query is provided.')
-};
-export const policyInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    preset: z.enum(['fully-auto', 'strict']).optional().describe('Apply an opinionated policy preset before explicit overrides.'),
-    enforceBootstrap: z.boolean().optional().describe('Enable or disable bootstrap enforcement for MCP read tools.'),
-    enforceContextFirst: z.boolean().optional().describe('Require brainlink_context before other MCP read tools.'),
-    autoBootstrapOnRead: z
-        .boolean()
-        .optional()
-        .describe('When bootstrap is missing/stale, run automatic bootstrap on read tools instead of returning preflight-required responses.'),
-    autoBootstrapOnStartup: z
-        .boolean()
-        .optional()
-        .describe('Run automatic bootstrap during MCP server startup using configured default vault/agent.'),
-    staleAfterMinutes: positiveInteger(120).describe('Bootstrap freshness window in minutes before read tools require a new bootstrap.')
-};
-export const versionInputSchema = {
-    ...vaultInput,
-    ...agentInput
-};
-export const sessionCloseInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    content: z.string().min(1).optional().describe('Optional extra session notes to include in the handoff.'),
-    cwd: z.string().min(1).optional().describe('Workspace path used for git status. Defaults to current process working directory.'),
-    dryRun: z.boolean().optional().default(false).describe('Preview handoff note without writing it.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after writing handoff.')
-};
-export const projectInitInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    projectPath: z.string().min(1).optional().describe('Project path to inspect. Defaults to current process working directory.')
-};
-export const recommendationsInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    ...searchModeInput,
-    ...contextStrategyInput,
-    query: z.string().min(1).optional().describe('Optional current task query to generate context-focused recommendations.'),
-    limit: optionalPositiveInteger().describe('Optional context limit override for generated recommendations.'),
-    tokens: optionalPositiveInteger().describe('Optional context token budget override for generated recommendations.')
-};
-export const dedupeInputSchema = {
-    ...vaultInput,
-    ...agentInput,
-    limit: optionalPositiveInteger().describe('Maximum duplicate candidate pairs to return.'),
-    minScore: z.number().min(0).max(1).optional().describe('Minimum semantic similarity score between 0 and 1.'),
-    semantic: z.boolean().optional().default(true).describe('Enable semantic duplicate detection in addition to exact content hash matches.')
-};
-export const dedupeResolveInputSchema = {
-    ...vaultInput,
-    leftPath: z.string().min(1).describe('Left note path from dedupe results.'),
-    rightPath: z.string().min(1).describe('Right note path from dedupe results.'),
-    action: z.enum(['merge', 'link', 'ignore']).describe('Resolution action.'),
-    autoIndex: z.boolean().optional().default(true).describe('Reindex after duplicate resolution.')
-};
-export const contextTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_context');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const mode = sanitizeSearchMode(input.mode, context.defaults.defaultSearchMode);
-    const strategy = sanitizeContextStrategy(input.strategy, context.defaults.defaultContextStrategy);
-    const limit = input.limit ?? context.defaults.defaultSearchLimit;
-    const tokens = input.tokens ?? context.defaults.defaultContextTokens;
-    const contextPackage = await buildContextPackage(context.vault, input.query, limit, tokens, context.agent, mode, strategy, context.defaults.defaultContextCacheTtlMs);
-    const contextSession = await touchContextSession(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        mode,
-        strategy,
-        limit,
-        tokens,
-        contextSession,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...contextPackage
-    });
-};
-export const contextPacksTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const dataSignature = await readContextDataSignature(context.vault);
-    if (input.action === 'clear') {
-        const result = await clearContextPacks(context.vault, {
-            staleOnly: input.staleOnly === true,
-            dataSignature
-        });
-        return jsonResult({
-            vault: context.vault,
-            agent: context.agent,
-            dataSignature,
-            action: 'clear',
-            staleOnly: input.staleOnly === true,
-            ...result
-        });
-    }
-    const packs = await listContextPacks(context.vault, dataSignature);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        dataSignature,
-        action: 'list',
-        packs
-    });
-};
-export const searchTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_search');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_search');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const mode = sanitizeSearchMode(input.mode, context.defaults.defaultSearchMode);
-    const limit = input.limit ?? context.defaults.defaultSearchLimit;
-    const results = await searchKnowledge(context.vault, input.query, limit, context.agent, mode);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        query: input.query,
-        limit,
-        mode,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        results
-    });
-};
-export const explainTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_explain');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_explain');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const mode = sanitizeSearchMode(input.mode, context.defaults.defaultSearchMode);
-    const limit = input.limit ?? context.defaults.defaultSearchLimit;
-    const results = await explainSearchResults(context.vault, input.query, limit, context.agent, mode);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        query: input.query,
-        limit,
-        mode,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        results
-    });
-};
-export const addNoteTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const shouldIndex = isTruthy(input.autoIndex);
-    const added = await addNoteWithMetadata(context.vault, input.title, input.content, context.agent, {
-        allowSensitive: input.allowSensitive,
-        autoContextLinks: input.autoContextLinks ?? context.config.autoCanonicalContextLinks
-    });
-    const index = shouldIndex ? await indexVault(context.vault) : undefined;
-    const focusPath = added.path.includes('agents/') ? added.path.slice(added.path.indexOf('agents/')).replaceAll('\\', '/') : undefined;
-    const possibleDuplicates = await scanDuplicateNotes(context.vault, {
-        agentId: context.agent,
-        focusPath,
-        limit: 5,
-        minSemanticScore: 0.92,
-        includeSemantic: true
-    });
-    return jsonResult({
-        vault: context.vault,
-        title: input.title,
-        agent: context.agent,
-        path: added.path,
-        writeConnectivity: {
-            autoLinked: added.autoLinked,
-            linkTarget: added.linkTarget,
-            context: added.context,
-            hubCreated: added.hubCreated,
-            guaranteedEdge: added.autoLinked
-        },
-        possibleDuplicates,
-        ...(index ? { index } : {})
-    });
-};
-export const rememberTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const suggestion = await buildRememberSuggestion({
-        vaultPath: context.vault,
-        content: input.content,
-        agentId: context.agent,
-        title: input.title,
-        tags: input.tags,
-        links: input.links,
-        linkLimit: input.linkLimit
-    });
-    if (input.dryRun) {
-        return jsonResult({
-            dryRun: true,
-            vault: context.vault,
-            agent: context.agent,
-            suggestion
-        });
-    }
-    const added = await addNoteWithMetadata(context.vault, suggestion.title, suggestion.content, context.agent, {
-        allowSensitive: input.allowSensitive,
-        autoContextLinks: false
-    });
-    const index = input.autoIndex ? await indexVault(context.vault) : undefined;
-    return jsonResult({
-        dryRun: false,
-        vault: context.vault,
-        agent: context.agent,
-        suggestion,
-        path: added.path,
-        ...(index ? { index } : {})
-    });
-};
-export const inboxAddTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await addInboxItem({
-        vaultPath: context.vault,
-        content: input.content,
-        agentId: context.agent,
-        autoIndex: input.autoIndex
-    });
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...result
-    });
-};
-export const inboxListTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const items = await listInboxItems(context.vault, input.limit);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        items
-    });
-};
-export const inboxProcessTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const items = await processInboxItems({
-        vaultPath: context.vault,
-        agentId: context.agent,
-        limit: input.limit
-    });
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        items
-    });
-};
-export const deleteNoteTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await deleteNote(context.vault, {
-        title: input.title,
-        path: input.path,
-        agentId: context.agent,
-        confirm: input.confirm,
-        autoIndex: input.autoIndex
-    });
-    return jsonResult({
-        vault: context.vault,
-        ...result
-    });
-};
-export const volatileAddTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const entry = await addVolatileMemory(context.vault, input.content, context.agent ?? 'shared', input.ttlMinutes ?? 240, input.tags);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        volatile: true,
-        entry
-    });
-};
-export const volatileClearTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const cleared = await clearVolatileMemory(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        cleared
-    });
-};
-export const addFileTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const content = await readFile(input.filePath, 'utf8');
-    const inferredTitle = inferTitleFromPath(input.filePath);
-    const title = input.title ?? inferredTitle;
-    if (title == null || title.length === 0) {
-        throw new Error('Cannot infer note title from file path. Provide a title explicitly.');
-    }
-    const shouldIndex = isTruthy(input.autoIndex);
-    const added = await addNoteWithMetadata(context.vault, title, content, context.agent, {
-        allowSensitive: input.allowSensitive,
-        autoContextLinks: context.config.autoCanonicalContextLinks
-    });
-    const index = shouldIndex ? await indexVault(context.vault) : undefined;
-    return jsonResult({
-        vault: context.vault,
-        title,
-        agent: context.agent,
-        filePath: input.filePath,
-        path: added.path,
-        writeConnectivity: {
-            autoLinked: added.autoLinked,
-            linkTarget: added.linkTarget,
-            context: added.context,
-            hubCreated: added.hubCreated,
-            guaranteedEdge: added.autoLinked
-        },
-        ...(index ? { index } : {})
-    });
-};
-export const canonicalizeContextLinksTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await canonicalizeContextLinks(context.vault, {
-        agentId: context.agent,
-        dryRun: input.dryRun === true,
-        createMissingHubs: input.createHubs !== false
-    });
-    const index = input.autoIndex !== false && !result.dryRun && result.changed > 0
-        ? await indexVault(context.vault, { full: true })
-        : undefined;
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...result,
-        ...(index ? { index } : {})
-    });
-};
-export const indexTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await indexVault(context.vault, {
-        full: input.full === true
-    });
-    return jsonResult({
-        vault: context.vault,
-        ...result
-    });
-};
-export const validateTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_validate');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_validate');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const validation = await validateVault(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        ...validation
-    });
-};
-export const doctorActionsTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_doctor_actions');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_doctor_actions');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const report = await buildActionableDoctor(context.vault);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        ...report
-    });
-};
-export const graphTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_graph');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_graph');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const graph = await getGraph(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        ...graph
-    });
-};
-export const graphContextsTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_graph_contexts');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_graph_contexts');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const contexts = await getGraphContexts(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        contexts
-    });
-};
-export const brokenLinksTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_broken_links');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_broken_links');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const brokenLinks = await getBrokenLinksReport(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        brokenLinks
-    });
-};
-export const suggestLinksTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_suggest_links');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_suggest_links');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    if (input.broken) {
-        const suggestions = await suggestBrokenLinkFixes(context.vault, context.agent, input.limit);
-        return jsonResult({
-            vault: context.vault,
-            agent: context.agent,
-            mode: 'broken-links',
-            ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-            ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-            suggestions
-        });
-    }
-    if (!input.content || input.content.trim().length === 0) {
-        throw new Error('content is required when broken=false.');
-    }
-    const suggestions = await suggestContextLinks(context.vault, input.content, context.agent, input.limit);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        mode: 'content',
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        suggestions
-    });
-};
-export const repairLinksTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await repairBrokenLinks(context.vault, {
-        agentId: context.agent,
-        dryRun: input.dryRun,
-        createMissing: input.createMissing,
-        autoIndex: input.autoIndex,
-        minScore: input.minScore,
-        margin: input.margin
-    });
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...result
-    });
-};
-export const orphansTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_orphans');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_orphans');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const orphans = await getOrphansReport(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        orphans
-    });
-};
-export const statsTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_stats');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_stats');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const stats = await getStats(context.vault, context.agent);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        stats
-    });
-};
-export const syncTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const readiness = await ensureBootstrapReady(context, input, 'brainlink_sync');
-    if (readiness.preflight) {
-        return readiness.preflight;
-    }
-    const contextReadiness = await ensureContextReady(context, input, 'brainlink_sync');
-    if (contextReadiness.preflight) {
-        return contextReadiness.preflight;
-    }
-    const index = await indexVault(context.vault);
-    const stats = await getStats(context.vault, context.agent);
-    const validation = await validateVault(context.vault, context.agent);
-    const brokenLinks = await getBrokenLinksReport(context.vault, context.agent);
-    const orphans = await getOrphansReport(context.vault, context.agent);
-    const response = {
-        vault: context.vault,
-        agent: context.agent,
-        ...(readiness.bootstrap ? { bootstrap: readiness.bootstrap } : {}),
-        ...(contextReadiness.context ? { contextReadiness: contextReadiness.context } : {}),
-        index,
-        stats,
-        validation,
-        brokenLinks,
-        orphans
-    };
-    if (!input.contextQuery) {
-        return jsonResult(response);
-    }
-    const mode = sanitizeSearchMode(input.mode, context.defaults.defaultSearchMode);
-    const strategy = sanitizeContextStrategy(input.strategy, context.defaults.defaultContextStrategy);
-    const contextLimit = input.contextLimit ?? context.defaults.defaultSearchLimit;
-    const contextTokens = input.contextTokens ?? context.defaults.defaultContextTokens;
-    const contextPackage = await buildContextPackage(context.vault, input.contextQuery, contextLimit, contextTokens, context.agent, mode, strategy, context.defaults.defaultContextCacheTtlMs);
-    const contextSession = await touchContextSession(context.vault, context.agent);
-    return jsonResult({
-        ...response,
-        context: {
-            mode,
-            strategy,
-            contextSession,
-            ...contextPackage
-        }
-    });
-};
-export const bootstrapTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const index = await indexVault(context.vault);
-    const stats = await getStats(context.vault, context.agent);
-    const validation = await validateVault(context.vault, context.agent);
-    const mode = sanitizeSearchMode(input.mode, context.defaults.defaultSearchMode);
-    const strategy = sanitizeContextStrategy(input.strategy, context.defaults.defaultContextStrategy);
-    const limit = input.limit ?? context.defaults.defaultSearchLimit;
-    const tokens = input.tokens ?? context.defaults.defaultContextTokens;
-    const contextPackage = input.query
-        ? await buildContextPackage(context.vault, input.query, limit, tokens, context.agent, mode, strategy, context.defaults.defaultContextCacheTtlMs)
-        : undefined;
-    const contextSession = input.query ? await touchContextSession(context.vault, context.agent) : undefined;
-    const guidance = stats.documentCount === 0
-        ? 'Vault indexed with zero documents. Add durable notes with brainlink_add_note, then run brainlink_bootstrap again.'
-        : input.query
-            ? 'Use returned context as grounding baseline, then write durable updates with brainlink_add_note when needed.'
-            : 'Run brainlink_context with the current task query to retrieve grounded context before answering.';
-    const session = await touchBootstrapSession(context.vault, context.agent);
-    const policy = await getBootstrapPolicy();
-    const nextActions = stats.documentCount === 0
-        ? [
-            {
-                tool: 'brainlink_add_note',
-                reason: 'No indexed documents were found. Add durable Markdown memory first.',
-                args: {
-                    vault: context.vault,
-                    ...(context.agent ? { agent: context.agent } : {}),
-                    title: 'Architecture',
-                    content: 'Durable memory with explicit [[links]] and #tags.'
-                }
-            },
-            {
-                tool: 'brainlink_bootstrap',
-                reason: 'Re-run bootstrap after writing notes so context tools can work on fresh index state.',
-                args: {
-                    vault: context.vault,
-                    ...(context.agent ? { agent: context.agent } : {}),
-                    mode
-                }
-            }
-        ]
-        : input.query
-            ? [
-                {
-                    tool: 'brainlink_add_note',
-                    reason: 'Persist relevant outcomes from this task as durable memory.',
-                    args: {
-                        vault: context.vault,
-                        ...(context.agent ? { agent: context.agent } : {}),
-                        title: 'Task Update',
-                        content: 'Summarize durable findings and connect with [[existing notes]].'
-                    }
-                }
-            ]
-            : [
-                {
-                    tool: 'brainlink_context',
-                    reason: 'Fetch grounded context for the current task.',
-                    args: {
-                        vault: context.vault,
-                        ...(context.agent ? { agent: context.agent } : {}),
-                        query: '<task>',
-                        mode,
-                        strategy,
-                        limit,
-                        tokens
-                    }
-                }
-            ];
-    return jsonResult(withNextActions({
-        vault: context.vault,
-        agent: context.agent,
-        mode,
-        strategy,
-        limit,
-        tokens,
-        index,
-        stats,
-        validation,
-        policy,
-        session,
-        guidance,
-        ...(contextPackage ? { context: contextPackage } : {}),
-        ...(contextSession ? { contextSession } : {})
-    }, nextActions));
-};
-export const policyTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const presetPatch = input.preset === 'strict'
-        ? {
-            enforceBootstrap: true,
-            enforceContextFirst: true,
-            autoBootstrapOnRead: false,
-            autoBootstrapOnStartup: false
-        }
-        : input.preset === 'fully-auto'
-            ? {
-                enforceBootstrap: true,
-                enforceContextFirst: true,
-                autoBootstrapOnRead: true,
-                autoBootstrapOnStartup: true
-            }
-            : {};
-    const policy = input.preset !== undefined ||
-        typeof input.enforceBootstrap === 'boolean' ||
-        typeof input.enforceContextFirst === 'boolean' ||
-        typeof input.autoBootstrapOnRead === 'boolean' ||
-        typeof input.autoBootstrapOnStartup === 'boolean' ||
-        typeof input.staleAfterMinutes === 'number'
-        ? await setBootstrapPolicy({
-            ...presetPatch,
-            ...(typeof input.enforceBootstrap === 'boolean' ? { enforceBootstrap: input.enforceBootstrap } : {}),
-            ...(typeof input.enforceContextFirst === 'boolean' ? { enforceContextFirst: input.enforceContextFirst } : {}),
-            ...(typeof input.autoBootstrapOnRead === 'boolean' ? { autoBootstrapOnRead: input.autoBootstrapOnRead } : {}),
-            ...(typeof input.autoBootstrapOnStartup === 'boolean' ? { autoBootstrapOnStartup: input.autoBootstrapOnStartup } : {}),
-            ...(typeof input.staleAfterMinutes === 'number' ? { staleAfterMinutes: input.staleAfterMinutes } : {})
-        })
-        : await getBootstrapPolicy();
-    const bootstrapStatus = await getBootstrapSessionStatus(context.vault, context.agent);
-    const contextStatus = await getContextSessionStatus(context.vault, context.agent);
-    const nextActions = bootstrapStatus.ready
-        ? []
-        : [
-            {
-                tool: 'brainlink_bootstrap',
-                reason: 'Bootstrap status is not ready. Run bootstrap before using read tools.',
-                args: {
-                    vault: context.vault,
-                    ...(context.agent ? { agent: context.agent } : {}),
-                    mode: context.defaults.defaultSearchMode,
-                    strategy: context.defaults.defaultContextStrategy
-                }
-            }
-        ];
-    const withContextAction = policy.enforceContextFirst && !contextStatus.ready
-        ? [
-            ...nextActions,
-            {
-                tool: 'brainlink_context',
-                reason: 'Context-first policy is enabled. Load context before other read tools.',
-                args: {
-                    vault: context.vault,
-                    ...(context.agent ? { agent: context.agent } : {}),
-                    query: '<task>',
-                    mode: context.defaults.defaultSearchMode,
-                    strategy: context.defaults.defaultContextStrategy,
-                    limit: context.defaults.defaultSearchLimit,
-                    tokens: context.defaults.defaultContextTokens
-                }
-            }
-        ]
-        : nextActions;
-    return jsonResult(withNextActions({
-        vault: context.vault,
-        agent: context.agent,
-        runtime: getRuntimeMetadata(),
-        policy,
-        bootstrapStatus,
-        contextStatus,
-        ...(input.preset ? { presetApplied: input.preset } : {})
-    }, withContextAction));
-};
-export const versionTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        runtime: getRuntimeMetadata()
-    });
-};
-export const sessionCloseTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await closeSession({
-        vaultPath: context.vault,
-        agentId: context.agent,
-        cwd: resolve(input.cwd ?? process.cwd()),
-        content: input.content,
-        write: input.dryRun !== true,
-        autoIndex: input.autoIndex
-    });
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        dryRun: input.dryRun === true,
-        ...result
-    });
-};
-export const projectInitTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await initializeProjectMemory({
-        vaultPath: context.vault,
-        projectPath: resolve(input.projectPath ?? process.cwd()),
-        agentId: context.agent
-    });
-    return jsonResult({
-        agent: context.agent,
-        ...result
-    });
-};
-export const recommendationsTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const policy = await getBootstrapPolicy();
-    const bootstrapStatus = await getBootstrapSessionStatus(context.vault, context.agent);
-    const contextStatus = await getContextSessionStatus(context.vault, context.agent);
-    const stats = await getStats(context.vault, context.agent);
-    const mode = sanitizeSearchMode(input.mode, context.defaults.defaultSearchMode);
-    const strategy = sanitizeContextStrategy(input.strategy, context.defaults.defaultContextStrategy);
-    const limit = input.limit ?? context.defaults.defaultSearchLimit;
-    const tokens = input.tokens ?? context.defaults.defaultContextTokens;
-    const query = input.query?.trim();
-    const recommendations = [
-        ...(policy.enforceBootstrap && (!policy.autoBootstrapOnRead || !policy.autoBootstrapOnStartup)
-            ? [
-                {
-                    tool: 'brainlink_policy',
-                    reason: 'Enable fully automatic bootstrap for plug-and-play agent usage.',
-                    args: {
-                        preset: 'fully-auto'
-                    }
-                }
-            ]
-            : []),
-        ...(!bootstrapStatus.ready && !policy.autoBootstrapOnRead
-            ? [
-                {
-                    tool: 'brainlink_bootstrap',
-                    reason: 'Bootstrap is required before read tools when auto-bootstrap-on-read is disabled.',
-                    args: {
-                        vault: context.vault,
-                        ...(context.agent ? { agent: context.agent } : {}),
-                        mode,
-                        strategy,
-                        ...(query ? { query } : {})
-                    }
-                }
-            ]
-            : []),
-        ...(policy.enforceContextFirst && !contextStatus.ready
-            ? [
-                {
-                    tool: 'brainlink_context',
-                    reason: 'Context-first policy is enabled. Load context before other read operations.',
-                    args: {
-                        vault: context.vault,
-                        ...(context.agent ? { agent: context.agent } : {}),
-                        query: query ?? '<task>',
-                        mode,
-                        strategy,
-                        limit,
-                        tokens
-                    }
-                }
-            ]
-            : []),
-        ...(stats.documentCount === 0
-            ? [
-                {
-                    tool: 'brainlink_add_note',
-                    reason: 'Seed the vault with a first durable note so retrieval can return useful context.',
-                    args: {
-                        vault: context.vault,
-                        ...(context.agent ? { agent: context.agent } : {}),
-                        title: 'Architecture',
-                        content: 'Seed durable memory with explicit [[links]] and #tags.'
-                    }
-                },
-                {
-                    tool: 'brainlink_index',
-                    reason: 'Rebuild index after writing the first notes.',
-                    args: {
-                        vault: context.vault
-                    }
-                }
-            ]
-            : []),
-        {
-            tool: 'brainlink_context',
-            reason: 'Retrieve grounded memory context before responding.',
-            args: {
-                vault: context.vault,
-                ...(context.agent ? { agent: context.agent } : {}),
-                query: query ?? '<task>',
-                mode,
-                strategy,
-                limit,
-                tokens
-            }
-        },
-        {
-            tool: 'brainlink_dedupe',
-            reason: 'Detect and resolve duplicate durable notes to keep memory quality high.',
-            args: {
-                vault: context.vault,
-                ...(context.agent ? { agent: context.agent } : {}),
-                limit: 10,
-                minScore: 0.92,
-                semantic: true
-            }
-        },
-        {
-            tool: 'brainlink_add_note',
-            reason: 'Persist durable outcomes after task completion (write responses include connectivity metadata).',
-            args: {
-                vault: context.vault,
-                ...(context.agent ? { agent: context.agent } : {}),
-                title: 'Task Update',
-                content: 'Durable findings connected to [[existing notes]].'
-            }
-        }
-    ];
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        defaults: {
-            mode,
-            strategy,
-            limit,
-            tokens
-        },
-        contextStrategies: [
-            {
-                strategy: 'rag',
-                useWhen: 'Use for fresh retrieval and context assembly from the current index.'
-            },
-            {
-                strategy: 'cag',
-                useWhen: 'Use for repeated or stable task context so Brainlink can reuse a fresh persisted context pack.'
-            },
-            {
-                strategy: 'auto',
-                useWhen: 'Use when the agent wants Brainlink to choose CAG on fresh pack hits and RAG otherwise.'
-            }
-        ],
-        policy,
-        bootstrapStatus,
-        contextStatus,
-        stats,
-        recommendations
-    });
-};
-export const dedupeTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const duplicates = await scanDuplicateNotes(context.vault, {
-        agentId: context.agent,
-        limit: input.limit ?? 25,
-        minSemanticScore: input.minScore ?? 0.92,
-        includeSemantic: input.semantic !== false
-    });
-    return jsonResult({
-        vault: context.vault,
-        agent: context.agent,
-        duplicates
-    });
-};
-export const dedupeResolveTool = async (input) => {
-    const context = await resolveExecutionContext(input);
-    const result = await resolveDuplicateNotes(context.vault, {
-        leftPath: input.leftPath,
-        rightPath: input.rightPath,
-        action: input.action,
-        autoIndex: isTruthy(input.autoIndex)
-    });
-    return jsonResult({
-        vault: context.vault,
-        ...result
-    });
-};
+export { brokenLinksInputSchema, brokenLinksTool, contextInputSchema, contextPacksInputSchema, contextPacksTool, contextTool, doctorActionsInputSchema, doctorActionsTool, explainInputSchema, explainTool, graphContextsInputSchema, graphContextsTool, graphInputSchema, graphTool, orphansInputSchema, orphansTool, recommendationsInputSchema, recommendationsTool, searchInputSchema, searchTool, statsInputSchema, statsTool, suggestLinksInputSchema, suggestLinksTool, validateInputSchema, validateTool, versionInputSchema, versionTool } from './tools/read-tools.js';
+export { addFileInputSchema, addFileTool, addNoteInputSchema, addNoteTool, deleteNoteInputSchema, deleteNoteTool, inboxAddInputSchema, inboxAddTool, inboxListInputSchema, inboxListTool, inboxProcessInputSchema, inboxProcessTool, rememberInputSchema, rememberTool, volatileAddInputSchema, volatileAddTool, volatileClearInputSchema, volatileClearTool } from './tools/write-tools.js';
+export { bootstrapInputSchema, bootstrapTool, canonicalizeContextLinksInputSchema, canonicalizeContextLinksTool, dedupeInputSchema, dedupeResolveInputSchema, dedupeResolveTool, dedupeTool, indexInputSchema, indexTool, policyInputSchema, policyTool, projectInitInputSchema, projectInitTool, repairLinksInputSchema, repairLinksTool, sessionCloseInputSchema, sessionCloseTool, syncInputSchema, syncTool } from './tools/maintenance-tools.js';