@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/mcp/config.js

@@ -3,6 +3,7 @@ import path from 'path';
 import os from 'os';
 import { getSettingsManager } from "../utils/settings-manager.js";
 import { logger } from '../utils/logger.js';
+import { readJsonAtomicSync, readJsonAtomicSyncReadOnly, writeJsonAtomicSync } from '../utils/atomic-write.js';
 /**
  * Resolve ${ENV_VAR} references in env values from process.env
  */
@@ -13,7 +14,7 @@ function resolveEnvVars(env) {
     for (const [key, value] of Object.entries(env)) {
         const match = value.match(/^\$\{(\w+)\}$/);
         const varName = match?.[1];
-        resolved[key] = varName !== undefined ? (process.env[varName] || '') : value;
+        resolved[key] = varName !== undefined ? (process.env[varName] || value) : value;
     }
     return resolved;
 }
@@ -29,24 +30,36 @@ function resolveServerEnv(server) {
     }
     return server;
 }
-/**
- * Load MCP configuration from multiple sources (Advanced enterprise architecture for)
- * Priority: Project .codebuddy/mcp.json > .codebuddy/settings.json > ~/.codebuddy/mcp.json
- */
-export function loadMCPConfig() {
+/** `mcpServers` of a project `.codebuddy/settings.json` read directly (explicit `cwd`). */
+function readProjectSettingsServers(projectDir) {
+    const settingsPath = path.join(projectDir, '.codebuddy', 'settings.json');
+    if (!fs.existsSync(settingsPath))
+        return undefined;
+    try {
+        const settings = readJsonAtomicSync(settingsPath, null, { mode: 0o600 });
+        const servers = settings?.mcpServers;
+        return servers && typeof servers === 'object' && !Array.isArray(servers) ? servers : undefined;
+    }
+    catch (error) {
+        logger.warn('Failed to load project settings MCP servers', { error });
+        return undefined;
+    }
+}
+export function loadMCPConfig(options = {}) {
     const servers = [];
     const seenServers = new Set();
     // 1. First, try project-level .codebuddy/mcp.json (highest priority, committable)
-    const projectMCPPath = path.join(process.cwd(), '.codebuddy', 'mcp.json');
+    const projectDir = options.cwd ?? process.cwd();
+    const projectMCPPath = path.join(projectDir, '.codebuddy', 'mcp.json');
     if (fs.existsSync(projectMCPPath)) {
         try {
-            const projectMCP = JSON.parse(fs.readFileSync(projectMCPPath, 'utf-8'));
+            const projectMCP = readJsonAtomicSync(projectMCPPath, {});
             const mcpServers = projectMCP.mcpServers || projectMCP.servers || {};
             for (const [name, config] of Object.entries(mcpServers)) {
                 if (!seenServers.has(name)) {
                     const serverConfig = resolveServerEnv({ ...config, name });
                     // Skip disabled servers at load time
-                    if (serverConfig.enabled === false) {
+                    if (serverConfig.enabled === false && !options.includeDisabled) {
                         seenServers.add(name);
                         continue;
                     }
@@ -59,13 +72,18 @@ export function loadMCPConfig() {
             logger.warn('Failed to load project MCP config', { error });
         }
     }
-    // 2. Then, try project settings (.codebuddy/settings.json)
-    const manager = getSettingsManager();
-    const projectSettings = manager.loadProjectSettings();
-    if (projectSettings.mcpServers) {
-        for (const [name, config] of Object.entries(projectSettings.mcpServers)) {
+    // 2. Then, try project settings (.codebuddy/settings.json). Without an explicit `cwd`
+    // the settings manager keeps its historical path; with one, that project's file is read.
+    const projectSettingsServers = options.cwd === undefined
+        ? getSettingsManager().loadProjectSettings().mcpServers
+        : readProjectSettingsServers(projectDir);
+    if (projectSettingsServers) {
+        for (const [name, config] of Object.entries(projectSettingsServers)) {
             if (!seenServers.has(name)) {
-                servers.push(resolveServerEnv(config));
+                const serverConfig = resolveServerEnv({ ...config, name });
+                if (serverConfig.enabled !== false || options.includeDisabled) {
+                    servers.push(serverConfig);
+                }
                 seenServers.add(name);
             }
         }
@@ -74,11 +92,14 @@ export function loadMCPConfig() {
     const userMCPPath = path.join(os.homedir(), '.codebuddy', 'mcp.json');
     if (fs.existsSync(userMCPPath)) {
         try {
-            const userMCP = JSON.parse(fs.readFileSync(userMCPPath, 'utf-8'));
+            const userMCP = readJsonAtomicSync(userMCPPath, {});
             const mcpServers = userMCP.mcpServers || userMCP.servers || {};
             for (const [name, config] of Object.entries(mcpServers)) {
                 if (!seenServers.has(name)) {
-                    servers.push(resolveServerEnv({ ...config, name }));
+                    const serverConfig = resolveServerEnv({ ...config, name });
+                    if (serverConfig.enabled !== false || options.includeDisabled) {
+                        servers.push(serverConfig);
+                    }
                     seenServers.add(name);
                 }
             }
@@ -89,6 +110,101 @@ export function loadMCPConfig() {
     }
     return { servers };
 }
+function isServerMap(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readOnlyServersFromFile(filePath, label, warnings, keys) {
+    const outcome = readJsonAtomicSyncReadOnly(filePath, isServerMap);
+    if (outcome.status === 'missing')
+        return undefined;
+    if (outcome.status === 'unreadable') {
+        warnings.push(`${label} is unreadable`);
+        return undefined;
+    }
+    if (outcome.status === 'corrupt') {
+        warnings.push(`${label} is corrupt or not a JSON object`);
+        return undefined;
+    }
+    const parsed = outcome.value;
+    if (keys === 'mcpServers-only') {
+        // The runtime never reads a `servers` key here: report it instead of counting it.
+        if (parsed.servers !== undefined) {
+            warnings.push(`${label} has a "servers" key, which is not read at runtime; use mcpServers`);
+        }
+        if (parsed.mcpServers === undefined)
+            return undefined;
+        if (!isServerMap(parsed.mcpServers)) {
+            warnings.push(`${label} has an invalid mcpServers value (expected an object)`);
+            return undefined;
+        }
+        return parsed.mcpServers;
+    }
+    // Same selection as the runtime (`mcpServers || servers`).
+    const servers = parsed.mcpServers || parsed.servers;
+    if (!servers)
+        return undefined;
+    if (!isServerMap(servers)) {
+        warnings.push(`${label} has an invalid mcpServers/servers value (expected an object)`);
+        return undefined;
+    }
+    return servers;
+}
+/**
+ * Strictly read-only MCP configuration loader for diagnostics. Reads the same
+ * three sources with the same precedence, disabled masking, and env resolution
+ * as `loadMCPConfig`, but never restores/renames/chmods/creates config or
+ * backups/temporaries. Corrupt or unreadable sources yield sanitized warnings
+ * instead of being silently treated as "no server configured". Missing config
+ * is normal and produces no warning.
+ */
+export function loadMCPConfigReadOnly(options = {}) {
+    const servers = [];
+    const seenServers = new Set();
+    const warnings = [];
+    const projectDir = options.cwd ?? process.cwd();
+    const projectMCPPath = path.join(projectDir, '.codebuddy', 'mcp.json');
+    const projectMCP = readOnlyServersFromFile(projectMCPPath, 'project .codebuddy/mcp.json', warnings, 'mcpServers-or-servers');
+    if (projectMCP) {
+        for (const [name, config] of Object.entries(projectMCP)) {
+            if (seenServers.has(name))
+                continue;
+            const serverConfig = resolveServerEnv({ ...config, name });
+            if (serverConfig.enabled === false && !options.includeDisabled) {
+                seenServers.add(name);
+                continue;
+            }
+            servers.push(serverConfig);
+            seenServers.add(name);
+        }
+    }
+    const projectSettingsPath = path.join(projectDir, '.codebuddy', 'settings.json');
+    const projectSettings = readOnlyServersFromFile(projectSettingsPath, 'project .codebuddy/settings.json', warnings, 'mcpServers-only');
+    if (projectSettings) {
+        for (const [name, config] of Object.entries(projectSettings)) {
+            if (seenServers.has(name))
+                continue;
+            const serverConfig = resolveServerEnv({ ...config, name });
+            if (serverConfig.enabled !== false || options.includeDisabled) {
+                servers.push(serverConfig);
+            }
+            seenServers.add(name);
+        }
+    }
+    const userMCPPath = path.join(os.homedir(), '.codebuddy', 'mcp.json');
+    const userMCP = readOnlyServersFromFile(userMCPPath, 'user ~/.codebuddy/mcp.json', warnings, 'mcpServers-or-servers');
+    if (userMCP) {
+        for (const [name, config] of Object.entries(userMCP)) {
+            if (seenServers.has(name))
+                continue;
+            const serverConfig = resolveServerEnv({ ...config, name });
+            if (serverConfig.enabled !== false || options.includeDisabled) {
+                servers.push(serverConfig);
+            }
+            seenServers.add(name);
+        }
+    }
+    return { servers, warnings };
+}
 export function saveMCPConfig(config) {
     const manager = getSettingsManager();
     const mcpServers = {};
@@ -119,6 +235,46 @@ export function getMCPServer(serverName) {
     const projectSettings = manager.loadProjectSettings();
     return projectSettings.mcpServers?.[serverName];
 }
+function updateEnabledInJsonFile(filePath, serverName, enabled) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const parsed = readJsonAtomicSync(filePath, null);
+    if (!parsed)
+        return false;
+    const key = parsed.mcpServers && typeof parsed.mcpServers === 'object' ? 'mcpServers' : 'servers';
+    const servers = parsed[key];
+    if (!servers || typeof servers !== 'object' || Array.isArray(servers))
+        return false;
+    const record = servers;
+    const existing = record[serverName];
+    if (!existing || typeof existing !== 'object' || Array.isArray(existing))
+        return false;
+    record[serverName] = { ...existing, enabled };
+    writeJsonAtomicSync(filePath, parsed);
+    return true;
+}
+/** Update the highest-priority source that actually defines the server. */
+export function setMCPServerEnabled(serverName, enabled) {
+    const projectPath = path.join(process.cwd(), '.codebuddy', 'mcp.json');
+    if (updateEnabledInJsonFile(projectPath, serverName, enabled)) {
+        return { updated: true, source: 'project-mcp', path: projectPath };
+    }
+    const manager = getSettingsManager();
+    const settings = manager.loadProjectSettings();
+    const settingsServers = settings.mcpServers;
+    if (settingsServers?.[serverName]) {
+        manager.updateProjectSetting('mcpServers', {
+            ...settingsServers,
+            [serverName]: { ...settingsServers[serverName], enabled },
+        });
+        return { updated: true, source: 'project-settings' };
+    }
+    const userPath = path.join(os.homedir(), '.codebuddy', 'mcp.json');
+    if (updateEnabledInJsonFile(userPath, serverName, enabled)) {
+        return { updated: true, source: 'user-mcp', path: userPath };
+    }
+    return { updated: false };
+}
 // Predefined server configurations (disabled by default — user activates with API key)
 export const PREDEFINED_SERVERS = {
     'brave-search': {
@@ -173,7 +329,7 @@ export function saveProjectMCPConfig(servers) {
     const config = {
         mcpServers: servers
     };
-    fs.writeFileSync(projectMCPPath, JSON.stringify(config, null, 2));
+    writeJsonAtomicSync(projectMCPPath, config);
     return projectMCPPath;
 }
 /**
@@ -228,7 +384,7 @@ export function createMCPConfigTemplate() {
             }
         }
     };
-    fs.writeFileSync(projectMCPPath, JSON.stringify(template, null, 2));
+    writeJsonAtomicSync(projectMCPPath, template);
     return projectMCPPath;
 }
 /**

package/dist/mcp/import-normalize.d.ts

@@ -0,0 +1,12 @@
+import type { MCPServerConfig } from './types.js';
+export type MCPImportSource = 'hermes' | 'openclaw';
+export interface MCPImportResult {
+    servers: MCPServerConfig[];
+    warnings: string[];
+    rejected: string[];
+}
+/** Supported subset: exact names and star globs. Unsupported exclusions must never broaden exposure. */
+export declare function validateMCPToolFilter(filter: MCPServerConfig['toolFilter']): void;
+export declare function mcpToolAllowed(name: string, filter: MCPServerConfig['toolFilter']): boolean;
+/** Pure import: never resolve env, connect, run commands or transfer credentials. */
+export declare function normalizeMCPImports(input: unknown, source: MCPImportSource): MCPImportResult;

package/dist/mcp/import-normalize.js

@@ -0,0 +1,114 @@
+import { SECRET_PATTERNS } from '../security/secret-patterns.js';
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const sensitiveKey = /KEY|TOKEN|SECRET|PASSWORD|AUTHORIZATION|COOKIE/i;
+const reference = /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/;
+const hasSecret = (value) => SECRET_PATTERNS.some(p => new RegExp(p.pattern.source, p.pattern.flags.replace('g', '')).test(value));
+/** Supported subset: exact names and star globs. Unsupported exclusions must never broaden exposure. */
+export function validateMCPToolFilter(filter) {
+    if (!filter)
+        return;
+    for (const patterns of [filter.include, filter.exclude]) {
+        if (patterns !== undefined && (!Array.isArray(patterns) || patterns.some(p => typeof p !== 'string' || !/^[A-Za-z0-9_.:*-]+$/.test(p)))) {
+            throw new Error('Unsupported MCP tool filter; only names and * are supported');
+        }
+    }
+}
+export function mcpToolAllowed(name, filter) {
+    validateMCPToolFilter(filter);
+    const matches = (pattern) => new RegExp(`^${pattern.split('*').map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*')}$`).test(name);
+    return (!filter?.include || filter.include.some(matches)) && !filter?.exclude?.some(matches);
+}
+/** Pure import: never resolve env, connect, run commands or transfer credentials. */
+export function normalizeMCPImports(input, source) {
+    const result = { servers: [], warnings: [], rejected: [] };
+    if (!record(input)) {
+        result.rejected.push('MCP server map must be an object');
+        return result;
+    }
+    for (const [name, raw] of Object.entries(input)) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(name) || !record(raw)) {
+            result.rejected.push('Invalid MCP server entry');
+            continue;
+        }
+        const warn = (message) => result.warnings.push(`${name}: ${message}`);
+        try {
+            const clean = (key, value) => {
+                if (typeof value !== 'string')
+                    throw new Error('Expected string configuration value');
+                if (reference.test(value) || /^Bearer \$\{[A-Za-z_][A-Za-z0-9_]*\}$/i.test(value))
+                    return value;
+                if (sensitiveKey.test(key) || /^(?:--)?[^=]*(?:token|secret|password|authorization|api[_-]?key)[^=]*=/i.test(value) || hasSecret(value)) {
+                    const envName = `MCP_IMPORT_${name}_${key}`.replace(/[^A-Za-z0-9_]/g, '_').toUpperCase();
+                    warn(`secret not copied; configure environment ${envName}`);
+                    return '${' + envName + '}';
+                }
+                return value;
+            };
+            const map = (key) => {
+                if (raw[key] === undefined)
+                    return undefined;
+                if (!record(raw[key]))
+                    throw new Error(`Invalid ${key}`);
+                return Object.fromEntries(Object.entries(raw[key]).map(([k, v]) => [k, clean(`${key}_${k}`, v)]));
+            };
+            const type = raw.transport ?? raw.type;
+            let transport;
+            if (type === 'stdio' || (type === undefined && typeof raw.command === 'string')) {
+                if (typeof raw.command !== 'string' || !raw.command.trim())
+                    throw new Error('stdio requires command');
+                if (raw.args !== undefined && (!Array.isArray(raw.args) || raw.args.some(a => typeof a !== 'string')))
+                    throw new Error('Invalid args');
+                const args = (raw.args ?? []);
+                transport = { type: 'stdio', inheritEnv: false, command: clean('command', raw.command), args: args.map((v, i) => clean(sensitiveKey.test(args[i - 1] ?? '') ? `arg_secret_${i}` : `arg_${i}`, v)), env: map('env') };
+                if (raw.cwd !== undefined)
+                    transport.cwd = clean('cwd', raw.cwd);
+            }
+            else {
+                const mapped = type === undefined ? (source === 'hermes' ? 'streamable_http' : 'sse')
+                    : type === 'http' || type === 'streamable-http' || type === 'streamable_http' ? 'streamable_http'
+                        : type === 'sse' || type === 'sse_sdk' ? 'sse' : undefined;
+                if (!mapped)
+                    throw new Error('Unsupported transport');
+                if (typeof raw.url !== 'string')
+                    throw new Error('Remote transport requires URL');
+                if (!reference.test(raw.url)) {
+                    const url = new URL(raw.url);
+                    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash || url.search)
+                        throw new Error('Remote URL must not contain credentials, query or fragment; use environment reference');
+                }
+                transport = { type: mapped, url: raw.url, headers: map('headers') };
+                if (type === undefined && source === 'hermes')
+                    warn('streamable HTTP selected; implicit SSE fallback is not imported');
+            }
+            const server = { name, transport, enabled: raw.enabled !== false };
+            const filter = raw.toolFilter ?? raw.tool_filter ?? raw.tools;
+            if (filter !== undefined) {
+                if (!record(filter))
+                    throw new Error('Invalid tool filter');
+                const allowedKeys = filter === raw.tools ? ['include', 'exclude', 'resources', 'prompts'] : ['include', 'exclude'];
+                if (Object.keys(filter).some(key => !allowedKeys.includes(key)))
+                    throw new Error('Unsupported tool filter fields');
+                if (filter.resources !== undefined || filter.prompts !== undefined)
+                    warn('resource/prompt utilities are not imported; Buddy imports native tools only');
+                if (filter.include !== undefined || filter.exclude !== undefined) {
+                    server.toolFilter = { ...(filter.include !== undefined ? { include: typeof filter.include === 'string' ? [filter.include] : filter.include } : {}),
+                        ...(filter.exclude !== undefined ? { exclude: typeof filter.exclude === 'string' ? [filter.exclude] : filter.exclude } : {}) };
+                    validateMCPToolFilter(server.toolFilter);
+                    // OpenClaw treats an empty include as unrestricted, unlike Hermes.
+                    if (source === 'openclaw' && server.toolFilter.include?.length === 0)
+                        delete server.toolFilter.include;
+                }
+            }
+            if (raw.auth !== undefined || raw.oauth !== undefined) {
+                server.enabled = false;
+                warn('authentication settings not imported; server disabled until operator configures authentication in Buddy');
+            }
+            result.servers.push(server);
+        }
+        catch {
+            result.rejected.push(`${name}: unsupported or unsafe configuration; no values copied`);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=import-normalize.js.map

package/dist/mcp/index.d.ts

@@ -13,5 +13,5 @@ export { MCPManager } from "./client.js";
 export { MCPClient, MCPResource, getMCPClient, resetMCPClient, } from "./mcp-client.js";
 export { TransportType, TransportConfig, MCPTransport, StdioTransport, HttpTransport, SSETransport, StreamableHttpTransport, createTransport, } from "./transports.js";
 export { CodeBuddyMCPServer } from "./mcp-server.js";
-export type { MCPToolDefinition } from "./mcp-server.js";
+export type { CodeBuddyMCPServerOptions, MCPExposureSummary, MCPToolDefinition, MCPToolExposureStats, } from "./mcp-server.js";
 export { loadMCPConfig, saveMCPConfig, addMCPServer, removeMCPServer, getMCPServer, PREDEFINED_SERVERS, saveProjectMCPConfig, createMCPConfigTemplate, hasProjectMCPConfig, getMCPConfigPaths, } from "./config.js";

package/dist/mcp/mcp-agent-tools.d.ts

@@ -16,5 +16,5 @@ export declare function formatAgentResponse(entries: ChatEntry[]): string;
 /**
  * Register agent intelligence tools with the MCP server.
  */
-export declare function registerAgentTools(server: McpServer, getAgent: AgentGetter): void;
+export declare function registerAgentTools(server: McpServer, getAgent: AgentGetter, shouldRegister?: (name: string) => boolean): void;
 export {};

package/dist/mcp/mcp-agent-tools.js

@@ -56,87 +56,90 @@ export function formatAgentResponse(entries) {
 /**
  * Register agent intelligence tools with the MCP server.
  */
-export function registerAgentTools(server, getAgent) {
+export function registerAgentTools(server, getAgent, shouldRegister = () => true) {
     // agent_chat - Send message to agent, get response
-    server.tool('agent_chat', 'Send a message to the Code Buddy AI agent and get a response with tool call results. Use for conversational interactions.', {
-        message: z.string().describe('The message to send to the agent'),
-        mode: z.enum(['code', 'ask', 'plan', 'architect']).optional()
-            .describe('Agent mode: code (default), ask (no tools), plan (planning only), architect (design)'),
-    }, async (args) => {
-        try {
-            return await withLock(async () => {
-                const agent = await getAgent();
-                if (args.mode) {
-                    agent.agentMode = args.mode;
-                }
-                const entries = await agent.processUserMessage(args.message);
+    if (shouldRegister('agent_chat'))
+        server.tool('agent_chat', 'Send a message to the Code Buddy AI agent and get a response with tool call results. Use for conversational interactions.', {
+            message: z.string().describe('The message to send to the agent'),
+            mode: z.enum(['code', 'ask', 'plan', 'architect']).optional()
+                .describe('Agent mode: code (default), ask (no tools), plan (planning only), architect (design)'),
+        }, async (args) => {
+            try {
+                return await withLock(async () => {
+                    const agent = await getAgent();
+                    if (args.mode) {
+                        agent.agentMode = args.mode;
+                    }
+                    const entries = await agent.processUserMessage(args.message);
+                    return {
+                        content: [{ type: 'text', text: formatAgentResponse(entries) }],
+                    };
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
                 return {
-                    content: [{ type: 'text', text: formatAgentResponse(entries) }],
+                    content: [{ type: 'text', text: `Agent chat error: ${message}` }],
+                    isError: true,
                 };
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                content: [{ type: 'text', text: `Agent chat error: ${message}` }],
-                isError: true,
-            };
-        }
-    });
+            }
+        });
     // agent_task - Autonomous task execution
-    server.tool('agent_task', 'Execute an autonomous task using Code Buddy agent. For complex tasks, uses DAG-based planning; for simple tasks, processes directly. Returns all tool calls and results.', {
-        task: z.string().describe('The task to execute autonomously'),
-        working_directory: z.string().optional()
-            .describe('Working directory for task execution (defaults to cwd)'),
-    }, async (args) => {
-        try {
-            return await withLock(async () => {
-                const agent = await getAgent();
-                if (args.working_directory) {
-                    process.chdir(args.working_directory);
-                }
-                let entries;
-                if (agent.needsOrchestration(args.task)) {
-                    entries = await agent.executePlan(args.task);
-                }
-                else {
-                    entries = await agent.processUserMessage(args.task);
-                }
+    if (shouldRegister('agent_task'))
+        server.tool('agent_task', 'Execute an autonomous task using Code Buddy agent. For complex tasks, uses DAG-based planning; for simple tasks, processes directly. Returns all tool calls and results.', {
+            task: z.string().describe('The task to execute autonomously'),
+            working_directory: z.string().optional()
+                .describe('Working directory for task execution (defaults to cwd)'),
+        }, async (args) => {
+            try {
+                return await withLock(async () => {
+                    const agent = await getAgent();
+                    if (args.working_directory) {
+                        process.chdir(args.working_directory);
+                    }
+                    let entries;
+                    if (agent.needsOrchestration(args.task)) {
+                        entries = await agent.executePlan(args.task);
+                    }
+                    else {
+                        entries = await agent.processUserMessage(args.task);
+                    }
+                    return {
+                        content: [{ type: 'text', text: formatAgentResponse(entries) }],
+                    };
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
                 return {
-                    content: [{ type: 'text', text: formatAgentResponse(entries) }],
+                    content: [{ type: 'text', text: `Agent task error: ${message}` }],
+                    isError: true,
                 };
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                content: [{ type: 'text', text: `Agent task error: ${message}` }],
-                isError: true,
-            };
-        }
-    });
+            }
+        });
     // agent_plan - Create plan without executing
-    server.tool('agent_plan', 'Create an execution plan for a task without executing it. Returns the DAG-based task plan with dependencies.', {
-        task: z.string().describe('The task to plan'),
-    }, async (args) => {
-        try {
-            return await withLock(async () => {
-                const agent = await getAgent();
-                // Set plan mode so agent creates plan without executing
-                agent.agentMode = 'plan';
-                const entries = await agent.processUserMessage(args.task);
+    if (shouldRegister('agent_plan'))
+        server.tool('agent_plan', 'Create an execution plan for a task without executing it. Returns the DAG-based task plan with dependencies.', {
+            task: z.string().describe('The task to plan'),
+        }, async (args) => {
+            try {
+                return await withLock(async () => {
+                    const agent = await getAgent();
+                    // Set plan mode so agent creates plan without executing
+                    agent.agentMode = 'plan';
+                    const entries = await agent.processUserMessage(args.task);
+                    return {
+                        content: [{ type: 'text', text: formatAgentResponse(entries) }],
+                    };
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
                 return {
-                    content: [{ type: 'text', text: formatAgentResponse(entries) }],
+                    content: [{ type: 'text', text: `Agent plan error: ${message}` }],
+                    isError: true,
                 };
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                content: [{ type: 'text', text: `Agent plan error: ${message}` }],
-                isError: true,
-            };
-        }
-    });
+            }
+        });
 }
 //# sourceMappingURL=mcp-agent-tools.js.map

package/dist/mcp/mcp-ckg-tools.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCP CKG Tools — expose the Collective Knowledge Graph to any MCP client.
+ *
+ * WHY THIS FILE EXISTS
+ *
+ * `mcp-memory-tools.ts` already exposes `memory_search`/`memory_save`, but those
+ * reach the PER-SESSION persistent memory (`persistent-memory.ts`) — one agent's
+ * notes. The Collective Knowledge Graph is a different thing: the SHARED,
+ * cross-agent memory, with bi-temporal supersede, cross-agent corroboration (a
+ * fact several independent agents assert gains confidence) and hybrid recall
+ * (embeddings + keyword + salience + MMR, no LLM at retrieval time).
+ *
+ * Until now it had no MCP surface at all. Every fact the fleet had accumulated was
+ * invisible to Claude Desktop, ChatGPT, or any other MCP client — the exact
+ * "one memory shared between all your tools" promise, sitting behind no door.
+ * These two tools are that door.
+ *
+ * Tools:
+ * - ckg_recall: hybrid recall over the shared graph, corroboration included
+ * - ckg_ingest: contribute a fact/lesson/decision/discovery to the shared graph
+ *
+ * NOT gated by CODEBUDDY_COLLECTIVE_MEMORY: that flag governs AUTOMATIC injection
+ * into an agent's context, which must stay opt-in. An MCP tool is called
+ * deliberately by the client — declaring it changes nothing until someone invokes
+ * it, and an empty graph simply returns no results.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register Collective Knowledge Graph tools with the MCP server.
+ */
+export declare function registerCkgTools(server: McpServer, shouldRegister?: (name: string) => boolean): void;