monomind 2.0.3 → 2.1.0

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

@@ -5,27 +5,37 @@
  * github.com/monoes/monomind
  */
 import { output } from '../output.js';
-// Get all top-level commands for completions
-const TOP_LEVEL_COMMANDS = [
-    'swarm', 'agent', 'task', 'session', 'config', 'memory',
-    'hive-mind', 'hooks', 'security', 'performance',
-    'providers', 'embeddings',
-    'doctor', 'completions', 'help', 'version'
-];
-// Swarm subcommands
-const SWARM_SUBCOMMANDS = ['init', 'status', 'scale', 'destroy', 'monitor'];
-// Agent subcommands
-const AGENT_SUBCOMMANDS = ['spawn', 'terminate', 'status', 'list', 'pool', 'health', 'update'];
-// Task subcommands
-const TASK_SUBCOMMANDS = ['create', 'status', 'list', 'complete', 'cancel'];
-// Memory subcommands
-const MEMORY_SUBCOMMANDS = ['store', 'retrieve', 'search', 'list', 'delete', 'stats', 'configure', 'export', 'import'];
-// Hive-mind subcommands
-const HIVE_MIND_SUBCOMMANDS = ['init', 'spawn', 'status', 'join', 'leave', 'consensus', 'broadcast', 'memory', 'shutdown'];
-// Hooks subcommands
-const HOOKS_SUBCOMMANDS = ['pre-edit', 'post-edit', 'pre-command', 'post-command', 'pre-task', 'post-task', 'route', 'explain', 'pretrain', 'build-agents', 'metrics', 'transfer', 'list', 'intelligence'];
+// Derive completion lists from the actual command registry (commands/index.ts)
+// instead of hardcoding them here — hardcoded lists rot as commands are added,
+// renamed, or removed (this file previously referenced 'claims', 'embeddings',
+// 'workflow', 'hive-mind', none of which exist as top-level commands anymore,
+// while omitting many real ones). A dynamic import (resolved at call time, in
+// the async command actions below) avoids evaluating the circular import
+// (index.ts -> completions.ts -> index.ts) at module-load time.
+async function getRegistry() {
+    const { commands } = await import('./index.js');
+    return commands;
+}
+function topLevelCommandNames(commands) {
+    return [...commands.map(c => c.name), 'help', 'version'];
+}
+/** Map of command name (and aliases) -> subcommand names, for commands that have subcommands. */
+function subcommandMap(commands) {
+    const map = {};
+    for (const cmd of commands) {
+        if (cmd.subcommands && cmd.subcommands.length > 0) {
+            map[cmd.name] = cmd.subcommands.map(s => s.name);
+            for (const alias of cmd.aliases ?? [])
+                map[alias] = map[cmd.name];
+        }
+    }
+    return map;
+}
 // Generate bash completion script
-function generateBashCompletion() {
+function generateBashCompletion(topLevel, subMap) {
+    const caseArms = Object.entries(subMap)
+        .map(([cmd, subs]) => `        ${cmd})\n            COMPREPLY=( $(compgen -W "${subs.join(' ')}" -- "\${cur}") )\n            return 0\n            ;;`)
+        .join('\n');
     return `# monomind bash completion
 # Generated by monomind completions bash
 # Add this to ~/.bashrc or ~/.bash_completion
@@ -34,61 +44,10 @@ _monomind_completions() {
     local cur prev words cword
     _init_completion -n : || return
 
-    local commands="${TOP_LEVEL_COMMANDS.join(' ')}"
-
-    # Subcommand completions
-    local swarm_commands="${SWARM_SUBCOMMANDS.join(' ')}"
-    local agent_commands="${AGENT_SUBCOMMANDS.join(' ')}"
-    local task_commands="${TASK_SUBCOMMANDS.join(' ')}"
-    local memory_commands="${MEMORY_SUBCOMMANDS.join(' ')}"
-    local hive_mind_commands="${HIVE_MIND_SUBCOMMANDS.join(' ')}"
-    local hooks_commands="${HOOKS_SUBCOMMANDS.join(' ')}"
+    local commands="${topLevel.join(' ')}"
 
     case "\${words[1]}" in
-        swarm)
-            COMPREPLY=( $(compgen -W "\${swarm_commands}" -- "\${cur}") )
-            return 0
-            ;;
-        agent)
-            COMPREPLY=( $(compgen -W "\${agent_commands}" -- "\${cur}") )
-            return 0
-            ;;
-        task)
-            COMPREPLY=( $(compgen -W "\${task_commands}" -- "\${cur}") )
-            return 0
-            ;;
-        memory)
-            COMPREPLY=( $(compgen -W "\${memory_commands}" -- "\${cur}") )
-            return 0
-            ;;
-        hive-mind|hive)
-            COMPREPLY=( $(compgen -W "\${hive_mind_commands}" -- "\${cur}") )
-            return 0
-            ;;
-        hooks)
-            COMPREPLY=( $(compgen -W "\${hooks_commands}" -- "\${cur}") )
-            return 0
-            ;;
-        security)
-            COMPREPLY=( $(compgen -W "scan cve audit secrets" -- "\${cur}") )
-            return 0
-            ;;
-        performance)
-            COMPREPLY=( $(compgen -W "benchmark profile metrics bottleneck" -- "\${cur}") )
-            return 0
-            ;;
-        claims)
-            COMPREPLY=( $(compgen -W "list check grant revoke roles policies" -- "\${cur}") )
-            return 0
-            ;;
-        embeddings)
-            COMPREPLY=( $(compgen -W "generate search compare collections index providers" -- "\${cur}") )
-            return 0
-            ;;
-        providers)
-            COMPREPLY=( $(compgen -W "list configure test models usage" -- "\${cur}") )
-            return 0
-            ;;
+${caseArms}
         doctor)
             COMPREPLY=( $(compgen -W "--fix --component --verbose" -- "\${cur}") )
             return 0
@@ -106,7 +65,17 @@ complete -F _monomind_completions npx\\ @monomind/cli@v1alpha
 `;
 }
 // Generate zsh completion script
-function generateZshCompletion() {
+function generateZshCompletion(commandList, subMap) {
+    const commandsBlock = commandList
+        .map(c => `        '${c.name}:${c.description.replace(/'/g, '')}'`)
+        .concat([`        'help:Show help'`, `        'version:Show version'`])
+        .join('\n');
+    const caseArms = Object.entries(subMap)
+        .map(([cmd, subs]) => {
+        const subLines = subs.map(s => `                        '${s}'`).join('\n');
+        return `                ${cmd})\n                    subcommands=(\n${subLines}\n                    )\n                    ;;`;
+    })
+        .join('\n');
     return `#compdef monomind
 # monomind zsh completion
 # Generated by monomind completions zsh
@@ -117,24 +86,7 @@ _monomind() {
     local -a subcommands
 
     commands=(
-        'swarm:Multi-agent swarm orchestration'
-        'agent:Agent lifecycle management'
-        'task:Task creation and management'
-        'session:Session management'
-        'config:Configuration management'
-        'memory:Memory operations with LanceDB'
-        'workflow:Workflow automation'
-        'hive-mind:Queen-led consensus coordination'
-        'hooks:Self-learning automation hooks'
-        'security:Security scanning and CVE detection'
-        'performance:Performance profiling'
-        'providers:AI provider management'
-        'claims:Claims-based authorization'
-        'embeddings:Vector embeddings'
-        'doctor:System diagnostics'
-        'completions:Shell completion scripts'
-        'help:Show help'
-        'version:Show version'
+${commandsBlock}
     )
 
     _arguments -C \\
@@ -148,124 +100,7 @@ _monomind() {
             ;;
         subcommand)
             case $words[2] in
-                swarm)
-                    subcommands=(
-                        'init:Initialize swarm'
-                        'status:Show swarm status'
-                        'scale:Scale agent count'
-                        'destroy:Shutdown swarm'
-                        'monitor:Real-time monitoring'
-                    )
-                    ;;
-                agent)
-                    subcommands=(
-                        'spawn:Create new agent'
-                        'terminate:Stop agent'
-                        'status:Check agent status'
-                        'list:List all agents'
-                        'pool:Manage agent pool'
-                        'health:Health check'
-                        'update:Update agent config'
-                    )
-                    ;;
-                task)
-                    subcommands=(
-                        'create:Create new task'
-                        'status:Check task status'
-                        'list:List all tasks'
-                        'complete:Mark task complete'
-                        'cancel:Cancel task'
-                    )
-                    ;;
-                memory)
-                    subcommands=(
-                        'store:Store data'
-                        'retrieve:Retrieve data'
-                        'search:Semantic search'
-                        'list:List entries'
-                        'delete:Delete entry'
-                        'stats:Show statistics'
-                        'configure:Configure backend'
-                        'export:Export to file'
-                        'import:Import from file'
-                    )
-                    ;;
-                hive-mind|hive)
-                    subcommands=(
-                        'init:Initialize hive mind'
-                        'spawn:Spawn worker agents'
-                        'status:Show hive status'
-                        'join:Join agent to hive'
-                        'leave:Remove agent'
-                        'consensus:Consensus management'
-                        'broadcast:Broadcast message'
-                        'memory:Shared memory'
-                        'shutdown:Shutdown hive'
-                    )
-                    ;;
-                hooks)
-                    subcommands=(
-                        'pre-edit:Before file editing'
-                        'post-edit:After file editing'
-                        'pre-command:Before command execution'
-                        'post-command:After command execution'
-                        'pre-task:Before task start'
-                        'post-task:After task completion'
-                        'route:Route task to agent'
-                        'explain:Explain routing'
-                        'pretrain:Bootstrap intelligence'
-                        'build-agents:Generate agent configs'
-                        'metrics:Show metrics'
-                        'transfer:Transfer learning'
-                        'list:List hooks'
-                        'intelligence:Neural intelligence commands'
-                    )
-                    ;;
-                security)
-                    subcommands=(
-                        'scan:Security scan'
-                        'cve:CVE detection'
-                        'audit:Security audit'
-                        'secrets:Secrets scanning'
-                    )
-                    ;;
-                performance)
-                    subcommands=(
-                        'benchmark:Run benchmarks'
-                        'profile:Profile code'
-                        'metrics:Show metrics'
-                        'bottleneck:Find bottlenecks'
-                    )
-                    ;;
-                claims)
-                    subcommands=(
-                        'list:List claims'
-                        'check:Check permission'
-                        'grant:Grant claim'
-                        'revoke:Revoke claim'
-                        'roles:Manage roles'
-                        'policies:Manage policies'
-                    )
-                    ;;
-                embeddings)
-                    subcommands=(
-                        'generate:Generate embeddings'
-                        'search:Semantic search'
-                        'compare:Compare vectors'
-                        'collections:Manage collections'
-                        'index:Index operations'
-                        'providers:Embedding providers'
-                    )
-                    ;;
-                providers)
-                    subcommands=(
-                        'list:List providers'
-                        'configure:Configure provider'
-                        'test:Test connection'
-                        'models:Available models'
-                        'usage:Usage statistics'
-                    )
-                    ;;
+${caseArms}
             esac
             _describe -t subcommands 'subcommands' subcommands
             ;;
@@ -276,7 +111,11 @@ _monomind "$@"
 `;
 }
 // Generate fish completion script
-function generateFishCompletion() {
+function generateFishCompletion(topLevel, subMap) {
+    const subBlocks = Object.entries(subMap)
+        .map(([cmd, subs]) => `# ${cmd} subcommands\n` +
+        subs.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from ${cmd}" -a "${sub}"`).join('\n'))
+        .join('\n\n');
     return `# monomind fish completion
 # Generated by monomind completions fish
 # Save to ~/.config/fish/completions/monomind.fish
@@ -285,64 +124,26 @@ function generateFishCompletion() {
 complete -c monomind -f
 
 # Top-level commands
-${TOP_LEVEL_COMMANDS.map(cmd => `complete -c monomind -n "__fish_use_subcommand" -a "${cmd}"`).join('\n')}
-
-# Swarm subcommands
-${SWARM_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from swarm" -a "${sub}"`).join('\n')}
-
-# Agent subcommands
-${AGENT_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from agent" -a "${sub}"`).join('\n')}
-
-# Task subcommands
-${TASK_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from task" -a "${sub}"`).join('\n')}
-
-# Memory subcommands
-${MEMORY_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from memory" -a "${sub}"`).join('\n')}
-
-# Hive-mind subcommands
-${HIVE_MIND_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from hive-mind hive" -a "${sub}"`).join('\n')}
-
-# Hooks subcommands
-${HOOKS_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from hooks" -a "${sub}"`).join('\n')}
-
-# Security subcommands
-complete -c monomind -n "__fish_seen_subcommand_from security" -a "scan cve audit secrets"
-
-# Performance subcommands
-complete -c monomind -n "__fish_seen_subcommand_from performance" -a "benchmark profile metrics bottleneck"
-
-# Claims subcommands
-complete -c monomind -n "__fish_seen_subcommand_from claims" -a "list check grant revoke roles policies"
-
-# Embeddings subcommands
-complete -c monomind -n "__fish_seen_subcommand_from embeddings" -a "generate search compare collections index providers"
+${topLevel.map(cmd => `complete -c monomind -n "__fish_use_subcommand" -a "${cmd}"`).join('\n')}
 
-# Providers subcommands
-complete -c monomind -n "__fish_seen_subcommand_from providers" -a "list configure test models usage"
+${subBlocks}
 `;
 }
 // Generate PowerShell completion script
-function generatePowerShellCompletion() {
+function generatePowerShellCompletion(topLevel, subMap) {
+    const subEntries = Object.entries(subMap)
+        .map(([cmd, subs]) => `    '${cmd}' = @('${subs.join("', '")}')`)
+        .join('\n');
     return `# monomind PowerShell completion
 # Generated by monomind completions powershell
 # Add to $PROFILE or save to a separate file and dot-source it
 
 $script:MonomindCommands = @(
-    '${TOP_LEVEL_COMMANDS.join("',\n    '")}'
+    '${topLevel.join("',\n    '")}'
 )
 
 $script:SubCommands = @{
-    'swarm' = @('${SWARM_SUBCOMMANDS.join("', '")}')
-    'agent' = @('${AGENT_SUBCOMMANDS.join("', '")}')
-    'task' = @('${TASK_SUBCOMMANDS.join("', '")}')
-    'memory' = @('${MEMORY_SUBCOMMANDS.join("', '")}')
-    'hive-mind' = @('${HIVE_MIND_SUBCOMMANDS.join("', '")}')
-    'hive' = @('${HIVE_MIND_SUBCOMMANDS.join("', '")}')
-    'hooks' = @('${HOOKS_SUBCOMMANDS.join("', '")}')
-    'security' = @('scan', 'cve', 'audit', 'secrets')
-    'performance' = @('benchmark', 'profile', 'metrics', 'bottleneck')
-    'embeddings' = @('generate', 'search', 'compare', 'collections', 'index', 'providers')
-    'providers' = @('list', 'configure', 'test', 'models', 'usage')
+${subEntries}
 }
 
 Register-ArgumentCompleter -Native -CommandName monomind -ScriptBlock {
@@ -371,7 +172,8 @@ const bashCommand = {
     name: 'bash',
     description: 'Generate bash completion script',
     action: async (ctx) => {
-        const script = generateBashCompletion();
+        const commandList = await getRegistry();
+        const script = generateBashCompletion(topLevelCommandNames(commandList), subcommandMap(commandList));
         output.writeln(script);
         return { success: true };
     }
@@ -381,7 +183,8 @@ const zshCommand = {
     name: 'zsh',
     description: 'Generate zsh completion script',
     action: async (ctx) => {
-        const script = generateZshCompletion();
+        const commandList = await getRegistry();
+        const script = generateZshCompletion(commandList, subcommandMap(commandList));
         output.writeln(script);
         return { success: true };
     }
@@ -391,7 +194,8 @@ const fishCommand = {
     name: 'fish',
     description: 'Generate fish completion script',
     action: async (ctx) => {
-        const script = generateFishCompletion();
+        const commandList = await getRegistry();
+        const script = generateFishCompletion(topLevelCommandNames(commandList), subcommandMap(commandList));
         output.writeln(script);
         return { success: true };
     }
@@ -402,7 +206,8 @@ const powershellCommand = {
     aliases: ['pwsh'],
     description: 'Generate PowerShell completion script',
     action: async (ctx) => {
-        const script = generatePowerShellCompletion();
+        const commandList = await getRegistry();
+        const script = generatePowerShellCompletion(topLevelCommandNames(commandList), subcommandMap(commandList));
         output.writeln(script);
         return { success: true };
     }

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

@@ -23,7 +23,7 @@ export const doctorCommand = {
         { name: 'install', short: 'i', description: 'Auto-install missing dependencies (Claude Code CLI)', type: 'boolean', default: false },
         {
             name: 'component', short: 'c',
-            description: 'Check specific component (version, node, npm, config, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, monoes, gates, gitignore, registry, monoes-tools, metrics-freshness, security-audit)',
+            description: 'Check specific component (version, node, npm, config, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, monoes, gates, gitignore, registry, memory-proficiency, monoes-tools, metrics-freshness, security-audit)',
             type: 'string',
         },
         { name: 'verbose', short: 'v', description: 'Verbose output', type: 'boolean', default: false },
@@ -86,7 +86,12 @@ export const doctorCommand = {
             'monoes-tools': checkMonoesTools,
             'metrics-freshness': checkMetricsFreshness, 'security-audit': checkSecurityAuditFindings,
         };
-        const checksToRun = (component && componentMap[component]) ? [componentMap[component]] : allChecks;
+        if (component && !componentMap[component]) {
+            output.writeln(output.error(`Unknown component: "${component}"`));
+            output.writeln(`Valid components: ${Object.keys(componentMap).sort().join(', ')}`);
+            return { success: false, exitCode: 1, data: { passed: 0, warnings: 0, failed: 1, results: [] } };
+        }
+        const checksToRun = component ? [componentMap[component]] : allChecks;
         const results = [];
         const fixes = [];
         const spinner = output.createSpinner({ text: 'Running health checks in parallel...', spinner: 'dots' });

package/packages/@monomind/cli/dist/src/commands/hooks-workers.js

@@ -479,6 +479,13 @@ const workerRunCommand = {
                 return { success: false, exitCode: 1 };
             }
             const manager = hooks.createWorkerManager(process.cwd());
+            // `run` invokes a single worker standalone, outside the normal
+            // session-start path — runWorker() itself does not create
+            // .monomind/metrics/, so on a fresh project with no prior
+            // session-start hook run, workers that write metrics files fail with
+            // ENOENT. ensureMetricsDir() is the minimal piece of the manager's
+            // initialize() step this command actually needs (no state load/timers).
+            await manager.ensureMetricsDir();
             const result = await manager.runWorker(name);
             if (!result.success) {
                 spinner.fail(`Worker ${name} failed: ${result.error || 'unknown error'}`);

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

@@ -37,6 +37,7 @@ import { searchUniversalCommand } from './search-universal.js';
 import { reportCrashCommand } from './report-crash.js';
 import { crashReportingCommand } from './crash-reporting.js';
 import { docCommand } from './doc.js';
+import { orgCommand } from './org.js';
 // Populate command cache
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -69,6 +70,7 @@ loadedCommands.set('search', searchUniversalCommand);
 loadedCommands.set('report-crash', reportCrashCommand);
 loadedCommands.set('crash-reporting', crashReportingCommand);
 loadedCommands.set('doc', docCommand);
+loadedCommands.set('org', orgCommand);
 // =============================================================================
 // Exports
 // =============================================================================
@@ -106,6 +108,7 @@ export const commands = [
     sessionCommand,
     agentCommand,
     swarmCommand,
+    orgCommand,
     memoryCommand,
     mcpCommand,
     hooksCommand,

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

@@ -256,11 +256,15 @@ const statusCommand = {
     action: async (ctx) => {
         try {
             let status = await getMCPServerStatus();
-            // If PID-based check says not running, detect stdio mode
+            // If PID-based check says not running, detect stdio mode.
+            // SECURITY/CORRECTNESS: must NOT use a TTY heuristic here — any
+            // non-interactive invocation (piped, CI, scripted) has
+            // `!process.stdin.isTTY === true`, which previously reported
+            // "running" even when nothing was actually running. Only the
+            // explicit stdio-transport env var counts as a real signal.
             if (!status.running) {
-                const isStdio = !process.stdin.isTTY;
                 const envTransport = process.env.MONOMIND_MCP_TRANSPORT;
-                if (isStdio || envTransport === 'stdio') {
+                if (envTransport === 'stdio') {
                     status = {
                         running: true,
                         pid: process.pid,
@@ -366,7 +370,7 @@ const toolsCommand = {
                 name: tool.name,
                 category: tool.category || 'uncategorized',
                 description: tool.description,
-                enabled: true
+                enabled: tool.enabled
             }));
         }
         else {
@@ -457,7 +461,7 @@ const toggleCommand = {
     action: async (ctx) => {
         const fs = await import('node:fs');
         const path = await import('node:path');
-        const stateFile = path.join('.monomind', 'mcp-disabled-tools.json');
+        const stateFile = path.join(ctx.cwd, '.monomind', 'mcp-disabled-tools.json');
         let disabled = [];
         try {
             disabled = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
@@ -485,7 +489,8 @@ const toggleCommand = {
         fs.mkdirSync(path.dirname(stateFile), { recursive: true });
         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('Note: MCP server restart required for changes to take effect.'));
+        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 };
     }
 };

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

@@ -178,20 +178,28 @@ export const statsCommand = {
     action: async (ctx) => {
         // Compute stats directly from the memory bridge (there is no memory_stats MCP tool)
         try {
-            const { bridgeListEntries } = await import('../memory/memory-bridge.js');
+            const { bridgeListEntries, bridgeGetBackendStats, bridgeGetDbPath } = await import('../memory/memory-bridge.js');
             const listed = await bridgeListEntries({ limit: 10000 });
             if (!listed || !listed.success)
                 throw new Error('memory backend unavailable');
             const entries = listed.entries;
             const totalBytes = entries.reduce((s, e) => s + (e.content || '').length, 0);
             const times = entries.map((e) => e.updatedAt || e.createdAt).filter(Boolean).sort();
+            // Real configured backend (falls back to the config default when unset).
+            const memoryConfig = configManager.get(ctx.cwd, 'memory');
+            const configuredBackend = memoryConfig?.backend || 'hybrid';
+            // The actual storage engine currently in use for reads/writes is always
+            // LanceDB (memory-bridge.ts) — report the real on-disk path, not the
+            // configured (but not-yet-wired) backend's path.
+            const backendStats = await bridgeGetBackendStats();
+            const realLocation = bridgeGetDbPath();
             const statsResult = {
                 totalEntries: entries.length,
                 totalSize: totalBytes >= 1048576 ? `${(totalBytes / 1048576).toFixed(1)} MB`
                     : totalBytes >= 1024 ? `${(totalBytes / 1024).toFixed(1)} KB` : `${totalBytes} B`,
                 version: 'lancedb',
-                backend: 'LanceDB',
-                location: '~/.monomind/projects/<project>/lancedb',
+                backend: `LanceDB (configured: ${configuredBackend})`,
+                location: realLocation,
                 oldestEntry: times[0] ? new Date(times[0]).toISOString() : null,
                 newestEntry: times.length ? new Date(times[times.length - 1]).toISOString() : null,
             };
@@ -199,7 +207,7 @@ export const statsCommand = {
                 backend: statsResult.backend,
                 entries: {
                     total: statsResult.totalEntries,
-                    vectors: 0, // Would need vector backend support
+                    vectors: backendStats?.totalEntries ?? statsResult.totalEntries,
                     text: statsResult.totalEntries
                 },
                 storage: {
@@ -243,8 +251,6 @@ export const statsCommand = {
                     { metric: 'Newest Entry', value: stats.newestEntry || 'N/A' }
                 ]
             });
-            output.writeln();
-            output.printInfo('v1 Performance: O(log n) pure-JS HNSW vector search');
             return { success: true, data: stats };
         }
         catch (error) {

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

@@ -18,32 +18,25 @@ export const exportCommand = {
         {
             name: 'format',
             short: 'f',
-            description: 'Export format (json, csv, binary, okf)',
+            description: 'Export format (only okf is currently implemented)',
             type: 'string',
-            choices: ['json', 'csv', 'binary', 'okf'],
-            default: 'json'
+            choices: ['okf'],
+            default: 'okf'
         },
         {
             name: 'namespace',
             short: 'n',
             description: 'Export specific namespace',
             type: 'string'
-        },
-        {
-            name: 'include-vectors',
-            description: 'Include vector embeddings',
-            type: 'boolean',
-            default: true
         }
     ],
     examples: [
-        { command: 'monomind memory export -o ./backup.json', description: 'Export all to JSON' },
-        { command: 'monomind memory export -o ./data.csv -f csv', description: 'Export to CSV' },
+        { command: 'monomind memory export -o ./backup', description: 'Export all as OKF bundle (directory of .md files)' },
         { command: 'monomind memory export -o ./knowledge -f okf', description: 'Export as OKF bundle (directory of .md files)' }
     ],
     action: async (ctx) => {
         const outputPath = ctx.flags.output;
-        const format = ctx.flags.format || 'json';
+        const format = ctx.flags.format || 'okf';
         if (!outputPath) {
             output.printError('Output path is required. Use --output or -o');
             return { success: false, exitCode: 1 };
@@ -87,7 +80,7 @@ export const exportCommand = {
                 return { success: false, exitCode: 1 };
             }
         }
-        output.printError(`Unsupported export format: ${format}. Use --format okf for file-based export.`);
+        output.printError(`Format '${format}' is not yet implemented. Use --format okf (the only supported format).`);
         return { success: false, exitCode: 1 };
     }
 };

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

@@ -105,10 +105,10 @@ const buildCommand = {
         const progressLines = [];
         try {
             const { buildAsync } = await import('@monoes/monograph');
-            // llmMaxSections is a UI variable only; not a valid BuildOptions key in @monoes/monograph@1.1.0
             await buildAsync(root, {
                 codeOnly,
                 force,
+                llmMaxSections,
                 onProgress: (p) => {
                     const msg = `[${p.phase}] ${p.message ?? ''}`;
                     progressLines.push(msg);
@@ -200,10 +200,10 @@ const wikiCommand = {
         const progressLines = [];
         try {
             const { buildAsync } = await import('@monoes/monograph');
-            // llmMaxSections is a UI variable only; not a valid BuildOptions key in @monoes/monograph@1.1.0
             await buildAsync(root, {
                 codeOnly: false,
                 force,
+                llmMaxSections,
                 onProgress: (p) => {
                     const msg = `[${p.phase}] ${p.message ?? ''}`;
                     progressLines.push(msg);
@@ -408,7 +408,7 @@ const watchCommand = {
             const watcher = new MonographWatcher(root);
             watcher.on('monograph:updated', () => {
                 output.writeln(output.dim('  [watch] File change detected, rebuilding…'));
-                buildAsync(root, { codeOnly: false }).catch((err) => {
+                buildAsync(root, { codeOnly: false, llmMaxSections }).catch((err) => {
                     output.writeln(output.dim(`  [watch] Rebuild error: ${err.message}`));
                 });
             });