monomind 1.18.15 → 2.0.0

package/packages/@monomind/cli/dist/src/commands/index.d.ts

@@ -1,12 +1,6 @@
 /**
  * CLI Commands Index
  * Central registry for all CLI commands
- *
- * NOTE: All commands are synchronously imported at module load time (lines below).
- * The commandLoaders/loadCommand infrastructure provides an async fallback for
- * commands looked up via getCommandAsync() but does NOT reduce startup time since
- * all modules are already imported synchronously for the commands array and
- * commandsByCategory exports.
  */
 import type { Command } from '../types.js';
 export { initCommand } from './init.js';
@@ -19,47 +13,21 @@ export { swarmCommand } from './swarm.js';
 export { memoryCommand } from './memory.js';
 export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
-export { daemonCommand } from './daemon.js';
 export { doctorCommand } from './doctor.js';
-export { neuralCommand } from './neural.js';
 export { performanceCommand } from './performance.js';
 export { securityCommand } from './security.js';
-export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { cleanupCommand } from './cleanup.js';
 export { autopilotCommand } from './autopilot.js';
 export { monographCommand } from './monograph.js';
 export { platformsCommand } from './platforms.js';
 export { designCommand } from './design-detect.js';
-export { enrichCommand } from './enrich.js';
 export { searchUniversalCommand } from './search-universal.js';
-export { scanCommand } from './scan.js';
 export { reportCrashCommand } from './report-crash.js';
 export { crashReportingCommand } from './crash-reporting.js';
 export { docCommand } from './doc.js';
-export declare function getConfigCommand(): Promise<Command | undefined>;
-export declare function getWorkflowCommand(): Promise<Command | undefined>;
-export declare function getHiveMindCommand(): Promise<Command | undefined>;
-export declare function getProcessCommand(): Promise<Command | undefined>;
-export declare function getTaskCommand(): Promise<Command | undefined>;
-export declare function getSessionCommand(): Promise<Command | undefined>;
-export declare function getNeuralCommand(): Promise<Command | undefined>;
-export declare function getSecurityCommand(): Promise<Command | undefined>;
-export declare function getPerformanceCommand(): Promise<Command | undefined>;
-export declare function getProvidersCommand(): Promise<Command | undefined>;
-export declare function getDeploymentCommand(): Promise<Command | undefined>;
-export declare function getClaimsCommand(): Promise<Command | undefined>;
-export declare function getCompletionsCommand(): Promise<Command | undefined>;
-export declare function getAnalyzeCommand(): Promise<Command | undefined>;
-export declare function getRouteCommand(): Promise<Command | undefined>;
-export declare function getIssuesCommand(): Promise<Command | undefined>;
-export declare function getGuidanceCommand(): Promise<Command | undefined>;
-export declare function getCleanupCommand(): Promise<Command | undefined>;
-export declare function getAutopilotCommand(): Promise<Command | undefined>;
-export declare function getMonographCommand(): Promise<Command | undefined>;
 /**
- * Core commands loaded synchronously (available immediately)
- * Advanced commands loaded on-demand for faster startup
+ * All registered commands
  */
 export declare const commands: Command[];
 /**
@@ -74,34 +42,13 @@ export declare const commandsByCategory: {
 };
 /**
  * Command registry map for quick lookup
- * Supports both sync (core commands) and async (lazy-loaded) commands
  */
 export declare const commandRegistry: Map<string, Command>;
-/**
- * Get command by name (sync for core commands, returns undefined for lazy commands)
- * Use getCommandAsync for lazy-loaded commands
- */
 export declare function getCommand(name: string): Command | undefined;
-/**
- * Get command by name (async - supports lazy loading)
- */
 export declare function getCommandAsync(name: string): Promise<Command | undefined>;
-/**
- * Check if command exists (sync check for core commands)
- */
 export declare function hasCommand(name: string): boolean;
-/**
- * Get all command names (including aliases and lazy-loadable)
- */
 export declare function getCommandNames(): string[];
-/**
- * Get all unique commands (excluding aliases)
- */
 export declare function getUniqueCommands(): Command[];
-/**
- * Load all commands (populates lazy-loaded commands)
- * Use this when you need all commands available synchronously
- */
 export declare function loadAllCommands(): Promise<Command[]>;
 /**
  * Setup commands in a CLI instance
@@ -110,7 +57,7 @@ export declare function setupCommands(cli: {
     command: (cmd: Command) => void;
 }): void;
 /**
- * Setup all commands including lazy-loaded (async)
+ * Setup all commands (async variant)
  */
 export declare function setupAllCommands(cli: {
     command: (cmd: Command) => void;

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

@@ -1,112 +1,10 @@
 /**
  * CLI Commands Index
  * Central registry for all CLI commands
- *
- * NOTE: All commands are synchronously imported at module load time (lines below).
- * The commandLoaders/loadCommand infrastructure provides an async fallback for
- * commands looked up via getCommandAsync() but does NOT reduce startup time since
- * all modules are already imported synchronously for the commands array and
- * commandsByCategory exports.
  */
-/**
- * Command loaders - commands are only imported when needed
- * This reduces initial bundle parse time by ~200ms
- */
-const commandLoaders = {
-    // P1 Core Commands (frequently used - load first)
-    init: () => import('./init.js'),
-    start: () => import('./start.js'),
-    status: () => import('./status.js'),
-    task: () => import('./task.js'),
-    session: () => import('./session.js'),
-    // Original Commands
-    agent: () => import('./agent.js'),
-    swarm: () => import('./swarm.js'),
-    memory: () => import('./memory.js'),
-    mcp: () => import('./mcp.js'),
-    config: () => import('./config.js'),
-    hooks: () => import('./hooks.js'),
-    workflow: () => import('./workflow.js'),
-    'hive-mind': () => import('./hive-mind.js'),
-    process: () => import('./process.js'),
-    daemon: () => import('./daemon.js'),
-    // Advanced Commands (less frequently used - lazy load)
-    neural: () => import('./neural.js'),
-    security: () => import('./security.js'),
-    performance: () => import('./performance.js'),
-    providers: () => import('./providers.js'),
-    deployment: () => import('./deployment.js'),
-    claims: () => import('./claims.js'),
-    // P0 Commands
-    completions: () => import('./completions.js'),
-    doctor: () => import('./doctor.js'),
-    // Analysis Commands
-    analyze: () => import('./analyze.js'),
-    // Q-Learning Routing Commands
-    route: () => import('./route.js'),
-    // Issue Claims Commands (ADR-016)
-    issues: () => import('./issues.js'),
-    // Auto-update System (ADR-025)
-    update: () => import('./update.js'),
-    // Guidance Control Plane
-    guidance: () => import('./guidance.js'),
-    'transfer-store': () => import('./transfer-store.js'),
-    'store': () => import('./transfer-store.js'),
-    cleanup: () => import('./cleanup.js'),
-    autopilot: () => import('./autopilot.js'),
-    tokens: () => import('./tokens.js'),
-    monograph: () => import('./monograph.js'),
-    replay: () => import('./replay.js'),
-    // Native browser automation (TypeScript CDP client)
-    browse: () => import('./browse.js'),
-    platforms: () => import('./platforms.js'),
-    // Org management (list, delete)
-    org: () => import('./org.js'),
-    // Design tooling (anti-pattern detection)
-    design: () => import('./design-detect.js'),
-    // Enrichment pipeline (T0/T1/T2 progressive content enrichment)
-    enrich: () => import('./enrich.js'),
-    // Universal search across all activated capabilities
-    search: () => import('./search-universal.js'),
-    // Re-scan directory and update capability fingerprint
-    scan: () => import('./scan.js'),
-    'report-crash': () => import('./report-crash.js'),
-    'crash-reporting': () => import('./crash-reporting.js'),
-    // Second Brain document management
-    doc: () => import('./doc.js'),
-};
-// Cache for loaded commands
 const loadedCommands = new Map();
-/**
- * Load a command lazily
- */
-async function loadCommand(name) {
-    if (loadedCommands.has(name)) {
-        return loadedCommands.get(name);
-    }
-    const loader = commandLoaders[name];
-    if (!loader)
-        return undefined;
-    try {
-        const module = await loader();
-        // Try to find the command export (either default or named)
-        const command = (module.default || module[`${name}Command`] || Object.values(module).find((v) => typeof v === 'object' && v !== null && 'name' in v && 'description' in v));
-        if (command) {
-            loadedCommands.set(name, command);
-            return command;
-        }
-    }
-    catch (error) {
-        // Silently fail for missing optional commands
-        if (process.env.DEBUG) {
-            console.error(`Failed to load command ${name}:`, error);
-        }
-    }
-    return undefined;
-}
 // =============================================================================
-// Synchronous Imports for Core Commands (needed immediately at startup)
-// These are the most commonly used commands that need instant access
+// Command Imports
 // =============================================================================
 import { initCommand } from './init.js';
 import { startCommand } from './start.js';
@@ -118,41 +16,28 @@ import { swarmCommand } from './swarm.js';
 import { memoryCommand } from './memory.js';
 import { mcpCommand } from './mcp.js';
 import { hooksCommand } from './hooks.js';
-import { daemonCommand } from './daemon.js';
 import { doctorCommand } from './doctor.js';
-import { neuralCommand } from './neural.js';
 import { performanceCommand } from './performance.js';
 import { securityCommand } from './security.js';
-import { hiveMindCommand } from './hive-mind.js';
 import browseCommand from './browse.js';
-// Additional commands for categorized help display
 import { configCommand } from './config.js';
 import { completionsCommand } from './completions.js';
-import { workflowCommand } from './workflow.js';
 import { analyzeCommand } from './analyze.js';
 import { routeCommand } from './route.js';
 import { providersCommand } from './providers.js';
-import { deploymentCommand } from './deployment.js';
-import { claimsCommand } from './claims.js';
-import { issuesCommand } from './issues.js';
 import updateCommand from './update.js';
-import { processCommand } from './process.js';
 import { guidanceCommand } from './guidance.js';
 import { cleanupCommand } from './cleanup.js';
 import { autopilotCommand } from './autopilot.js';
 import { monographCommand } from './monograph.js';
-import replayCommand from './replay.js';
-import storeCommand from './transfer-store.js';
 import tokensCommand from './tokens.js';
 import { platformsCommand } from './platforms.js';
 import { designCommand } from './design-detect.js';
-import { enrichCommand } from './enrich.js';
 import { searchUniversalCommand } from './search-universal.js';
-import { scanCommand } from './scan.js';
 import { reportCrashCommand } from './report-crash.js';
 import { crashReportingCommand } from './crash-reporting.js';
 import { docCommand } from './doc.js';
-// Pre-populate cache with core commands
+// Populate command cache
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
 loadedCommands.set('status', statusCommand);
@@ -163,32 +48,30 @@ loadedCommands.set('swarm', swarmCommand);
 loadedCommands.set('memory', memoryCommand);
 loadedCommands.set('mcp', mcpCommand);
 loadedCommands.set('hooks', hooksCommand);
-loadedCommands.set('daemon', daemonCommand);
 loadedCommands.set('doctor', doctorCommand);
-loadedCommands.set('neural', neuralCommand);
 loadedCommands.set('performance', performanceCommand);
 loadedCommands.set('security', securityCommand);
-loadedCommands.set('hive-mind', hiveMindCommand);
 loadedCommands.set('guidance', guidanceCommand);
 loadedCommands.set('cleanup', cleanupCommand);
 loadedCommands.set('autopilot', autopilotCommand);
 loadedCommands.set('monograph', monographCommand);
-loadedCommands.set('replay', replayCommand);
-loadedCommands.set('transfer-store', storeCommand);
 loadedCommands.set('tokens', tokensCommand);
 loadedCommands.set('platforms', platformsCommand);
 loadedCommands.set('browse', browseCommand);
+loadedCommands.set('config', configCommand);
+loadedCommands.set('completions', completionsCommand);
+loadedCommands.set('analyze', analyzeCommand);
+loadedCommands.set('route', routeCommand);
+loadedCommands.set('providers', providersCommand);
+loadedCommands.set('update', updateCommand);
 loadedCommands.set('design', designCommand);
-loadedCommands.set('enrich', enrichCommand);
 loadedCommands.set('search', searchUniversalCommand);
-loadedCommands.set('scan', scanCommand);
 loadedCommands.set('report-crash', reportCrashCommand);
 loadedCommands.set('crash-reporting', crashReportingCommand);
 loadedCommands.set('doc', docCommand);
 // =============================================================================
-// Exports (maintain backwards compatibility)
+// Exports
 // =============================================================================
-// Export synchronously loaded commands
 export { initCommand } from './init.js';
 export { startCommand } from './start.js';
 export { statusCommand } from './status.js';
@@ -199,51 +82,23 @@ export { swarmCommand } from './swarm.js';
 export { memoryCommand } from './memory.js';
 export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
-export { daemonCommand } from './daemon.js';
 export { doctorCommand } from './doctor.js';
-export { neuralCommand } from './neural.js';
 export { performanceCommand } from './performance.js';
 export { securityCommand } from './security.js';
-export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { cleanupCommand } from './cleanup.js';
 export { autopilotCommand } from './autopilot.js';
 export { monographCommand } from './monograph.js';
 export { platformsCommand } from './platforms.js';
 export { designCommand } from './design-detect.js';
-export { enrichCommand } from './enrich.js';
 export { searchUniversalCommand } from './search-universal.js';
-export { scanCommand } from './scan.js';
 export { reportCrashCommand } from './report-crash.js';
 export { crashReportingCommand } from './crash-reporting.js';
 export { docCommand } from './doc.js';
-// Lazy-loaded command re-exports (for backwards compatibility, but async-only)
-export async function getConfigCommand() { return loadCommand('config'); }
-export async function getWorkflowCommand() { return loadCommand('workflow'); }
-export async function getHiveMindCommand() { return loadCommand('hive-mind'); }
-export async function getProcessCommand() { return loadCommand('process'); }
-export async function getTaskCommand() { return loadCommand('task'); }
-export async function getSessionCommand() { return loadCommand('session'); }
-export async function getNeuralCommand() { return loadCommand('neural'); }
-export async function getSecurityCommand() { return loadCommand('security'); }
-export async function getPerformanceCommand() { return loadCommand('performance'); }
-export async function getProvidersCommand() { return loadCommand('providers'); }
-export async function getDeploymentCommand() { return loadCommand('deployment'); }
-export async function getClaimsCommand() { return loadCommand('claims'); }
-export async function getCompletionsCommand() { return loadCommand('completions'); }
-export async function getAnalyzeCommand() { return loadCommand('analyze'); }
-export async function getRouteCommand() { return loadCommand('route'); }
-export async function getIssuesCommand() { return loadCommand('issues'); }
-export async function getGuidanceCommand() { return loadCommand('guidance'); }
-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
+ * All registered commands
  */
 export const commands = [
-    // Core commands (synchronously loaded)
     initCommand,
     startCommand,
     statusCommand,
@@ -254,23 +109,27 @@ export const commands = [
     memoryCommand,
     mcpCommand,
     hooksCommand,
-    daemonCommand,
     doctorCommand,
-    neuralCommand,
     performanceCommand,
     securityCommand,
-    hiveMindCommand,
     guidanceCommand,
     cleanupCommand,
     autopilotCommand,
     monographCommand,
     platformsCommand,
     designCommand,
-    enrichCommand,
     searchUniversalCommand,
-    scanCommand,
     docCommand,
     crashReportingCommand,
+    browseCommand,
+    configCommand,
+    completionsCommand,
+    analyzeCommand,
+    routeCommand,
+    providersCommand,
+    updateCommand,
+    tokensCommand,
+    reportCrashCommand,
 ];
 /**
  * Commands organized by category for help display
@@ -290,38 +149,26 @@ export const commandsByCategory = {
         hooksCommand,
     ],
     advanced: [
-        neuralCommand,
         securityCommand,
         performanceCommand,
-        hiveMindCommand,
         guidanceCommand,
         autopilotCommand,
     ],
     utility: [
         configCommand,
         doctorCommand,
-        daemonCommand,
         completionsCommand,
-        workflowCommand,
     ],
     analysis: [
         analyzeCommand,
         routeCommand,
         monographCommand,
-        replayCommand,
         tokensCommand,
-        enrichCommand,
         searchUniversalCommand,
-        scanCommand,
     ],
     management: [
         providersCommand,
-        deploymentCommand,
-        claimsCommand,
-        issuesCommand,
         updateCommand,
-        processCommand,
-        storeCommand,
         cleanupCommand,
         platformsCommand,
         browseCommand,
@@ -329,7 +176,6 @@ export const commandsByCategory = {
 };
 /**
  * Command registry map for quick lookup
- * Supports both sync (core commands) and async (lazy-loaded) commands
  */
 export const commandRegistry = new Map();
 // Register core commands and their aliases
@@ -341,66 +187,27 @@ for (const cmd of commands) {
         }
     }
 }
-/**
- * Get command by name (sync for core commands, returns undefined for lazy commands)
- * Use getCommandAsync for lazy-loaded commands
- */
 export function getCommand(name) {
     return loadedCommands.get(name) || commandRegistry.get(name);
 }
-/**
- * Get command by name (async - supports lazy loading)
- */
 export async function getCommandAsync(name) {
-    // Check already-loaded commands first
-    const cached = loadedCommands.get(name);
-    if (cached)
-        return cached;
-    // Check sync registry
-    const synced = commandRegistry.get(name);
-    if (synced)
-        return synced;
-    // Try lazy loading
-    return loadCommand(name);
+    return loadedCommands.get(name) || commandRegistry.get(name);
 }
-/**
- * Check if command exists (sync check for core commands)
- */
 export function hasCommand(name) {
-    return loadedCommands.has(name) || commandRegistry.has(name) || name in commandLoaders;
+    return loadedCommands.has(name) || commandRegistry.has(name);
 }
-/**
- * Get all command names (including aliases and lazy-loadable)
- */
 export function getCommandNames() {
     const names = new Set([
         ...Array.from(commandRegistry.keys()),
         ...Array.from(loadedCommands.keys()),
-        ...Object.keys(commandLoaders),
     ]);
     return Array.from(names);
 }
-/**
- * Get all unique commands (excluding aliases)
- */
 export function getUniqueCommands() {
     return commands.filter(cmd => !cmd.hidden);
 }
-/**
- * Load all commands (populates lazy-loaded commands)
- * Use this when you need all commands available synchronously
- */
 export async function loadAllCommands() {
-    const allCommands = [...commands];
-    for (const name of Object.keys(commandLoaders)) {
-        if (!loadedCommands.has(name)) {
-            const cmd = await loadCommand(name);
-            if (cmd && !allCommands.includes(cmd)) {
-                allCommands.push(cmd);
-            }
-        }
-    }
-    return allCommands;
+    return [...commands];
 }
 /**
  * Setup commands in a CLI instance
@@ -411,7 +218,7 @@ export function setupCommands(cli) {
     }
 }
 /**
- * Setup all commands including lazy-loaded (async)
+ * Setup all commands (async variant)
  */
 export async function setupAllCommands(cli) {
     const allCommands = await loadAllCommands();

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

@@ -59,7 +59,7 @@ export const wizardCommand = {
                     const skillSets = await multiSelect({
                         message: 'Select skill sets:',
                         options: [
-                            { value: 'core', label: 'Core', hint: 'Swarm, memory, SPARC skills', selected: true },
+                            { value: 'core', label: 'Core', hint: 'Swarm, memory skills', selected: true },
                             { value: 'memory', label: 'Memory (LanceDB)', hint: 'Vector database skills', selected: true },
                             { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
                         ],
@@ -132,16 +132,14 @@ export const wizardCommand = {
             options.runtime.enableNeural = enableNeural;
             if (memoryBackend === 'lancedb' || memoryBackend === 'hybrid') {
                 const enableSelfLearning = await confirm({
-                    message: 'Enable self-learning memory? (LearningBridge + Knowledge Graph + Agent Scopes)',
+                    message: 'Enable self-learning memory? (Knowledge Graph + Agent Scopes)',
                     default: true,
                 });
                 options.runtime.enableLearningBridge = enableSelfLearning && enableNeural;
-                options.runtime.enableMemoryGraph = enableSelfLearning;
                 options.runtime.enableAgentScopes = enableSelfLearning;
             }
             else {
                 options.runtime.enableLearningBridge = false;
-                options.runtime.enableMemoryGraph = false;
                 options.runtime.enableAgentScopes = false;
             }
             const enableEmbeddings = await confirm({
@@ -222,7 +220,7 @@ export const wizardCommand = {
                     { setting: 'Memory Backend', value: options.runtime.memoryBackend },
                     { setting: 'HNSW Indexing', value: options.runtime.enableHNSW ? 'Enabled' : 'Disabled' },
                     { setting: 'Neural Learning', value: options.runtime.enableNeural ? 'Enabled' : 'Disabled' },
-                    { setting: 'Self-Learning', value: options.runtime.enableLearningBridge ? 'LearningBridge + Graph + Scopes' : 'Disabled' },
+                    { setting: 'Self-Learning', value: options.runtime.enableLearningBridge ? 'Graph + Scopes' : 'Disabled' },
                     { setting: 'Embeddings', value: enableEmbeddings ? `${embeddingModel} (hyperbolic)` : 'Disabled' },
                     { setting: 'Skills', value: `${result.summary.skillsCount} installed` },
                     { setting: 'Commands', value: `${result.summary.commandsCount} installed` },

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

@@ -167,11 +167,10 @@ const initAction = async (ctx) => {
         }
         const noStartAll = ctx.flags['no-start-all'] || ctx.flags.noStartAll;
         const startAll = noStartAll ? false : (ctx.flags['start-all'] ?? ctx.flags.startAll ?? true);
-        const startDaemon = ctx.flags['start-daemon'] || ctx.flags.startDaemon || startAll;
-        if (startDaemon || startAll) {
+        if (startAll) {
             output.writeln();
             output.printInfo('Starting services...');
-            const { execSync, spawn: spawnChild } = await import('child_process');
+            const { execSync } = await import('child_process');
             if (startAll) {
                 try {
                     output.writeln(output.dim('  Initializing memory database...'));
@@ -186,17 +185,6 @@ const initAction = async (ctx) => {
                     output.writeln(output.dim('  Memory database already exists'));
                 }
             }
-            if (startDaemon) {
-                try {
-                    output.writeln(output.dim('  Starting daemon...'));
-                    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 {
-                    output.writeln(output.warning('  Daemon may already be running'));
-                }
-            }
             if (startAll) {
                 try {
                     output.writeln(output.dim('  Initializing swarm...'));
@@ -240,10 +228,9 @@ const initAction = async (ctx) => {
                 output.writeln(output.warning('  Embedding initialization skipped (run manually)'));
             }
         }
-        if (!startDaemon && !startAll) {
+        if (!startAll) {
             output.writeln(output.bold('Next steps:'));
             output.printList([
-                `Run ${output.highlight('monomind daemon start')} to start background workers`,
                 `Run ${output.highlight('monomind memory init')} to initialize memory database`,
                 `Run ${output.highlight('monomind swarm init')} to initialize a swarm`,
                 `Services auto-start by default; use ${output.highlight('--no-start-all')} to skip`,
@@ -318,16 +305,10 @@ export const initCommand = {
         },
         {
             name: 'start-all',
-            description: 'Auto-start daemon, memory, and swarm after init (default: true)',
+            description: 'Auto-start memory and swarm after init (default: true)',
             type: 'boolean',
             default: true,
         },
-        {
-            name: 'start-daemon',
-            description: 'Auto-start daemon after init',
-            type: 'boolean',
-            default: false,
-        },
         {
             name: 'no-watch',
             description: 'Skip starting the monograph knowledge graph watcher after init',
@@ -351,7 +332,6 @@ export const initCommand = {
     examples: [
         { command: 'monomind init', description: 'Initialize with default configuration' },
         { command: 'monomind init --no-start-all', description: 'Initialize without auto-starting services' },
-        { command: 'monomind init --start-daemon', description: 'Initialize and start daemon only' },
         { command: 'monomind init --minimal', description: 'Initialize with minimal configuration' },
         { command: 'monomind init --full', description: 'Initialize with all components' },
         { command: 'monomind init --force', description: 'Reinitialize and overwrite existing config' },

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

@@ -455,10 +455,38 @@ const toggleCommand = {
         }
     ],
     action: async (ctx) => {
-        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 };
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const stateFile = path.join('.monomind', 'mcp-disabled-tools.json');
+        let disabled = [];
+        try {
+            disabled = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+        }
+        catch { /* fresh */ }
+        const enableArg = ctx.flags.enable;
+        const disableArg = ctx.flags.disable;
+        if (!enableArg && !disableArg) {
+            output.writeln(output.warning('Provide --enable <tool> or --disable <tool>'));
+            return { success: false, exitCode: 1 };
+        }
+        if (disableArg) {
+            const tools = disableArg.split(',').map(t => t.trim());
+            for (const t of tools) {
+                if (!disabled.includes(t))
+                    disabled.push(t);
+            }
+            output.printSuccess(`Disabled: ${tools.join(', ')}`);
+        }
+        if (enableArg) {
+            const tools = enableArg.split(',').map(t => t.trim());
+            disabled = disabled.filter(t => !tools.includes(t));
+            output.printSuccess(`Enabled: ${tools.join(', ')}`);
+        }
+        fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+        fs.writeFileSync(stateFile, JSON.stringify(disabled, null, 2) + '\n');
+        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.'));
+        return { success: true };
     }
 };
 // Execute tool

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

@@ -1,10 +1,9 @@
 /**
  * Memory Admin Commands
- * deleteCommand, statsCommand, configureCommand, cleanupCommand
+ * deleteCommand, statsCommand, configureCommand
  */
 import type { Command } from '../types.js';
 export declare const deleteCommand: Command;
 export declare const statsCommand: Command;
 export declare const configureCommand: Command;
-export declare const cleanupCommand: Command;
 //# sourceMappingURL=memory-admin.d.ts.map