@monoes/monomindcli 2.9.22 → 2.9.24

package/dist/src/commands/mcp.js

@@ -5,17 +5,21 @@
  * @module @monomind/cli/commands/mcp
  * @version 3.0.0
  */
+import { callMCPTool, hasTool, listMCPTools } from '../mcp-client.js';
+import { getMCPServerStatus, getServerManager } from '../mcp-server.js';
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
-import { getServerManager, getMCPServerStatus, } from '../mcp-server.js';
-import { listMCPTools, callMCPTool, hasTool } from '../mcp-client.js';
-// MCP tools categories
+// MCP tools categories — `value` must match the literal `category` field set
+// on registered MCPTool entries (see mcp-tools/*.ts), not the lazy-load
+// category key in mcp-client.ts's CATEGORY_LOADERS. Values that don't match
+// any tool's `category` field always return zero results from the real
+// registry (previously masked by a fabricated static fallback list).
 const TOOL_CATEGORIES = [
-    { value: 'coordination', label: 'Coordination', hint: 'Swarm and agent coordination tools' },
-    { value: 'monitoring', label: 'Monitoring', hint: 'Status and metrics monitoring' },
-    { value: 'memory', label: 'Memory', hint: 'Memory and neural features' },
+    { value: 'monoswarm', label: 'Coordination', hint: 'Monoswarm coordination tools' },
+    { value: 'performance', label: 'Monitoring', hint: 'Status and metrics monitoring' },
+    { value: 'knowledge', label: 'Memory', hint: 'Memory and neural features' },
     { value: 'github', label: 'GitHub', hint: 'GitHub integration tools' },
-    { value: 'system', label: 'System', hint: 'System and benchmark tools' }
+    { value: 'system', label: 'System', hint: 'System and benchmark tools' },
 ];
 /**
  * Format uptime for display
@@ -43,14 +47,14 @@ const startCommand = {
             short: 'p',
             description: 'Server port',
             type: 'number',
-            default: 3000
+            default: 3000,
         },
         {
             name: 'host',
             short: 'h',
             description: 'Server host',
             type: 'string',
-            default: 'localhost'
+            default: 'localhost',
         },
         {
             name: 'transport',
@@ -58,34 +62,34 @@ const startCommand = {
             description: 'Transport type (stdio, http, websocket)',
             type: 'string',
             default: 'stdio',
-            choices: ['stdio', 'http', 'websocket']
+            choices: ['stdio', 'http', 'websocket'],
         },
         {
             name: 'tools',
             description: 'Tools to enable (comma-separated or "all")',
             type: 'string',
-            default: 'all'
+            default: 'all',
         },
         {
             name: 'daemon',
             short: 'd',
             description: 'Run as background daemon',
             type: 'boolean',
-            default: false
+            default: false,
         },
         {
             name: 'force',
             short: 'f',
             description: 'Force restart (kill existing server first)',
             type: 'boolean',
-            default: false
-        }
+            default: false,
+        },
     ],
     examples: [
         { command: 'monomind mcp start', description: 'Start with defaults (stdio)' },
         { command: 'monomind mcp start -p 8080 -t http', description: 'Start HTTP server' },
         { command: 'monomind mcp start -d', description: 'Start as daemon' },
-        { command: 'monomind mcp start -f', description: 'Force restart (kill existing)' }
+        { command: 'monomind mcp start -f', description: 'Force restart (kill existing)' },
     ],
     action: async (ctx) => {
         const rawPort = ctx.flags.port ?? 3000;
@@ -165,20 +169,32 @@ const startCommand = {
             });
             // Start the server
             const status = await manager.start();
+            let toolsValue;
+            if (!tools || tools === 'all') {
+                // Report the real count of tools that will actually be advertised,
+                // rather than a hardcoded figure — this varies with MONOMIND_MCP_FULL
+                // and any disabled-tools config.
+                const registeredTools = await listMCPTools();
+                const enabledCount = registeredTools.filter((t) => t.enabled).length;
+                toolsValue = `${enabledCount} enabled`;
+            }
+            else {
+                toolsValue = `${tools.split(',').length} enabled`;
+            }
             output.writeln();
             output.printTable({
                 columns: [
                     { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 30 }
+                    { key: 'value', header: 'Value', width: 30 },
                 ],
                 data: [
                     { property: 'Server PID', value: status.pid || process.pid },
                     { property: 'Transport', value: transport },
                     { property: 'Host', value: host },
                     { property: 'Port', value: port },
-                    { property: 'Tools', value: !tools || tools === 'all' ? '27 enabled' : `${tools.split(',').length} enabled` },
-                    { property: 'Status', value: output.success('Running') }
-                ]
+                    { property: 'Tools', value: toolsValue },
+                    { property: 'Status', value: output.success('Running') },
+                ],
             });
             output.writeln();
             output.printSuccess('MCP Server started');
@@ -198,7 +214,7 @@ const startCommand = {
             output.printError(`Failed to start MCP server: ${error.message}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Stop MCP server
 const stopCommand = {
@@ -210,8 +226,8 @@ const stopCommand = {
             short: 'f',
             description: 'Force stop without graceful shutdown',
             type: 'boolean',
-            default: false
-        }
+            default: false,
+        },
     ],
     action: async (ctx) => {
         const force = ctx.flags.force;
@@ -224,7 +240,7 @@ const stopCommand = {
         if (!force && ctx.interactive) {
             const confirmed = await confirm({
                 message: `Stop MCP server (PID: ${status.pid})?`,
-                default: false
+                default: false,
             });
             if (!confirmed) {
                 output.printInfo('Operation cancelled');
@@ -247,7 +263,7 @@ const stopCommand = {
             output.printError(`Failed to stop MCP server: ${error.message}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // MCP status
 const statusCommand = {
@@ -283,11 +299,9 @@ const statusCommand = {
                 output.printTable({
                     columns: [
                         { key: 'metric', header: 'Metric', width: 20 },
-                        { key: 'value', header: 'Value', width: 20, align: 'right' }
+                        { key: 'value', header: 'Value', width: 20, align: 'right' },
                     ],
-                    data: [
-                        { metric: 'Status', value: output.error('Stopped') }
-                    ]
+                    data: [{ metric: 'Status', value: output.error('Stopped') }],
                 });
                 output.writeln();
                 output.writeln(output.dim('Run "monomind mcp start" to start the server'));
@@ -314,13 +328,13 @@ const statusCommand = {
                     metric: 'Health',
                     value: status.health.healthy
                         ? output.success('Healthy')
-                        : output.error(status.health.error || 'Unhealthy')
+                        : output.error(status.health.error || 'Unhealthy'),
                 });
                 if (status.health.metrics) {
                     for (const [key, value] of Object.entries(status.health.metrics)) {
                         displayData.push({
                             metric: `  ${key}`,
-                            value: String(value)
+                            value: String(value),
                         });
                     }
                 }
@@ -328,9 +342,9 @@ const statusCommand = {
             output.printTable({
                 columns: [
                     { key: 'metric', header: 'Metric', width: 20 },
-                    { key: 'value', header: 'Value', width: 25, align: 'right' }
+                    { key: 'value', header: 'Value', width: 25, align: 'right' },
                 ],
-                data: displayData
+                data: displayData,
             });
             return { success: true, data: status };
         }
@@ -338,7 +352,7 @@ const statusCommand = {
             output.printError(`Failed to get status: ${error.message}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // List tools
 const toolsCommand = {
@@ -350,65 +364,26 @@ const toolsCommand = {
             short: 'c',
             description: 'Filter by category',
             type: 'string',
-            choices: TOOL_CATEGORIES.map(c => c.value)
+            choices: TOOL_CATEGORIES.map((c) => c.value),
         },
         {
             name: 'enabled',
             description: 'Show only enabled tools',
             type: 'boolean',
-            default: false
-        }
+            default: false,
+        },
     ],
     action: async (ctx) => {
         const category = ctx.flags.category;
-        // Use local tool registry
-        let tools;
-        // Get tools from local registry
+        // Use local tool registry — no static fallback. If the registry can't be
+        // loaded, let the error propagate rather than showing a fabricated list.
         const registeredTools = await listMCPTools(category);
-        if (registeredTools.length > 0) {
-            tools = registeredTools.map(tool => ({
-                name: tool.name,
-                category: tool.category || 'uncategorized',
-                description: tool.description,
-                enabled: tool.enabled
-            }));
-        }
-        else {
-            // Fallback to static tool list
-            tools = [
-                // Agent tools
-                { name: 'agent_spawn', category: 'agent', description: 'Spawn a new agent', enabled: true },
-                { name: 'agent_list', category: 'agent', description: 'List all agents', enabled: true },
-                { name: 'agent_terminate', category: 'agent', description: 'Terminate an agent', enabled: true },
-                { name: 'agent_status', category: 'agent', description: 'Get agent status', enabled: true },
-                // Swarm tools
-                { name: 'swarm_init', category: 'swarm', description: 'Initialize swarm topology', enabled: true },
-                { name: 'swarm_status', category: 'swarm', description: 'Get swarm status', enabled: true },
-                { name: 'swarm_scale', category: 'swarm', description: 'Scale swarm size', enabled: true },
-                // Memory tools
-                { name: 'memory_store', category: 'memory', description: 'Store in memory', enabled: true },
-                { name: 'memory_search', category: 'memory', description: 'Search memory', enabled: true },
-                { name: 'memory_list', category: 'memory', description: 'List memory entries', enabled: true },
-                // Config tools
-                { name: 'config_load', category: 'config', description: 'Load configuration', enabled: true },
-                { name: 'config_save', category: 'config', description: 'Save configuration', enabled: true },
-                { name: 'config_validate', category: 'config', description: 'Validate configuration', enabled: true },
-                // Hooks tools
-                { name: 'hooks_pre-edit', category: 'hooks', description: 'Pre-edit hook', enabled: true },
-                { name: 'hooks_post-edit', category: 'hooks', description: 'Post-edit hook', enabled: true },
-                { name: 'hooks_pre-command', category: 'hooks', description: 'Pre-command hook', enabled: true },
-                { name: 'hooks_post-command', category: 'hooks', description: 'Post-command hook', enabled: true },
-                { name: 'hooks_route', category: 'hooks', description: 'Route task to agent', enabled: true },
-                { name: 'hooks_explain', category: 'hooks', description: 'Explain routing', enabled: true },
-                { name: 'hooks_pretrain', category: 'hooks', description: 'Pretrain from repo', enabled: true },
-                { name: 'hooks_metrics', category: 'hooks', description: 'Learning metrics', enabled: true },
-                { name: 'hooks_list', category: 'hooks', description: 'List hooks', enabled: true },
-                // System tools
-                { name: 'system_info', category: 'system', description: 'System information', enabled: true },
-                { name: 'system_health', category: 'system', description: 'Health status', enabled: true },
-                { name: 'system_metrics', category: 'system', description: 'Server metrics', enabled: true },
-            ].filter(t => !category || t.category === category);
-        }
+        const tools = registeredTools.map((tool) => ({
+            name: tool.name,
+            category: tool.category || 'uncategorized',
+            description: tool.description,
+            enabled: tool.enabled,
+        }));
         if (ctx.flags.format === 'json') {
             output.printJson(tools);
             return { success: true, data: tools };
@@ -416,6 +391,10 @@ const toolsCommand = {
         output.writeln();
         output.writeln(output.bold('Available MCP Tools'));
         output.writeln();
+        if (tools.length === 0) {
+            output.printInfo(category ? `0 tools matched category "${category}"` : '0 tools matched');
+            return { success: true, data: tools };
+        }
         // Group by category
         const grouped = tools.reduce((acc, tool) => {
             if (!acc[tool.category])
@@ -429,16 +408,21 @@ const toolsCommand = {
                 columns: [
                     { key: 'name', header: 'Tool', width: 25 },
                     { key: 'description', header: 'Description', width: 35 },
-                    { key: 'enabled', header: 'Status', width: 10, format: (v) => v ? output.success('Enabled') : output.dim('Disabled') }
+                    {
+                        key: 'enabled',
+                        header: 'Status',
+                        width: 10,
+                        format: (v) => v ? output.success('Enabled') : output.dim('Disabled'),
+                    },
                 ],
                 data: catTools,
-                border: false
+                border: false,
             });
             output.writeln();
         }
         output.printInfo(`Total: ${tools.length} tools`);
         return { success: true, data: tools };
-    }
+    },
 };
 // Enable/disable tools
 const toggleCommand = {
@@ -449,14 +433,14 @@ const toggleCommand = {
             name: 'enable',
             short: 'e',
             description: 'Enable tools',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'disable',
             short: 'd',
             description: 'Disable tools',
-            type: 'string'
-        }
+            type: 'string',
+        },
     ],
     action: async (ctx) => {
         const fs = await import('node:fs');
@@ -477,7 +461,7 @@ const toggleCommand = {
             return { success: false, exitCode: 1 };
         }
         if (disableArg) {
-            const tools = disableArg.split(',').map(t => t.trim());
+            const tools = disableArg.split(',').map((t) => t.trim());
             for (const t of tools) {
                 if (!disabled.includes(t))
                     disabled.push(t);
@@ -485,17 +469,17 @@ const toggleCommand = {
             output.printSuccess(`Disabled: ${tools.join(', ')}`);
         }
         if (enableArg) {
-            const tools = enableArg.split(',').map(t => t.trim());
-            disabled = disabled.filter(t => !tools.includes(t));
+            const tools = enableArg.split(',').map((t) => t.trim());
+            disabled = disabled.filter((t) => !tools.includes(t));
             output.printSuccess(`Enabled: ${tools.join(', ')}`);
         }
         fs.mkdirSync(path.dirname(stateFile), { recursive: true });
-        fs.writeFileSync(stateFile, JSON.stringify(disabled, null, 2) + '\n');
+        fs.writeFileSync(stateFile, `${JSON.stringify(disabled, null, 2)}\n`);
         output.writeln(output.dim(`State saved to ${stateFile}. ${disabled.length} tool(s) disabled.`));
         output.writeln(output.dim('Disabled tools are rejected immediately by direct CLI invocation.'));
         output.writeln(output.dim('An external MCP server (mcp start) must be restarted to stop exposing disabled tools to MCP clients.'));
         return { success: true };
-    }
+    },
 };
 // Execute tool
 const execCommand = {
@@ -507,17 +491,20 @@ const execCommand = {
             short: 't',
             description: 'Tool name',
             type: 'string',
-            required: true
+            required: true,
         },
         {
             name: 'params',
             short: 'p',
             description: 'Tool parameters (JSON)',
-            type: 'string'
-        }
+            type: 'string',
+        },
     ],
     examples: [
-        { command: 'monomind mcp exec -t swarm_init -p \'{"topology":"mesh"}\'', description: 'Execute tool' }
+        {
+            command: 'monomind mcp exec -t monoswarm_init -p \'{"topology":"mesh"}\'',
+            description: 'Execute tool',
+        },
     ],
     action: async (ctx) => {
         const tool = ctx.flags.tool || ctx.args[0];
@@ -531,7 +518,7 @@ const execCommand = {
             try {
                 params = JSON.parse(paramsStr);
             }
-            catch (e) {
+            catch (_e) {
                 output.printError('Invalid JSON parameters');
                 return { success: false, exitCode: 1 };
             }
@@ -542,7 +529,7 @@ const execCommand = {
         }
         try {
             // Execute through local MCP tool registry
-            if (!await hasTool(tool)) {
+            if (!(await hasTool(tool))) {
                 output.printError(`Tool not found: ${tool}`);
                 return { success: false, exitCode: 1 };
             }
@@ -568,7 +555,7 @@ const execCommand = {
             output.printError(`Tool execution failed: ${error.message}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Health check command
 const healthCommand = {
@@ -609,10 +596,10 @@ const healthCommand = {
             output.printError(`Health check failed: ${error.message}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Logs command
-const logsCommand = {
+export const logsCommand = {
     name: 'logs',
     description: 'Show MCP server logs',
     options: [
@@ -621,54 +608,134 @@ const logsCommand = {
             short: 'n',
             description: 'Number of lines',
             type: 'number',
-            default: 20
+            default: 20,
         },
         {
             name: 'follow',
             short: 'f',
             description: 'Follow log output',
             type: 'boolean',
-            default: false
+            default: false,
         },
         {
             name: 'level',
             description: 'Filter by log level',
             type: 'string',
-            choices: ['debug', 'info', 'warn', 'error']
-        }
+            choices: ['debug', 'info', 'warn', 'error'],
+        },
     ],
     action: async (ctx) => {
         const lines = ctx.flags.lines || 50;
+        const follow = ctx.flags.follow;
+        const levelFilter = ctx.flags.level?.toLowerCase();
         // Try to find and read the actual log file
-        const { existsSync, readFileSync, statSync } = await import('fs');
-        const { join } = await import('path');
+        const { existsSync, readFileSync, statSync, watch, createReadStream } = await import('node:fs');
+        const { join } = await import('node:path');
         const MAX_MCP_LOG_BYTES = 10 * 1024 * 1024; // 10 MB
         const logPaths = [
             join(ctx.cwd, '.monomind', 'logs', 'mcp-server.log'),
             join(ctx.cwd, '.monomind', 'logs', 'daemon.log'),
             join(ctx.cwd, '.monomind', 'mcp.log'),
         ];
-        const logFile = logPaths.find(p => existsSync(p) && statSync(p).size <= MAX_MCP_LOG_BYTES);
+        const logFile = logPaths.find((p) => existsSync(p) && statSync(p).size <= MAX_MCP_LOG_BYTES);
         output.writeln();
         output.writeln(output.bold('MCP Server Logs'));
         output.writeln(output.dim('─'.repeat(50)));
         if (!logFile) {
             output.writeln(output.dim('No log files found. Start the MCP server to generate logs.'));
-            output.writeln(output.dim(`Checked: ${logPaths.map(p => p.replace(ctx.cwd, '.')).join(', ')}`));
+            output.writeln(output.dim(`Checked: ${logPaths.map((p) => p.replace(ctx.cwd, '.')).join(', ')}`));
+            if (follow) {
+                output.printError('--follow requires an existing log file to watch — none was found.');
+                return { success: false };
+            }
             return { success: true };
         }
+        // Best-effort text match: log line formats vary (bracketed, "level:", JSON),
+        // so match the level as a whole word anywhere in the line rather than
+        // assuming one format.
+        const levelPattern = levelFilter ? new RegExp(`\\b${levelFilter}\\b`, 'i') : null;
+        const matchesLevel = (line) => !levelPattern || levelPattern.test(line);
         const content = readFileSync(logFile, 'utf8');
-        const logLines = content.trim().split('\n').filter(Boolean);
+        const logLines = content.trim().split('\n').filter(Boolean).filter(matchesLevel);
         const tail = logLines.slice(-lines);
         if (tail.length === 0) {
-            output.writeln(output.dim('Log file is empty.'));
+            output.writeln(output.dim(levelFilter
+                ? `Log file has no lines matching level "${levelFilter}".`
+                : 'Log file is empty.'));
+        }
+        else {
+            output.writeln(output.dim(`Showing last ${tail.length} lines from ${logFile.replace(ctx.cwd, '.')}` +
+                (levelFilter ? ` (level=${levelFilter})` : '')));
+            output.writeln();
+            tail.forEach((line) => output.writeln(line));
+        }
+        if (!follow) {
             return { success: true };
         }
-        output.writeln(output.dim(`Showing last ${tail.length} lines from ${logFile.replace(ctx.cwd, '.')}`));
+        // Real tail -f: watch the file for growth and stream newly appended lines,
+        // filtered the same way as the initial tail. Exits on Ctrl+C.
         output.writeln();
-        tail.forEach(line => output.writeln(line));
-        return { success: true };
-    }
+        output.writeln(output.dim('Following log output — press Ctrl+C to stop.'));
+        return new Promise((resolve) => {
+            let position = statSync(logFile).size;
+            let pendingPartialLine = '';
+            let reading = false;
+            const readNewData = () => {
+                if (reading)
+                    return;
+                reading = true;
+                let size;
+                try {
+                    size = statSync(logFile).size;
+                }
+                catch {
+                    reading = false;
+                    return;
+                }
+                if (size < position) {
+                    // File was truncated or rotated — restart from the beginning.
+                    position = 0;
+                    pendingPartialLine = '';
+                }
+                if (size <= position) {
+                    reading = false;
+                    return;
+                }
+                const stream = createReadStream(logFile, {
+                    start: position,
+                    end: size - 1,
+                    encoding: 'utf8',
+                });
+                let chunkData = '';
+                stream.on('data', (chunk) => {
+                    chunkData += chunk;
+                });
+                stream.on('end', () => {
+                    position = size;
+                    const combined = pendingPartialLine + chunkData;
+                    const parts = combined.split('\n');
+                    pendingPartialLine = parts.pop() ?? '';
+                    for (const line of parts) {
+                        if (line && matchesLevel(line))
+                            output.writeln(line);
+                    }
+                    reading = false;
+                });
+                stream.on('error', () => {
+                    reading = false;
+                });
+            };
+            const watcher = watch(logFile, { persistent: true }, (eventType) => {
+                if (eventType === 'change')
+                    readNewData();
+            });
+            const stop = () => {
+                watcher.close();
+                resolve({ success: true });
+            };
+            process.once('SIGINT', stop);
+        });
+    },
 };
 // Restart command
 const restartCommand = {
@@ -680,11 +747,11 @@ const restartCommand = {
             short: 'f',
             description: 'Force restart without graceful shutdown',
             type: 'boolean',
-            default: false
-        }
+            default: false,
+        },
     ],
     action: async (ctx) => {
-        const force = ctx.flags.force;
+        const _force = ctx.flags.force;
         output.printInfo('Restarting MCP Server...');
         try {
             const manager = getServerManager();
@@ -697,7 +764,7 @@ const restartCommand = {
             output.printError(`Failed to restart: ${error.message}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Verify subcommand — bridges the new-user "did the install actually work?" gap (P0-16).
 // Runs after `claude mcp add monomind -- npx -y monomind@latest mcp start` to give the
@@ -720,7 +787,11 @@ const verifyCommand = {
         try {
             const tools = await listMCPTools();
             toolCount = tools.length;
-            checks.push({ label: 'Tool registry', ok: toolCount > 0, detail: `${toolCount} tools registered` });
+            checks.push({
+                label: 'Tool registry',
+                ok: toolCount > 0,
+                detail: `${toolCount} tools registered`,
+            });
         }
         catch (e) {
             checks.push({ label: 'Tool registry', ok: false, detail: `error: ${e.message}` });
@@ -729,17 +800,29 @@ const verifyCommand = {
         const sampleTool = 'system_info';
         try {
             const has = await hasTool(sampleTool);
-            checks.push({ label: `Sample tool (${sampleTool})`, ok: has, detail: has ? 'resolves' : 'missing' });
+            checks.push({
+                label: `Sample tool (${sampleTool})`,
+                ok: has,
+                detail: has ? 'resolves' : 'missing',
+            });
         }
         catch (e) {
-            checks.push({ label: `Sample tool (${sampleTool})`, ok: false, detail: `error: ${e.message}` });
+            checks.push({
+                label: `Sample tool (${sampleTool})`,
+                ok: false,
+                detail: `error: ${e.message}`,
+            });
         }
         // 3. claude mcp list includes monomind (best-effort; skip if claude CLI missing)
         try {
             const { spawnSync } = await import('node:child_process');
             const result = spawnSync('claude', ['mcp', 'list'], { encoding: 'utf8', timeout: 5000 });
             if (result.error || result.status !== 0) {
-                checks.push({ label: 'claude mcp registration', ok: false, detail: 'claude CLI unavailable or returned non-zero — run `claude mcp add monomind -- npx -y monomind@latest mcp start` to register' });
+                checks.push({
+                    label: 'claude mcp registration',
+                    ok: false,
+                    detail: 'claude CLI unavailable or returned non-zero — run `claude mcp add monomind -- npx -y monomind@latest mcp start` to register',
+                });
             }
             else {
                 const listed = (result.stdout || '').toLowerCase();
@@ -747,12 +830,18 @@ const verifyCommand = {
                 checks.push({
                     label: 'claude mcp registration',
                     ok: registered,
-                    detail: registered ? 'monomind appears in `claude mcp list`' : 'monomind NOT in `claude mcp list` — run `claude mcp add monomind -- npx -y monomind@latest mcp start`',
+                    detail: registered
+                        ? 'monomind appears in `claude mcp list`'
+                        : 'monomind NOT in `claude mcp list` — run `claude mcp add monomind -- npx -y monomind@latest mcp start`',
                 });
             }
         }
         catch {
-            checks.push({ label: 'claude mcp registration', ok: false, detail: 'claude CLI not found — install Claude Code or register manually' });
+            checks.push({
+                label: 'claude mcp registration',
+                ok: false,
+                detail: 'claude CLI not found — install Claude Code or register manually',
+            });
         }
         // Render
         let allOk = true;
@@ -770,7 +859,7 @@ const verifyCommand = {
             output.printError('One or more checks failed. Fix the issues above and re-run `monomind mcp verify`.');
         }
         return { success: allOk, exitCode: allOk ? 0 : 1 };
-    }
+    },
 };
 // Main MCP command
 export const mcpCommand = {
@@ -791,13 +880,19 @@ export const mcpCommand = {
     options: [],
     examples: [
         { command: 'monomind mcp start', description: 'Start MCP server' },
-        { command: 'monomind mcp start -t http -p 8080', description: 'Start HTTP server on port 8080' },
+        {
+            command: 'monomind mcp start -t http -p 8080',
+            description: 'Start HTTP server on port 8080',
+        },
         { command: 'monomind mcp status', description: 'Show server status' },
         { command: 'monomind mcp tools', description: 'List tools' },
-        { command: 'monomind mcp verify', description: 'Verify the MCP server is reachable and tools respond' },
-        { command: 'monomind mcp stop', description: 'Stop the server' }
+        {
+            command: 'monomind mcp verify',
+            description: 'Verify the MCP server is reachable and tools respond',
+        },
+        { command: 'monomind mcp stop', description: 'Stop the server' },
     ],
-    action: async (ctx) => {
+    action: async (_ctx) => {
         output.writeln();
         output.writeln(output.bold('MCP Server Management'));
         output.writeln();
@@ -814,10 +909,10 @@ export const mcpCommand = {
             `${output.highlight('toggle')}   - Enable/disable tools`,
             `${output.highlight('exec')}     - Execute a tool`,
             `${output.highlight('logs')}     - Show server logs`,
-            `${output.highlight('verify')}   - Verify the MCP server is reachable and tools respond`
+            `${output.highlight('verify')}   - Verify the MCP server is reachable and tools respond`,
         ]);
         return { success: true };
-    }
+    },
 };
 export default mcpCommand;
 //# sourceMappingURL=mcp.js.map