monomind 1.18.13 → 1.19.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,253 +413,13 @@ 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
-        }
-    ],
-    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');
-            }
-            fs.renameSync(tmpPath, resolvedOutputPath);
-            spinner.succeed('Session exported');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 18 },
-                    { key: 'value', header: 'Value', width: 40 }
-                ],
-                data: [
-                    { property: 'Session ID', value: sessionId },
-                    { property: 'Output File', value: absolutePath },
-                    { property: 'Format', value: exportFormat.toUpperCase() },
-                    { 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) }
-                ]
-            });
-            output.writeln();
-            output.printSuccess(`Session exported to ${outputPath}`);
-            return {
-                success: true,
-                data: { sessionId, outputPath, format: exportFormat, size: content.length }
-            };
-        }
-        catch (error) {
-            spinner.fail('Failed to export session');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Import subcommand
-const importCommand = {
-    name: 'import',
-    description: 'Import session from file',
-    options: [
-        {
-            name: 'name',
-            short: 'n',
-            description: 'Session name for imported session',
-            type: 'string'
-        },
-        {
-            name: 'activate',
-            description: 'Activate session after import',
-            type: 'boolean',
-            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 };
-        }
-        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');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 35 }
-                ],
-                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' }
-                ]
-            });
-            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);
-            }
-            return { success: true, data: result };
-        }
-        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 };
-        }
-    }
-};
 // Current subcommand
 const currentCommand = {
     name: 'current',
     description: 'Show current active session',
     action: async (ctx) => {
         try {
-            const result = await callMCPTool('session_current', { includeStats: true });
+            const result = await callMCPTool('session_info', { includeStats: true });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
@@ -720,41 +477,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,8 +486,6 @@ export const sessionCommand = {
         saveCommand,
         restoreCommand,
         deleteCommand,
-        exportCommand,
-        importCommand,
         currentCommand
     ],
     options: [],
@@ -774,8 +494,6 @@ 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' }
     ],
     action: async (ctx) => {
@@ -791,8 +509,6 @@ 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.writeln();

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

@@ -98,15 +98,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 +118,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 +139,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 +197,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 +256,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

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

@@ -79,8 +79,13 @@ async function getSystemStatus() {
         catch {
             // MCP not running
         }
-        // Get memory status
-        const memoryStatus = await callMCPTool('memory_stats', {});
+        // Memory status — no MCP tool available; use defaults
+        const memoryStatus = {
+            entries: 0,
+            size: 0,
+            backend: 'lancedb',
+            performance: { avgSearchTime: 0, cacheHitRate: 0 },
+        };
         // Get task status
         const taskStatus = await callMCPTool('task_summary', {});
         return {
@@ -495,8 +500,17 @@ const memoryCommand = {
     name: 'memory',
     description: 'Show detailed memory status',
     action: async (ctx) => {
+        // memory_detailed-stats MCP tool is not registered; use memory bridge directly
         try {
-            const result = await callMCPTool('memory_detailed-stats', {});
+            const { bridgeListEntries } = await import('../memory/memory-bridge.js');
+            const listed = await bridgeListEntries({ limit: 10000 });
+            const entries = listed?.success ? listed.entries : [];
+            const totalBytes = entries.reduce((s, e) => s + (e.content || '').length, 0);
+            const result = {
+                backend: 'LanceDB',
+                entries: entries.length,
+                size: totalBytes,
+            };
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
@@ -513,37 +527,12 @@ const memoryCommand = {
                     { property: 'Backend', value: result.backend },
                     { property: 'Total Entries', value: result.entries.toLocaleString() },
                     { property: 'Storage Size', value: formatBytes(result.size) },
-                    { property: 'HNSW Index', value: result.performance.hnswEnabled ? 'Enabled' : 'Disabled' }
-                ]
-            });
-            output.writeln();
-            output.writeln(output.bold('Performance'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 20 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Avg Search Time', value: `${result.performance.avgSearchTime.toFixed(2)}ms` },
-                    { metric: 'Avg Write Time', value: `${result.performance.avgWriteTime.toFixed(2)}ms` },
-                    { metric: 'Cache Hit Rate', value: `${(result.performance.cacheHitRate * 100).toFixed(1)}%` }
                 ]
             });
-            output.writeln();
-            output.writeln(output.bold('v1 Performance Gains'));
-            output.printList([
-                `Search Speed: ${output.success(result.v1Gains.searchImprovement)}`,
-                `Memory Usage: ${output.success(result.v1Gains.memoryReduction)}`
-            ]);
             return { success: true, data: result };
         }
         catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to get memory status: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
+            output.printError(`Failed to get memory status: ${error instanceof Error ? error.message : String(error)}`);
             return { success: false, exitCode: 1 };
         }
     }

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

@@ -575,7 +575,7 @@ const stopCommand = {
         // Attempt MCP cleanup first — only persist 'stopped' state if it succeeds
         let mcpStopped = false;
         try {
-            await callMCPTool('swarm_stop', { swarmId, force });
+            await callMCPTool('swarm_shutdown', { swarmId, force });
             output.writeln(output.dim('  MCP swarm stopped'));
             mcpStopped = true;
         }

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

@@ -601,56 +601,11 @@ const assignCommand = {
         }
     }
 };
-// Retry subcommand
-const retryCommand = {
-    name: 'retry',
-    aliases: ['rerun'],
-    description: 'Retry a failed task',
-    options: [
-        {
-            name: 'reset-state',
-            description: 'Reset task state completely',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    action: async (ctx) => {
-        const taskId = (ctx.args[0] || '').slice(0, MAX_TASK_ID_LEN);
-        const resetState = ctx.flags['reset-state'];
-        if (!taskId) {
-            output.printError('Task ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('task_retry', {
-                taskId,
-                resetState
-            });
-            output.writeln();
-            output.printSuccess(`Task ${taskId} retried`);
-            output.printInfo(`New task ID: ${result.newTaskId}`);
-            output.printInfo(`Status: ${formatStatus(result.status)}`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to retry task: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 // Main task command
 export const taskCommand = {
     name: 'task',
     description: 'Task management commands',
-    subcommands: [createCommand, listCommand, statusCommand, cancelCommand, assignCommand, retryCommand],
+    subcommands: [createCommand, listCommand, statusCommand, cancelCommand, assignCommand],
     options: [],
     examples: [
         { command: 'monomind task create -t implementation -d "Add user auth"', description: 'Create a task' },
@@ -659,7 +614,6 @@ export const taskCommand = {
         { command: 'monomind task status task-123', description: 'Get task details' },
         { command: 'monomind task cancel task-123', description: 'Cancel a task' },
         { command: 'monomind task assign task-123 --agent coder-1', description: 'Assign task to agent' },
-        { command: 'monomind task retry task-123', description: 'Retry a failed task' }
     ],
     action: async (ctx) => {
         // Show help if no subcommand
@@ -674,8 +628,7 @@ export const taskCommand = {
             `${output.highlight('list')}    - List tasks`,
             `${output.highlight('status')}  - Get task details`,
             `${output.highlight('cancel')}  - Cancel a running task`,
-            `${output.highlight('assign')}  - Assign task to agent(s)`,
-            `${output.highlight('retry')}   - Retry a failed task`
+            `${output.highlight('assign')}  - Assign task to agent(s)`
         ]);
         output.writeln();
         output.writeln('Run "monomind task <subcommand> --help" for subcommand help');