monomind 1.8.0 → 1.9.1

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

@@ -65,8 +65,9 @@ const commandLoaders = {
     'transfer-store': () => import('./transfer-store.js'),
     cleanup: () => import('./cleanup.js'),
     autopilot: () => import('./autopilot.js'),
-    ui: () => import('./ui.js'),
     tokens: () => import('./tokens.js'),
+    monograph: () => import('./monograph.js'),
+    replay: () => import('./replay.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();
@@ -138,7 +139,11 @@ import { guidanceCommand } from './guidance.js';
 import { applianceCommand } from './appliance.js';
 import { cleanupCommand } from './cleanup.js';
 import { autopilotCommand } from './autopilot.js';
-import uiCommand from './ui.js';
+import { monographCommand } from './monograph.js';
+import replayCommand from './replay.js';
+import { benchmarkCommand } from './benchmark.js';
+import storeCommand from './transfer-store.js';
+import tokensCommand from './tokens.js';
 // Pre-populate cache with core commands
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -161,7 +166,11 @@ loadedCommands.set('hive-mind', hiveMindCommand);
 loadedCommands.set('guidance', guidanceCommand);
 loadedCommands.set('cleanup', cleanupCommand);
 loadedCommands.set('autopilot', autopilotCommand);
-loadedCommands.set('ui', uiCommand);
+loadedCommands.set('monograph', monographCommand);
+loadedCommands.set('replay', replayCommand);
+loadedCommands.set('benchmark', benchmarkCommand);
+loadedCommands.set('transfer-store', storeCommand);
+loadedCommands.set('tokens', tokensCommand);
 // =============================================================================
 // Exports (maintain backwards compatibility)
 // =============================================================================
@@ -188,7 +197,7 @@ export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
 export { cleanupCommand } from './cleanup.js';
 export { autopilotCommand } from './autopilot.js';
-export { default as uiCommand } from './ui.js';
+export { monographCommand } from './monograph.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
 export async function getConfigCommand() { return loadCommand('config'); }
 export async function getMigrateCommand() { return loadCommand('migrate'); }
@@ -215,6 +224,7 @@ export async function getGuidanceCommand() { return loadCommand('guidance'); }
 export async function getApplianceCommand() { return loadCommand('appliance'); }
 export async function getCleanupCommand() { return loadCommand('cleanup'); }
 export async function getAutopilotCommand() { return loadCommand('autopilot'); }
+export async function getMonographCommand() { return loadCommand('monograph'); }
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup
@@ -242,7 +252,7 @@ export const commands = [
     guidanceCommand,
     cleanupCommand,
     autopilotCommand,
-    uiCommand,
+    monographCommand,
 ];
 /**
  * Commands organized by category for help display
@@ -252,7 +262,6 @@ export const commandsByCategory = {
         initCommand,
         startCommand,
         statusCommand,
-        uiCommand,
         agentCommand,
         swarmCommand,
         memoryCommand,
@@ -270,6 +279,7 @@ export const commandsByCategory = {
         ruvectorCommand,
         guidanceCommand,
         autopilotCommand,
+        benchmarkCommand,
     ],
     utility: [
         configCommand,
@@ -283,6 +293,9 @@ export const commandsByCategory = {
         analyzeCommand,
         routeCommand,
         progressCommand,
+        monographCommand,
+        replayCommand,
+        tokensCommand,
     ],
     management: [
         providersCommand,
@@ -293,7 +306,7 @@ export const commandsByCategory = {
         updateCommand,
         processCommand,
         applianceCommand,
-        cleanupCommand,
+        storeCommand,
     ],
 };
 /**

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

@@ -52,8 +52,15 @@ const initAction = async (ctx) => {
     output.writeln();
     // Build init options based on flags
     let options;
-    const base = minimal ? MINIMAL_INIT_OPTIONS : full ? FULL_INIT_OPTIONS : DEFAULT_INIT_OPTIONS;
-    options = { ...base, targetDir: cwd, force, components: { ...base.components } };
+    if (minimal) {
+        options = { ...MINIMAL_INIT_OPTIONS, targetDir: cwd, force };
+    }
+    else if (full) {
+        options = { ...FULL_INIT_OPTIONS, targetDir: cwd, force };
+    }
+    else {
+        options = { ...DEFAULT_INIT_OPTIONS, targetDir: cwd, force };
+    }
     // Handle --skip-claude and --only-claude flags
     if (skipClaude) {
         options.components.settings = false;
@@ -82,6 +89,23 @@ const initAction = async (ctx) => {
             return { success: false, exitCode: 1 };
         }
         spinner.succeed('Monomind initialized successfully!');
+        // Trigger background monograph build + continuous watch
+        try {
+            const { spawn } = await import('child_process');
+            for (const args of [
+                ['monograph', 'build', '--code-only'],
+                ['monograph', 'watch'],
+            ]) {
+                const proc = spawn(process.execPath, [process.argv[1], ...args], {
+                    detached: true, stdio: 'ignore', cwd: ctx.cwd, env: process.env,
+                });
+                proc.unref();
+            }
+            output.printInfo('◈ Building knowledge graph in background… (watch mode active)');
+        }
+        catch {
+            // non-critical
+        }
         output.writeln();
         // Display summary
         const summary = [];
@@ -129,12 +153,12 @@ const initAction = async (ctx) => {
         if (startDaemon || startAll) {
             output.writeln();
             output.printInfo('Starting services...');
-            const { execSync } = await import('child_process');
+            const { execSync, spawn: spawnChild } = await import('child_process');
             // Initialize memory database
             if (startAll) {
                 try {
                     output.writeln(output.dim('  Initializing memory database...'));
-                    execSync('npx @monoes/cli@latest memory init 2>/dev/null', {
+                    execSync('npx @monomind/cli@latest memory init', {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
                         timeout: 30000
@@ -149,11 +173,8 @@ const initAction = async (ctx) => {
             if (startDaemon) {
                 try {
                     output.writeln(output.dim('  Starting daemon...'));
-                    execSync('npx @monoes/cli@latest daemon start 2>/dev/null &', {
-                        stdio: 'pipe',
-                        cwd: ctx.cwd,
-                        timeout: 10000
-                    });
+                    const daemonProc = spawnChild(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['@monomind/cli@latest', 'daemon', 'start'], { stdio: 'ignore', detached: true, cwd: ctx.cwd });
+                    daemonProc.unref();
                     output.writeln(output.success('  ✓ Daemon started'));
                 }
                 catch {
@@ -164,7 +185,7 @@ const initAction = async (ctx) => {
             if (startAll) {
                 try {
                     output.writeln(output.dim('  Initializing swarm...'));
-                    execSync('npx @monoes/cli@latest swarm init --topology hierarchical 2>/dev/null', {
+                    execSync('npx @monomind/cli@latest swarm init --topology hierarchical', {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
                         timeout: 30000
@@ -184,11 +205,16 @@ const initAction = async (ctx) => {
         if (withEmbeddings) {
             output.writeln();
             output.printInfo('Initializing ONNX embedding subsystem...');
-            const { execSync } = await import('child_process');
+            const ALLOWED_MODELS = /^[\w\-./]+$/;
+            if (!ALLOWED_MODELS.test(embeddingModel)) {
+                output.writeln(output.error('Invalid model identifier. Only alphanumeric characters, hyphens, dots, and slashes are allowed.'));
+                return { success: false, exitCode: 1 };
+            }
+            const { execFileSync } = await import('child_process');
             try {
                 output.writeln(output.dim(`  Model: ${embeddingModel}`));
                 output.writeln(output.dim('  Hyperbolic: Enabled (Poincaré ball)'));
-                execSync(`npx @monoes/cli@latest embeddings init --model ${embeddingModel} --no-download --force 2>/dev/null`, {
+                execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['@monomind/cli@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
                     stdio: 'pipe',
                     cwd: ctx.cwd,
                     timeout: 30000
@@ -211,6 +237,13 @@ const initAction = async (ctx) => {
                 options.components.settings ? `Review ${output.highlight('.claude/settings.json')} for hook configurations` : '',
             ].filter(Boolean));
         }
+        // Recommend UA semantic enrichment
+        output.writeln('');
+        output.writeln(output.bold('Tip: Enrich your knowledge graph with semantic summaries'));
+        output.writeln(output.dim('  Run /monomind:understand in Claude Code to analyze your project'));
+        output.writeln(output.dim('  and add LLM-generated summaries, tags, and architectural layers'));
+        output.writeln(output.dim(`  to the monograph graph. This gives Claude Code a richer mental`));
+        output.writeln(output.dim(`  model of your codebase from the very first session.`));
         if (ctx.flags.format === 'json') {
             output.printJson(result);
         }
@@ -285,13 +318,11 @@ const wizardCommand = {
                             { value: 'core', label: 'Core', hint: 'Swarm, memory, SPARC skills', selected: true },
                             { value: 'agentdb', label: 'AgentDB', hint: 'Vector database skills', selected: true },
                             { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
-                            { value: 'v1', label: 'v1', hint: 'v1 implementation skills', selected: true },
                         ],
                     });
                     options.skills.core = skillSets.includes('core');
                     options.skills.agentdb = skillSets.includes('agentdb');
                     options.skills.github = skillSets.includes('github');
-                    options.skills.v1 = skillSets.includes('v1');
                 }
                 // Hooks selection
                 if (options.components.settings) {
@@ -409,9 +440,14 @@ const wizardCommand = {
             if (enableEmbeddings) {
                 output.writeln();
                 output.printInfo('Initializing ONNX embedding subsystem...');
-                const { execSync } = await import('child_process');
+                const ALLOWED_MODELS = /^[\w\-./]+$/;
+                if (!ALLOWED_MODELS.test(embeddingModel)) {
+                    output.writeln(output.error('Invalid model identifier. Only alphanumeric characters, hyphens, dots, and slashes are allowed.'));
+                    return { success: false, exitCode: 1 };
+                }
+                const { execFileSync } = await import('child_process');
                 try {
-                    execSync(`npx @monoes/cli@latest embeddings init --model ${embeddingModel} --no-download --force 2>/dev/null`, {
+                    execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['@monomind/cli@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
                         timeout: 30000
@@ -500,7 +536,6 @@ const skillsCommand = {
         { name: 'core', description: 'Install core skills', type: 'boolean', default: true },
         { name: 'agentdb', description: 'Install AgentDB skills', type: 'boolean', default: false },
         { name: 'github', description: 'Install GitHub skills', type: 'boolean', default: false },
-        { name: 'v1', description: 'Install v1 skills', type: 'boolean', default: false },
     ],
     action: async (ctx) => {
         const options = {
@@ -525,8 +560,7 @@ const skillsCommand = {
                 agentdb: ctx.flags.agentdb,
                 github: ctx.flags.github,
                 browser: false,
-                v1: ctx.flags.v1,
-                dualMode: false,
+                advanced: false,
             },
         };
         const spinner = output.createSpinner({ text: 'Installing skills...' });

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

@@ -2,7 +2,7 @@
  * CLI MCP Command
  * MCP server control and management with real server integration
  *
- * @module @monoes/cli/commands/mcp
+ * @module @monomind/cli/commands/mcp
  * @version 3.0.0
  */
 import { output } from '../output.js';
@@ -450,23 +450,10 @@ const toggleCommand = {
         }
     ],
     action: async (ctx) => {
-        const toEnable = ctx.flags.enable;
-        const toDisable = ctx.flags.disable;
-        if (toEnable) {
-            const tools = toEnable.split(',');
-            output.printInfo(`Enabling tools: ${tools.join(', ')}`);
-            output.printSuccess(`Enabled ${tools.length} tools`);
-        }
-        if (toDisable) {
-            const tools = toDisable.split(',');
-            output.printInfo(`Disabling tools: ${tools.join(', ')}`);
-            output.printSuccess(`Disabled ${tools.length} tools`);
-        }
-        if (!toEnable && !toDisable) {
-            output.printError('Use --enable or --disable with comma-separated tool names');
-            return { success: false, exitCode: 1 };
-        }
-        return { success: true };
+        output.writeln();
+        output.writeln(output.warning('⚠  Tool toggling not yet implemented.'));
+        output.writeln(output.dim('Tool enable/disable state is not currently persisted. This feature requires MCP server reload support.'));
+        return { success: false, exitCode: 1 };
     }
 };
 // Execute tool
@@ -610,35 +597,35 @@ const logsCommand = {
         }
     ],
     action: async (ctx) => {
-        const lines = ctx.flags.lines;
-        // Default logs (loaded from actual log file when available)
-        const logs = [
-            { time: new Date().toISOString(), level: 'info', message: 'MCP Server started on stdio' },
-            { time: new Date().toISOString(), level: 'info', message: 'Registered 27 tools' },
-            { time: new Date().toISOString(), level: 'debug', message: 'Received request: tools/list' },
-            { time: new Date().toISOString(), level: 'info', message: 'Session initialized' },
-        ].slice(-lines);
+        const lines = ctx.flags.lines || 50;
+        // Try to find and read the actual log file
+        const { existsSync, readFileSync } = await import('fs');
+        const { join } = await import('path');
+        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));
         output.writeln();
         output.writeln(output.bold('MCP Server Logs'));
-        output.writeln();
-        for (const log of logs) {
-            let levelStr;
-            switch (log.level) {
-                case 'error':
-                    levelStr = output.error(log.level.toUpperCase().padEnd(5));
-                    break;
-                case 'warn':
-                    levelStr = output.warning(log.level.toUpperCase().padEnd(5));
-                    break;
-                case 'debug':
-                    levelStr = output.dim(log.level.toUpperCase().padEnd(5));
-                    break;
-                default:
-                    levelStr = output.info(log.level.toUpperCase().padEnd(5));
-            }
-            output.writeln(`${output.dim(log.time)} ${levelStr} ${log.message}`);
+        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(', ')}`));
+            return { success: true };
+        }
+        const content = readFileSync(logFile, 'utf8');
+        const logLines = content.trim().split('\n').filter(Boolean);
+        const tail = logLines.slice(-lines);
+        if (tail.length === 0) {
+            output.writeln(output.dim('Log file is empty.'));
+            return { success: true };
         }
-        return { success: true, data: logs };
+        output.writeln(output.dim(`Showing last ${tail.length} lines from ${logFile.replace(ctx.cwd, '.')}`));
+        output.writeln();
+        tail.forEach(line => output.writeln(line));
+        return { success: true };
     }
 };
 // Restart command

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

@@ -5,6 +5,7 @@
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { configManager } from '../services/config-file-manager.js';
 // Memory backends
 const BACKENDS = [
     { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
@@ -499,6 +500,10 @@ const editCommand = {
             output.printError('Entry ID is required for palace/knowledge edit. Use --id');
             return { success: false, exitCode: 1 };
         }
+        if (!/^[a-zA-Z0-9_\-]{1,128}$/.test(id)) {
+            output.printError('ID must be 1-128 chars: alphanumeric, underscore, or hyphen only');
+            return { success: false, exitCode: 1 };
+        }
         const filePath = source === 'palace'
             ? path.join(process.cwd(), '.monomind', 'palace', 'drawers.jsonl')
             : path.join(process.cwd(), '.monomind', 'knowledge', 'chunks.jsonl');
@@ -509,7 +514,16 @@ const editCommand = {
         let entries;
         try {
             const raw = fs.readFileSync(filePath, 'utf8');
-            entries = raw.split('\n').filter(Boolean).map(l => JSON.parse(l));
+            entries = [];
+            for (const line of raw.split('\n').filter(Boolean)) {
+                try {
+                    entries.push(JSON.parse(line));
+                }
+                catch {
+                    output.printError(`Malformed JSONL entry in ${source} file`);
+                    return { success: false, exitCode: 1 };
+                }
+            }
         }
         catch (err) {
             output.printError(`Failed to read ${source} file: ${err instanceof Error ? err.message : 'Unknown error'}`);
@@ -532,7 +546,9 @@ const editCommand = {
         }
         entries[idx] = { ...entries[idx], content: value, ts: new Date().toISOString() };
         try {
-            fs.writeFileSync(filePath, entries.map(e => JSON.stringify(e)).join('\n') + '\n');
+            const tmpPath = filePath + '.tmp';
+            fs.writeFileSync(tmpPath, entries.map(e => JSON.stringify(e)).join('\n') + '\n');
+            fs.renameSync(tmpPath, filePath);
             output.printSuccess(`Updated ${source} entry "${id}"`);
             return { success: true, data: entries[idx] };
         }
@@ -734,6 +750,10 @@ const deleteCommand = {
             output.printError('Entry ID is required for palace/knowledge delete. Use --id');
             return { success: false, exitCode: 1 };
         }
+        if (!/^[a-zA-Z0-9_\-]{1,128}$/.test(id)) {
+            output.printError('ID must be 1-128 chars: alphanumeric, underscore, or hyphen only');
+            return { success: false, exitCode: 1 };
+        }
         const fs = await import('fs');
         const path = await import('path');
         const filePath = source === 'palace'
@@ -746,7 +766,16 @@ const deleteCommand = {
         let entries;
         try {
             const raw = fs.readFileSync(filePath, 'utf8');
-            entries = raw.split('\n').filter(Boolean).map(l => JSON.parse(l));
+            entries = [];
+            for (const line of raw.split('\n').filter(Boolean)) {
+                try {
+                    entries.push(JSON.parse(line));
+                }
+                catch {
+                    output.printError(`Malformed JSONL entry in ${source} file`);
+                    return { success: false, exitCode: 1 };
+                }
+            }
         }
         catch (err) {
             output.printError(`Failed to read ${source} file: ${err instanceof Error ? err.message : 'Unknown error'}`);
@@ -769,7 +798,9 @@ const deleteCommand = {
         }
         entries.splice(idx, 1);
         try {
-            fs.writeFileSync(filePath, entries.map(e => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : ''));
+            const tmpPath = filePath + '.tmp';
+            fs.writeFileSync(tmpPath, entries.map(e => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : ''));
+            fs.renameSync(tmpPath, filePath);
             output.printSuccess(`Deleted ${source} entry "${id}"`);
             output.printInfo(`Remaining entries: ${entries.length}`);
             return { success: true, data: { id, deleted: true, remainingEntries: entries.length } };
@@ -894,10 +925,10 @@ const configureCommand = {
         const config = {
             backend: backend || 'hybrid',
             path: ctx.flags.path || './data/memory',
-            cacheSize: ctx.flags.cacheSize || 256,
+            cacheSize: ctx.flags['cache-size'] || 256,
             hnsw: {
-                m: ctx.flags.hnswM || 16,
-                ef: ctx.flags.hnswEf || 200
+                m: ctx.flags['hnsw-m'] || 16,
+                ef: ctx.flags['hnsw-ef'] || 200
             }
         };
         output.writeln();
@@ -917,6 +948,7 @@ const configureCommand = {
             ]
         });
         output.writeln();
+        configManager.set(ctx.cwd, 'memory', config);
         output.printSuccess('Memory configuration updated');
         return { success: true, data: config };
     }
@@ -972,7 +1004,7 @@ const cleanupCommand = {
         { command: 'monomind memory cleanup --expired-only', description: 'Clean expired entries' }
     ],
     action: async (ctx) => {
-        const dryRun = ctx.flags.dryRun;
+        const dryRun = ctx.flags['dry-run'];
         const force = ctx.flags.force;
         if (dryRun) {
             output.writeln(output.warning('DRY RUN - No changes will be made'));
@@ -981,9 +1013,9 @@ const cleanupCommand = {
         try {
             const result = await callMCPTool('memory_cleanup', {
                 dryRun,
-                olderThan: ctx.flags.olderThan,
-                expiredOnly: ctx.flags.expiredOnly,
-                lowQualityThreshold: ctx.flags.lowQuality,
+                olderThan: ctx.flags['older-than'],
+                expiredOnly: ctx.flags['expired-only'],
+                lowQualityThreshold: ctx.flags['low-quality'],
                 namespace: ctx.flags.namespace,
             });
             if (ctx.flags.format === 'json') {
@@ -1348,7 +1380,7 @@ const initMemoryCommand = {
         const force = ctx.flags.force;
         const verbose = ctx.flags.verbose;
         const verify = ctx.flags.verify !== false; // Default true
-        const loadEmbeddings = ctx.flags.loadEmbeddings;
+        const loadEmbeddings = ctx.flags['load-embeddings'];
         output.writeln();
         output.writeln(output.bold('Initializing Memory Database'));
         output.writeln(output.dim('─'.repeat(50)));
@@ -1505,11 +1537,11 @@ const initMemoryCommand = {
                 output.writeln(output.dim(`Synced to: ${claudeDbPath}`));
             }
             // Fix #1428: ONNX worker threads keep the event loop alive after init.
-            // Force-exit after a short delay to allow final I/O to flush.
-            if (typeof globalThis !== 'undefined') {
+            // Only force-exit when embeddings were actually loaded (ONNX threads spun up).
+            if (loadEmbeddings && typeof globalThis !== 'undefined') {
                 setTimeout(() => {
                     process.exit(0);
-                }, 500).unref();
+                }, 500);
             }
             return {
                 success: true,