monomind 1.18.15 → 2.0.0

package/packages/@monomind/cli/dist/src/commands/session.js

@@ -5,9 +5,6 @@
 import { output } from '../output.js';
 import { confirm, input, select } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { gzipSync } from 'node:zlib';
 // Format date for display
 function formatDate(dateStr) {
     const date = new Date(dateStr);
@@ -416,288 +413,184 @@ const deleteCommand = {
         }
     }
 };
-// Export subcommand
-const exportCommand = {
-    name: 'export',
-    description: 'Export session to file',
-    options: [
-        {
-            name: 'output',
-            short: 'o',
-            description: 'Output file path',
-            type: 'string'
-        },
-        {
-            name: 'format',
-            short: 'f',
-            description: 'Export format (json, yaml)',
-            type: 'string',
-            choices: ['json', 'yaml'],
-            default: 'json'
-        },
-        {
-            name: 'include-memory',
-            description: 'Include memory data',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'compress',
-            description: 'Compress output',
-            type: 'boolean',
-            default: false
-        }
-    ],
+// Current subcommand
+const currentCommand = {
+    name: 'current',
+    description: 'Show current active session',
     action: async (ctx) => {
-        let sessionId = ctx.args[0];
-        let outputPath = ctx.flags.output;
-        const exportFormat = ctx.flags.format;
-        const compress = ctx.flags.compress;
-        // Get current session if no ID provided
-        if (!sessionId) {
-            try {
-                const current = await callMCPTool('session_current', {});
-                sessionId = current.sessionId;
-            }
-            catch {
-                output.printError('No active session. Provide a session ID to export.');
-                return { success: false, exitCode: 1 };
-            }
-        }
-        // Generate output path if not provided
-        if (!outputPath) {
-            const ext = compress ? '.gz' : '';
-            outputPath = `session-${sessionId}.${exportFormat}${ext}`;
-        }
-        const spinner = output.createSpinner({ text: 'Exporting session...' });
-        spinner.start();
         try {
-            const result = await callMCPTool('session_export', {
-                sessionId,
-                includeMemory: ctx.flags['include-memory'] !== false
-            });
-            // Format output
-            let content;
-            if (exportFormat === 'yaml') {
-                content = toSimpleYaml(result.data);
-            }
-            else {
-                content = JSON.stringify(result.data, null, 2);
-            }
-            // Path traversal protection: resolved path must stay within CWD
-            const effectiveCwd = ctx.cwd || process.cwd();
-            const absolutePath = path.isAbsolute(outputPath)
-                ? outputPath
-                : path.join(effectiveCwd, outputPath);
-            const resolvedOutputPath = path.resolve(absolutePath);
-            const resolvedCwd = path.resolve(effectiveCwd);
-            if (!resolvedOutputPath.startsWith(resolvedCwd + path.sep) && resolvedOutputPath !== resolvedCwd) {
-                output.printError(`Output path must be within the working directory.`);
-                return { success: false, exitCode: 1 };
-            }
-            // Write atomically (tmp + rename) to avoid partial writes — use resolvedOutputPath
-            const tmpPath = `${resolvedOutputPath}.${process.pid}.${Date.now()}.tmp`;
-            if (compress) {
-                const compressed = gzipSync(Buffer.from(content, 'utf-8'));
-                fs.writeFileSync(tmpPath, compressed);
-            }
-            else {
-                fs.writeFileSync(tmpPath, content, 'utf-8');
+            const result = await callMCPTool('session_info', { includeStats: true });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
             }
-            fs.renameSync(tmpPath, resolvedOutputPath);
-            spinner.succeed('Session exported');
+            output.writeln();
+            output.writeln(output.bold('Current Session'));
             output.writeln();
             output.printTable({
                 columns: [
                     { key: 'property', header: 'Property', width: 18 },
-                    { key: 'value', header: 'Value', width: 40 }
+                    { key: 'value', header: 'Value', width: 35 }
                 ],
                 data: [
-                    { property: 'Session ID', value: sessionId },
-                    { property: 'Output File', value: absolutePath },
-                    { property: 'Format', value: exportFormat.toUpperCase() },
+                    { property: 'Session ID', value: result.sessionId },
+                    { property: 'Name', value: result.name || '-' },
+                    { property: 'Status', value: formatStatus(result.status) },
+                    { property: 'Started', value: new Date(result.startedAt).toLocaleString() },
+                    { property: 'Duration', value: formatDuration(result.stats.duration) },
                     { property: 'Agents', value: result.stats.agentCount },
                     { property: 'Tasks', value: result.stats.taskCount },
-                    { property: 'Memory Entries', value: result.stats.memoryEntries },
-                    { property: 'File Size', value: formatSize(content.length) }
+                    { property: 'Memory Entries', value: result.stats.memoryEntries }
                 ]
             });
-            output.writeln();
-            output.printSuccess(`Session exported to ${outputPath}`);
-            return {
-                success: true,
-                data: { sessionId, outputPath, format: exportFormat, size: content.length }
-            };
+            return { success: true, data: result };
         }
         catch (error) {
-            spinner.fail('Failed to export session');
             if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+                output.printWarning('No active session');
+                output.printInfo('Start a session with "monomind start"');
+                return { success: true, data: { active: false } };
             }
+            output.printError(`Unexpected error: ${String(error)}`);
             return { success: false, exitCode: 1 };
         }
     }
 };
-// Import subcommand
-const importCommand = {
-    name: 'import',
-    description: 'Import session from file',
+// Replay subcommand (session replay and inspection, merged from `replay` command)
+const replayShowCommand = {
+    name: 'show',
+    description: 'Show replay for a session',
     options: [
-        {
-            name: 'name',
-            short: 'n',
-            description: 'Session name for imported session',
-            type: 'string'
-        },
-        {
-            name: 'activate',
-            description: 'Activate session after import',
-            type: 'boolean',
-            default: false
-        }
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
     ],
     action: async (ctx) => {
-        const filePath = ctx.args[0];
-        const sessionName = ctx.flags.name;
-        const activate = ctx.flags.activate;
-        if (!filePath) {
-            output.printError('File path is required');
-            return { success: false, exitCode: 1 };
-        }
-        const absolutePath = path.isAbsolute(filePath)
-            ? filePath
-            : path.join(ctx.cwd, filePath);
-        // Path traversal protection: resolved path must stay within cwd or home
-        const resolvedPath = path.resolve(absolutePath);
-        const cwd = ctx.cwd || process.cwd();
-        const home = process.env.HOME || '';
-        const underCwd = resolvedPath === cwd || resolvedPath.startsWith(cwd + path.sep);
-        const underHome = home && (resolvedPath === home || resolvedPath.startsWith(home + path.sep));
-        if (!underCwd && !underHome) {
-            output.printError(`Path '${filePath}' escapes the allowed directories.`);
-            return { success: false, exitCode: 1 };
-        }
-        if (!fs.existsSync(absolutePath)) {
-            output.printError(`File not found: ${absolutePath}`);
-            return { success: false, exitCode: 1 };
-        }
-        // Reject oversized files before reading into memory
-        const MAX_IMPORT_BYTES = 50 * 1024 * 1024; // 50 MB
-        const stat = fs.statSync(absolutePath);
-        if (stat.size > MAX_IMPORT_BYTES) {
-            output.printError(`File too large: ${absolutePath} (${(stat.size / 1024 / 1024).toFixed(1)} MB > 50 MB limit)`);
-            return { success: false, exitCode: 1 };
+        // Cap session ID to prevent DoS via oversized string and unbounded output reflection.
+        const sessionId = (ctx.args[0] || '').slice(0, 128);
+        if (!sessionId) {
+            output.printError('Session ID is required: session replay show <sessionId>');
+            return { success: false, message: 'Missing session ID' };
         }
-        const spinner = output.createSpinner({ text: 'Importing session...' });
-        spinner.start();
         try {
-            const content = fs.readFileSync(absolutePath, 'utf-8');
-            let data;
-            // Parse based on extension
-            if (absolutePath.endsWith('.yaml') || absolutePath.endsWith('.yml')) {
-                output.printError('YAML import is not supported. Please convert to JSON first.');
-                spinner.fail('Import failed');
-                return { success: false, exitCode: 1 };
-            }
-            else {
-                data = JSON.parse(content, (key, value) => {
-                    if (key === '__proto__' || key === 'constructor' || key === 'prototype')
-                        return undefined;
-                    return value;
-                });
-            }
-            const result = await callMCPTool('session_import', {
-                data,
-                name: sessionName,
-                activate
-            });
-            spinner.succeed('Session imported');
+            const { ReplayReader } = await import('../observability/replay-reader.js');
+            const reader = new ReplayReader();
+            const data = await reader.show(sessionId);
+            if (!data) {
+                output.writeln(`No replay data for session ${sessionId}`);
+                return { success: true, message: 'No replay data' };
+            }
+            if (ctx.flags['json']) {
+                output.writeln(JSON.stringify(data, null, 2));
+                return { success: true, data };
+            }
+            // Human-readable summary derived from the session replay data
+            const started = new Date(data.startedAt);
+            const ended = data.endedAt ? new Date(data.endedAt) : null;
+            const duration = ended && !isNaN(started.getTime()) && !isNaN(ended.getTime())
+                ? formatDuration(ended.getTime() - started.getTime())
+                : 'in progress';
+            output.writeln();
+            output.writeln(output.bold(`Replay: ${data.id}`));
             output.writeln();
             output.printTable({
                 columns: [
-                    { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 35 }
+                    { key: 'property', header: 'Property', width: 18 },
+                    { key: 'value', header: 'Value', width: 45 }
                 ],
                 data: [
-                    { property: 'Session ID', value: result.sessionId },
-                    { property: 'Name', value: result.name },
-                    { property: 'Source File', value: path.basename(absolutePath) },
-                    { property: 'Agents Imported', value: result.stats.agentsImported },
-                    { property: 'Tasks Imported', value: result.stats.tasksImported },
-                    { property: 'Memory Entries', value: result.stats.memoryEntriesImported },
-                    { property: 'Activated', value: result.activated ? 'Yes' : 'No' }
+                    { property: 'Started', value: isNaN(started.getTime()) ? data.startedAt : started.toLocaleString() },
+                    { property: 'Ended', value: ended ? ended.toLocaleString() : '-' },
+                    { property: 'Duration', value: duration },
+                    { property: 'Tasks', value: data.taskCount != null ? String(data.taskCount) : '-' },
+                    { property: 'Tokens', value: data.tokenUsage?.total != null ? String(data.tokenUsage.total) : '-' },
+                    { property: 'File', value: data.filePath }
                 ]
             });
-            output.writeln();
-            output.printSuccess(`Session imported: ${result.sessionId}`);
-            if (!result.activated) {
-                output.printInfo(`Restore with: monomind session restore ${result.sessionId}`);
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
+            // Key steps: surface recorded metrics from the raw session data if present
+            const metrics = data.raw?.metrics;
+            if (metrics && typeof metrics === 'object') {
+                const entries = Object.entries(metrics)
+                    .filter(([, v]) => typeof v === 'number' || typeof v === 'string');
+                if (entries.length > 0) {
+                    output.writeln();
+                    output.writeln(output.bold('Metrics'));
+                    output.printList(entries.map(([k, v]) => `${k}: ${String(v)}`));
+                }
             }
-            return { success: true, data: result };
+            return { success: true, data };
         }
-        catch (error) {
-            spinner.fail('Failed to import session');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else if (error instanceof SyntaxError) {
-                output.printError('Invalid file format. Expected JSON or YAML.');
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
+        catch {
+            output.writeln(`No replay data for session ${sessionId}`);
+            return { success: true, message: 'No replay data' };
         }
-    }
+    },
 };
-// Current subcommand
-const currentCommand = {
-    name: 'current',
-    description: 'Show current active session',
+const replayListCommand = {
+    name: 'list',
+    description: 'List available session replays',
+    options: [
+        { name: 'limit', short: 'n', type: 'number', description: 'Max entries', default: 20 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
     action: async (ctx) => {
         try {
-            const result = await callMCPTool('session_current', { includeStats: true });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
+            const { ReplayReader } = await import('../observability/replay-reader.js');
+            const reader = new ReplayReader();
+            const rawLimit = ctx.flags['limit'];
+            // Cap limit to prevent DoS
+            const limit = typeof rawLimit === 'number' && Number.isFinite(rawLimit)
+                ? Math.max(1, Math.min(Math.floor(rawLimit), 500))
+                : 20;
+            const data = await reader.list(limit);
+            if (ctx.flags['json']) {
+                output.writeln(JSON.stringify(data, null, 2));
+                return { success: true, data };
+            }
+            if (data.length === 0) {
+                output.writeln('No replay sessions available');
+                return { success: true, data };
             }
             output.writeln();
-            output.writeln(output.bold('Current Session'));
+            output.writeln(output.bold(`Session Replays (${data.length})`));
             output.writeln();
             output.printTable({
                 columns: [
-                    { key: 'property', header: 'Property', width: 18 },
-                    { key: 'value', header: 'Value', width: 35 }
+                    { key: 'id', header: 'ID', width: 26 },
+                    { key: 'started', header: 'Started', width: 20 },
+                    { key: 'ended', header: 'Ended', width: 20 },
+                    { key: 'tasks', header: 'Tasks', width: 8, align: 'right' }
                 ],
-                data: [
-                    { property: 'Session ID', value: result.sessionId },
-                    { property: 'Name', value: result.name || '-' },
-                    { property: 'Status', value: formatStatus(result.status) },
-                    { property: 'Started', value: new Date(result.startedAt).toLocaleString() },
-                    { property: 'Duration', value: formatDuration(result.stats.duration) },
-                    { property: 'Agents', value: result.stats.agentCount },
-                    { property: 'Tasks', value: result.stats.taskCount },
-                    { property: 'Memory Entries', value: result.stats.memoryEntries }
-                ]
+                data: data.map(s => ({
+                    id: s.id,
+                    started: formatDate(s.startedAt),
+                    ended: s.endedAt ? formatDate(s.endedAt) : '-',
+                    tasks: s.taskCount != null ? String(s.taskCount) : '-'
+                }))
             });
-            return { success: true, data: result };
+            output.writeln();
+            output.printInfo('Show details with: monomind session replay show <sessionId>');
+            return { success: true, data };
         }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printWarning('No active session');
-                output.printInfo('Start a session with "monomind start"');
-                return { success: true, data: { active: false } };
-            }
-            output.printError(`Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
+        catch {
+            output.writeln('No replay sessions available');
+            return { success: true, message: 'No sessions' };
         }
-    }
+    },
+};
+const replayCommand = {
+    name: 'replay',
+    description: 'Session replay and inspection',
+    subcommands: [replayShowCommand, replayListCommand],
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('Session Replay'));
+        output.writeln();
+        output.writeln('Usage: monomind session replay <show|list> [options]');
+        output.printList([
+            `${output.highlight('show <sessionId>')} - Show replay for a session`,
+            `${output.highlight('list')}             - List available session replays`
+        ]);
+        return { success: true };
+    },
 };
 // Helper functions
 function formatSize(bytes) {
@@ -720,41 +613,6 @@ function formatDuration(ms) {
     }
     return `${seconds}s`;
 }
-function toSimpleYaml(obj, indent = 0) {
-    // Simple YAML serializer (for basic types)
-    if (obj === null)
-        return 'null';
-    if (typeof obj === 'boolean')
-        return String(obj);
-    if (typeof obj === 'number')
-        return String(obj);
-    if (typeof obj === 'string') {
-        const needsQuoting = /[:"'\n\r\\]|^(true|false|null|yes|no|on|off)$/i.test(obj) || /^\s|\s$/.test(obj) || /^[!&|>{\[]/.test(obj);
-        if (needsQuoting)
-            return `"${obj.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-        return obj;
-    }
-    const spaces = '  '.repeat(indent);
-    let result = '';
-    if (Array.isArray(obj)) {
-        for (const item of obj) {
-            result += `${spaces}- ${toSimpleYaml(item, indent + 1).trim()}\n`;
-        }
-        return result;
-    }
-    if (typeof obj === 'object') {
-        for (const [key, value] of Object.entries(obj)) {
-            if (typeof value === 'object' && value !== null) {
-                result += `${spaces}${key}:\n${toSimpleYaml(value, indent + 1)}`;
-            }
-            else {
-                result += `${spaces}${key}: ${toSimpleYaml(value, indent)}\n`;
-            }
-        }
-        return result;
-    }
-    return String(obj);
-}
 // Main session command
 export const sessionCommand = {
     name: 'session',
@@ -764,9 +622,8 @@ export const sessionCommand = {
         saveCommand,
         restoreCommand,
         deleteCommand,
-        exportCommand,
-        importCommand,
-        currentCommand
+        currentCommand,
+        replayCommand
     ],
     options: [],
     examples: [
@@ -774,9 +631,9 @@ export const sessionCommand = {
         { command: 'monomind session save -n "checkpoint-1"', description: 'Save current session' },
         { command: 'monomind session restore session-123', description: 'Restore a session' },
         { command: 'monomind session delete session-123', description: 'Delete a session' },
-        { command: 'monomind session export -o backup.json', description: 'Export session to file' },
-        { command: 'monomind session import backup.json', description: 'Import session from file' },
-        { command: 'monomind session current', description: 'Show current session' }
+        { command: 'monomind session current', description: 'Show current session' },
+        { command: 'monomind session replay list', description: 'List available session replays' },
+        { command: 'monomind session replay show session-123', description: 'Show replay for a session' }
     ],
     action: async (ctx) => {
         // Show help if no subcommand
@@ -791,9 +648,8 @@ export const sessionCommand = {
             `${output.highlight('save')}    - Save current session state`,
             `${output.highlight('restore')} - Restore a saved session`,
             `${output.highlight('delete')}  - Delete a saved session`,
-            `${output.highlight('export')}  - Export session to file`,
-            `${output.highlight('import')}  - Import session from file`,
-            `${output.highlight('current')} - Show current active session`
+            `${output.highlight('current')} - Show current active session`,
+            `${output.highlight('replay')}  - Session replay and inspection (show, list)`
         ]);
         output.writeln();
         output.writeln('Run "monomind session <subcommand> --help" for subcommand help');

package/packages/@monomind/cli/dist/src/commands/start.js

@@ -8,7 +8,6 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 // Default configuration
-const DEFAULT_PORT = 3000;
 const DEFAULT_TOPOLOGY = 'hierarchical-mesh';
 const DEFAULT_MAX_AGENTS = 15;
 // Check if project is initialized
@@ -85,9 +84,7 @@ function loadConfig(cwd) {
 // Main start action
 const startAction = async (ctx) => {
     const daemon = ctx.flags.daemon;
-    const port = ctx.flags.port;
     const topology = ctx.flags.topology;
-    const skipMcp = ctx.flags['skip-mcp'];
     const cwd = ctx.cwd;
     // Check initialization
     if (!isInitialized(cwd)) {
@@ -98,15 +95,11 @@ const startAction = async (ctx) => {
     // Load configuration
     const config = loadConfig(cwd);
     const swarmConfig = config?.swarm || {};
-    const mcpConfig = config?.mcp || {};
     const VALID_TOPOLOGIES = new Set(['hierarchical-mesh', 'mesh', 'hierarchical', 'ring', 'star']);
     const rawTopology = topology || swarmConfig.topology || DEFAULT_TOPOLOGY;
     const finalTopology = VALID_TOPOLOGIES.has(rawTopology) ? rawTopology : DEFAULT_TOPOLOGY;
     const rawMaxAgents = Number(swarmConfig.maxAgents || DEFAULT_MAX_AGENTS);
     const maxAgents = Number.isFinite(rawMaxAgents) ? Math.max(1, Math.min(rawMaxAgents, 100)) : DEFAULT_MAX_AGENTS;
-    const autoStartMcp = mcpConfig.autoStart !== false && !skipMcp;
-    const rawMcpPort = port || Number(mcpConfig.serverPort) || DEFAULT_PORT;
-    const mcpPort = Number.isFinite(rawMcpPort) ? Math.max(1, Math.min(rawMcpPort, 65535)) : DEFAULT_PORT;
     output.writeln();
     output.writeln(output.bold('Starting Monomind'));
     output.writeln();
@@ -122,28 +115,7 @@ const startAction = async (ctx) => {
             v1Mode: true
         });
         spinner.succeed(`Swarm initialized (${finalTopology})`);
-        // Step 2: Start MCP server if configured
-        let mcpResult = null;
-        if (autoStartMcp) {
-            spinner.setText('Starting MCP server...');
-            spinner.start();
-            try {
-                mcpResult = await callMCPTool('mcp_start', {
-                    port: mcpPort,
-                    transport: mcpConfig.transportType || 'stdio',
-                    tools: mcpConfig.tools || ['agent', 'swarm', 'memory', 'task']
-                });
-                spinner.succeed(`MCP server started on port ${mcpPort}`);
-            }
-            catch (error) {
-                spinner.fail('MCP server failed to start');
-                output.printWarning(error instanceof MCPClientError
-                    ? error.message
-                    : String(error));
-                // Continue without MCP
-            }
-        }
-        // Step 3: Run health check
+        // Step 2: Run health check
         spinner.setText('Running health checks...');
         spinner.start();
         const healthResult = await callMCPTool('swarm_health', {
@@ -164,7 +136,6 @@ const startAction = async (ctx) => {
             `Swarm ID:  ${swarmResult.swarmId}`,
             `Topology:  ${finalTopology}`,
             `Max Agents: ${maxAgents}`,
-            `MCP Server: ${autoStartMcp ? `localhost:${mcpPort}` : 'disabled'}`,
             `Mode:      ${daemon ? 'Daemon' : 'Foreground'}`,
             `Health:    ${healthResult.status}`
         ].join('\n'), 'System Status');
@@ -223,10 +194,6 @@ const startAction = async (ctx) => {
             swarmId: swarmResult.swarmId,
             topology: finalTopology,
             maxAgents,
-            mcp: mcpResult ? {
-                port: mcpPort,
-                transport: mcpConfig.transportType || 'stdio'
-            } : null,
             health: healthResult.status,
             daemon,
             startedAt: new Date().toISOString()
@@ -286,20 +253,11 @@ const stopCommand = {
         const spinner = output.createSpinner({ text: 'Stopping system...' });
         spinner.start();
         try {
-            // Stop MCP server
-            spinner.setText('Stopping MCP server...');
-            try {
-                await callMCPTool('mcp_stop', { graceful: !force, timeout });
-                spinner.succeed('MCP server stopped');
-            }
-            catch {
-                spinner.fail('MCP server was not running');
-            }
             // Stop swarm
             spinner.setText('Stopping swarm...');
             spinner.start();
             try {
-                await callMCPTool('swarm_stop', {
+                await callMCPTool('swarm_shutdown', {
                     graceful: !force,
                     timeout,
                     saveState: true
@@ -403,33 +361,18 @@ export const startCommand = {
             type: 'boolean',
             default: false
         },
-        {
-            name: 'port',
-            short: 'p',
-            description: 'MCP server port',
-            type: 'number',
-            default: DEFAULT_PORT
-        },
         {
             name: 'topology',
             short: 't',
             description: 'Swarm topology (hierarchical-mesh, mesh, hierarchical, ring, star)',
             type: 'string',
             choices: ['hierarchical-mesh', 'mesh', 'hierarchical', 'ring', 'star']
-        },
-        {
-            name: 'skip-mcp',
-            description: 'Skip starting MCP server',
-            type: 'boolean',
-            default: false
         }
     ],
     examples: [
         { command: 'monomind start', description: 'Start with configuration defaults' },
         { command: 'monomind start --daemon', description: 'Start as background daemon' },
-        { command: 'monomind start --port 3001', description: 'Start MCP on custom port' },
         { command: 'monomind start --topology mesh', description: 'Start with mesh topology' },
-        { command: 'monomind start --skip-mcp', description: 'Start without MCP server' },
         { command: 'monomind start quick', description: 'Quick start with defaults' },
         { command: 'monomind start stop', description: 'Stop the running system' }
     ],