monomind 2.0.2 → 2.1.0

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

@@ -7,6 +7,19 @@ import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { spawn } from 'child_process';
+/** Check liveness of a pid via a zero-signal, matching the pattern used elsewhere (e.g. .claude/helpers/control-start.cjs). */
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // Default configuration
 const DEFAULT_TOPOLOGY = 'hierarchical-mesh';
 const DEFAULT_MAX_AGENTS = 15;
@@ -92,6 +105,60 @@ const startAction = async (ctx) => {
         output.printInfo('Run "monomind init" first to initialize');
         return { success: false, exitCode: 1 };
     }
+    // Daemon mode, parent side: a Node process cannot truly self-daemonize —
+    // every handle (streams, intervals) would need to be unref'd, which leaves
+    // nothing keeping the event loop alive and the process exits almost
+    // immediately. Instead, spawn a genuine DETACHED CHILD process that
+    // re-invokes this same command with an internal marker flag; the parent's
+    // only job is to confirm the child came up and then exit. The child (see
+    // the `--foreground-worker-internal` branch below) is the one that actually
+    // stays running, with a real ref'd keep-alive.
+    const isDaemonChild = Boolean(ctx.flags['foreground-worker-internal']);
+    if (daemon && !isDaemonChild) {
+        output.writeln();
+        output.writeln(output.bold('Starting Monomind (daemon)'));
+        output.writeln();
+        const daemonPidPath = path.join(cwd, '.monomind', 'daemon.pid');
+        if (fs.existsSync(daemonPidPath)) {
+            const stalePid = Number(fs.readFileSync(daemonPidPath, 'utf-8').trim());
+            if (isPidAlive(stalePid)) {
+                output.printError(`Daemon already running (pid ${stalePid}). Run "monomind stop" first.`);
+                return { success: false, exitCode: 1 };
+            }
+            // Stale pid file — the prior daemon is dead, safe to remove.
+            fs.unlinkSync(daemonPidPath);
+        }
+        // Reconstruct the child's argv explicitly rather than reusing process.argv —
+        // startAction can be reached via `start`, `start quick`, or `restart`
+        // (which calls startAction directly in-process), so process.argv may not
+        // even contain the `start` subcommand. Building the args from ctx.flags
+        // guarantees the respawned child always dispatches to a valid daemon start.
+        const entry = process.argv[1];
+        const childArgs = ['start', '--daemon', '--foreground-worker-internal'];
+        if (topology)
+            childArgs.push('--topology', topology);
+        const child = spawn(process.execPath, [entry, ...childArgs], {
+            detached: true,
+            stdio: 'ignore',
+            cwd,
+        });
+        child.unref();
+        // Give the child a moment to actually start before trusting its pid.
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        if (!child.pid || !isPidAlive(child.pid)) {
+            output.printError('Daemon child process failed to start');
+            return { success: false, exitCode: 1 };
+        }
+        fs.mkdirSync(path.dirname(daemonPidPath), { recursive: true });
+        fs.writeFileSync(daemonPidPath, String(child.pid), { mode: 0o600 });
+        output.printSuccess(`Monomind daemon started (pid ${child.pid})`);
+        output.printInfo('Use "monomind stop" to stop it.');
+        const daemonStartResult = { daemon: true, pid: child.pid, startedAt: new Date().toISOString() };
+        if (ctx.flags.format === 'json') {
+            output.printJson(daemonStartResult);
+        }
+        return { success: true, data: daemonStartResult };
+    }
     // Load configuration
     const config = loadConfig(cwd);
     const swarmConfig = config?.swarm || {};
@@ -147,48 +214,28 @@ const startAction = async (ctx) => {
             `${output.highlight('monomind swarm status')} - View swarm details`,
             `${output.highlight('monomind stop')} - Stop the system`
         ]);
-        // Daemon mode
-        if (daemon) {
+        // Daemon mode: this branch only runs inside the detached child spawned by
+        // the parent-side block above (isDaemonChild === true — the parent never
+        // reaches here, it already returned after confirming the child is alive).
+        // The pid file was already written by the parent with the CHILD's pid, so
+        // just confirm it's in place and start the real, ref'd keep-alive that
+        // actually holds the event loop open.
+        if (daemon && isDaemonChild) {
             output.writeln();
             output.printInfo('Running in daemon mode. Use "monomind stop" to stop.');
-            // Store PID for daemon management.
-            // wx flag refuses to follow a pre-staged symlink at the path; mode 0o600
-            // keeps the file from being world-readable on multi-user systems.
             const daemonPidPath = path.join(cwd, '.monomind', 'daemon.pid');
-            try {
-                fs.writeFileSync(daemonPidPath, String(process.pid), { flag: 'wx', mode: 0o600 });
-            }
-            catch (e) {
-                if (e.code === 'EEXIST') {
-                    // Stale PID file — caller should have verified the prior daemon is dead
-                    fs.unlinkSync(daemonPidPath);
-                    fs.writeFileSync(daemonPidPath, String(process.pid), { flag: 'wx', mode: 0o600 });
-                }
-                else {
-                    throw e;
-                }
-            }
-            // Detach from parent process for true daemon behavior
-            if (process.platform !== 'win32') {
-                // Unix-like systems: create new session
-                try {
-                    process.stdin.unref?.();
-                    process.stdout.unref?.();
-                    process.stderr.unref?.();
-                }
-                catch {
-                    // Ignore errors if streams can't be unref'd
-                }
-            }
-            // Keep process alive in daemon mode
+            // Keep the process alive with a REAL (ref'd) interval — this is what
+            // actually keeps Node's event loop from exiting, since stdio was
+            // already set to 'ignore' by the parent's spawn() call.
             const keepAlive = setInterval(() => {
-                // Heartbeat - check if we should still be running
+                // Heartbeat - exit if our pid file has been removed (e.g. by `stop`)
                 if (!fs.existsSync(daemonPidPath)) {
                     clearInterval(keepAlive);
                     process.exit(0);
                 }
             }, 5000);
-            keepAlive.unref(); // Don't prevent process from exiting if no other work
+            // Deliberately NOT unref'd — this is the one handle that must keep the
+            // daemon child's event loop alive indefinitely.
         }
         const result = {
             swarmId: swarmResult.swarmId,
@@ -267,16 +314,74 @@ const stopCommand = {
             catch {
                 spinner.fail('Swarm was not running');
             }
-            // Clean up daemon PID
+            // Stop the daemon process itself: read its real pid, verify liveness,
+            // send a real termination signal, then wait and confirm it's actually
+            // dead before reporting success — rather than unconditionally deleting
+            // the pid file and claiming success regardless of reality.
             const daemonPidPath = path.join(ctx.cwd, '.monomind', 'daemon.pid');
+            let daemonWasRunning = false;
+            let daemonStopped = true;
+            let daemonPid = null;
             if (fs.existsSync(daemonPidPath)) {
-                fs.unlinkSync(daemonPidPath);
+                const pidStr = fs.readFileSync(daemonPidPath, 'utf-8').trim();
+                const pid = Number(pidStr);
+                daemonPid = Number.isInteger(pid) && pid > 0 ? pid : null;
+                if (daemonPid && isPidAlive(daemonPid)) {
+                    daemonWasRunning = true;
+                    spinner.setText(`Stopping daemon (pid ${daemonPid})...`);
+                    spinner.start();
+                    try {
+                        process.kill(daemonPid, force ? 'SIGKILL' : 'SIGTERM');
+                    }
+                    catch {
+                        // Process may have exited between the liveness check and the signal
+                    }
+                    // Wait and confirm the process actually exited before claiming success.
+                    const waitMs = Math.min(timeout, 10) * 1000;
+                    const deadline = Date.now() + waitMs;
+                    while (Date.now() < deadline && isPidAlive(daemonPid)) {
+                        await new Promise((resolve) => setTimeout(resolve, 200));
+                    }
+                    if (isPidAlive(daemonPid) && force) {
+                        try {
+                            process.kill(daemonPid, 'SIGKILL');
+                        }
+                        catch { /* already gone */ }
+                        await new Promise((resolve) => setTimeout(resolve, 300));
+                    }
+                    daemonStopped = !isPidAlive(daemonPid);
+                    if (daemonStopped) {
+                        spinner.succeed(`Daemon stopped (pid ${daemonPid})`);
+                    }
+                    else {
+                        spinner.fail(`Daemon (pid ${daemonPid}) did not stop within ${waitMs}ms`);
+                    }
+                }
+                // Only clean up the pid file once we've confirmed the process is gone
+                // (or it was already stale) — never delete it while a live daemon
+                // still owns it.
+                if (daemonStopped) {
+                    fs.unlinkSync(daemonPidPath);
+                }
             }
             output.writeln();
-            output.printSuccess('MonoMind stopped successfully');
+            if (!daemonWasRunning) {
+                output.printInfo('No daemon was running.');
+            }
+            else if (daemonStopped) {
+                output.printSuccess(`MonoMind daemon stopped successfully (pid ${daemonPid})`);
+            }
+            else {
+                output.printError(`Failed to stop daemon (pid ${daemonPid}) — it did not exit in time`);
+                return {
+                    success: false,
+                    exitCode: 1,
+                    data: { stopped: false, force, pid: daemonPid }
+                };
+            }
             return {
                 success: true,
-                data: { stopped: true, force, stoppedAt: new Date().toISOString() }
+                data: { stopped: daemonWasRunning ? daemonStopped : null, force, pid: daemonPid, stoppedAt: new Date().toISOString() }
             };
         }
         catch (error) {

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

@@ -6,14 +6,32 @@ import { output } from '../output.js';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { existsSync } from 'fs';
 function getTrackerPath() {
     const __dirname = dirname(fileURLToPath(import.meta.url));
-    // From dist/src/commands/ -> back to project root -> .claude/helpers/
-    return join(__dirname, '..', '..', '..', '..', '..', '..', '.claude', 'helpers', 'token-tracker.cjs');
+    // The CLI package ships its own copy of token-tracker.cjs at the package
+    // root: from dist/src/commands/tokens.js, that's 3 levels up
+    // (dist/src/commands -> dist/src -> dist -> package root), then
+    // .claude/helpers/token-tracker.cjs. Verified empirically — do not "fix"
+    // this by guessing a different depth without re-checking the build output.
+    const bundled = join(__dirname, '..', '..', '..', '.claude', 'helpers', 'token-tracker.cjs');
+    if (existsSync(bundled))
+        return bundled;
+    // Fall back to a copy in the user's own project (e.g. a stripped install
+    // that dropped .claude/helpers, or a monorepo checkout like this one where
+    // the user's cwd has its own tracker copy).
+    const cwdCopy = join(process.cwd(), '.claude', 'helpers', 'token-tracker.cjs');
+    if (existsSync(cwdCopy))
+        return cwdCopy;
+    return null;
 }
 function loadTracker() {
+    const trackerPath = getTrackerPath();
+    if (!trackerPath) {
+        throw new Error('token-tracker.cjs not found (checked bundled package copy and cwd/.claude/helpers)');
+    }
     const require = createRequire(import.meta.url);
-    return require(getTrackerPath());
+    return require(trackerPath);
 }
 const VALID_PERIODS = new Set(['today', 'week', '30days', 'month']);
 function validatePeriod(raw) {

package/packages/@monomind/cli/dist/src/config-adapter.js

@@ -2,6 +2,23 @@
  * Configuration Adapter
  * Converts between SystemConfig and MonomindConfig types
  */
+// Share fallback values with config-file-manager.ts's own DEFAULT_CONFIG so
+// a config that round-trips through this adapter doesn't silently diverge
+// from what `monomind config create`/`reset` would produce (e.g. maxAgents
+// 8 vs a separately-hardcoded 15, hooks.enabled true vs false).
+import { DEFAULT_CONFIG } from './services/config-file-manager.js';
+// structuredClone so nested arrays/objects (e.g. hooks.hooks) returned by
+// systemConfigToMonomindConfig() below are never the live DEFAULT_CONFIG
+// reference — matches config-file-manager.ts's own cloneDefaultConfig() fix,
+// which this file's direct DEFAULT_CONFIG import would otherwise bypass.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const AGENTS_DEFAULTS = structuredClone(DEFAULT_CONFIG.agents);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const SWARM_DEFAULTS = structuredClone(DEFAULT_CONFIG.swarm);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const CLI_DEFAULTS = structuredClone(DEFAULT_CONFIG.cli);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const HOOKS_DEFAULTS = structuredClone(DEFAULT_CONFIG.hooks);
 /**
  * Convert SystemConfig to MonomindConfig (CLI-specific format)
  */
@@ -11,19 +28,19 @@ export function systemConfigToMonomindConfig(systemConfig) {
         projectRoot: systemConfig.orchestrator?.session?.dataDir || process.cwd(),
         // Agent configuration
         agents: {
-            defaultType: 'coder',
-            autoSpawn: false, // Not in SystemConfig
-            maxConcurrent: systemConfig.orchestrator?.lifecycle?.maxConcurrentAgents ?? 15,
-            timeout: systemConfig.orchestrator?.lifecycle?.spawnTimeout ?? 300000,
+            defaultType: systemConfig.agents?.defaultType ?? AGENTS_DEFAULTS.defaultType,
+            autoSpawn: systemConfig.agents?.autoSpawn ?? AGENTS_DEFAULTS.autoSpawn,
+            maxConcurrent: systemConfig.orchestrator?.lifecycle?.maxConcurrentAgents ?? AGENTS_DEFAULTS.maxConcurrent,
+            timeout: systemConfig.orchestrator?.lifecycle?.spawnTimeout ?? AGENTS_DEFAULTS.timeout,
             providers: [],
         },
         // Swarm configuration
         swarm: {
             topology: normalizeTopology(systemConfig.swarm?.topology),
-            maxAgents: systemConfig.swarm?.maxAgents ?? 15,
-            autoScale: systemConfig.swarm?.autoScale?.enabled ?? false,
+            maxAgents: systemConfig.swarm?.maxAgents ?? SWARM_DEFAULTS.maxAgents,
+            autoScale: systemConfig.swarm?.autoScale?.enabled ?? SWARM_DEFAULTS.autoScale,
             coordinationStrategy: systemConfig.swarm?.coordination?.consensusRequired ? 'consensus' : 'leader',
-            healthCheckInterval: systemConfig.swarm?.coordination?.timeoutMs ?? 10000,
+            healthCheckInterval: systemConfig.swarm?.coordination?.timeoutMs ?? SWARM_DEFAULTS.healthCheckInterval,
         },
         // Memory configuration
         memory: {
@@ -41,19 +58,22 @@ export function systemConfigToMonomindConfig(systemConfig) {
             transportType: systemConfig.mcp?.transport?.type || 'stdio',
             tools: [], // Not in SystemConfig
         },
-        // CLI preferences
+        // CLI preferences — read from SystemConfig.cli when present, falling
+        // back to the shared DEFAULT_CONFIG.cli values (not separately
+        // hardcoded numbers that could silently drop user-configured values).
         cli: {
-            colorOutput: true,
-            interactive: true,
-            verbosity: 'normal',
-            outputFormat: 'text',
-            progressStyle: 'spinner',
+            colorOutput: systemConfig.cli?.colorOutput ?? CLI_DEFAULTS.colorOutput,
+            interactive: systemConfig.cli?.interactive ?? CLI_DEFAULTS.interactive,
+            verbosity: systemConfig.cli?.verbosity ?? CLI_DEFAULTS.verbosity,
+            outputFormat: systemConfig.cli?.outputFormat ?? CLI_DEFAULTS.outputFormat,
+            progressStyle: systemConfig.cli?.progressStyle ?? CLI_DEFAULTS.progressStyle,
         },
-        // Hooks configuration
+        // Hooks configuration — likewise read from SystemConfig.hooks when
+        // present, falling back to the shared DEFAULT_CONFIG.hooks values.
         hooks: {
-            enabled: false,
-            autoExecute: false,
-            hooks: [],
+            enabled: systemConfig.hooks?.enabled ?? HOOKS_DEFAULTS.enabled,
+            autoExecute: systemConfig.hooks?.autoExecute ?? HOOKS_DEFAULTS.autoExecute,
+            hooks: systemConfig.hooks?.hooks ?? HOOKS_DEFAULTS.hooks,
         },
         // Neural pattern-learning configuration
         neural: {

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

@@ -82,12 +82,16 @@ export class CLI {
                 this.output.printDebug(`Flags: ${JSON.stringify(Object.fromEntries(Object.entries(flags).filter(([k]) => k !== '_')))}`);
                 this.output.printDebug(`CWD: ${process.cwd()}`);
             }
-            // Run startup update check (non-blocking, silent on skip)
-            if (!flags.noUpdate && commandPath[0] !== 'update') {
+            // Run startup update check (non-blocking, silent on skip).
+            // `update` is now a properly-declared global boolean option (default
+            // true) — `--no-update` negates it via the parser's standard boolean
+            // negation path rather than relying on the generic --no-X fallback
+            // (which checked the flag name against the GLOBAL pool of every
+            // command's boolean options, so an unrelated command declaring its
+            // own `update` boolean flag could hijack `--no-update`'s meaning).
+            if (flags.update !== false && commandPath[0] !== 'update') {
                 this.checkForUpdatesOnStartup().catch(() => { });
             }
-            // Initialize optional subsystems (non-blocking — never delay CLI startup)
-            this.initSubsystems().catch(() => { });
             // Handle lazy-loaded commands that weren't recognized by the parser
             // If commandPath is empty but positional has a command name, check if it's lazy-loadable
             if (commandPath.length === 0 && positional.length > 0 && !positional[0].startsWith('-')) {
@@ -101,8 +105,11 @@ export class CLI {
             // No command - show help or suggest correction
             if (commandPath.length === 0 || flags.help || flags.h) {
                 if (commandPath.length > 0) {
-                    // Show command-specific help
-                    await this.showCommandHelp(commandPath[0]);
+                    // Show help for the fully-resolved (sub)command — walking the same
+                    // path the dispatcher below resolves — not just the top-level
+                    // parent's subcommand list. `monomind memory store --help` should
+                    // show `store`'s own options, not memory's list of subcommands.
+                    await this.showCommandHelp(commandPath);
                 }
                 else if (positional.length > 0 && !positional[0].startsWith('-')) {
                     // First positional looks like an attempted command - suggest correction
@@ -135,6 +142,13 @@ export class CLI {
                 this.output.writeln(this.output.dim(`  ${message}`));
                 process.exit(1);
             }
+            // Initialize optional subsystems (non-blocking — never delay CLI
+            // startup). Deliberately placed AFTER the --help/--version/unknown-
+            // command short-circuits above: those paths don't touch project state,
+            // so running this here means `monomind --help` (or any invocation in a
+            // directory that's never been a monomind project) no longer creates
+            // .monomind/registry.json as a side effect of just asking for help.
+            this.initSubsystems().catch(() => { });
             // Handle subcommand (supports nested subcommands)
             let targetCommand = command;
             let subcommandArgs = positional;
@@ -208,8 +222,8 @@ export class CLI {
                 }
             }
             else {
-                // No action - show command help
-                await this.showCommandHelp(commandName);
+                // No action - show help for the resolved (sub)command path
+                await this.showCommandHelp(commandPath.length > 0 ? commandPath : [commandName]);
             }
         }
         catch (error) {
@@ -308,24 +322,40 @@ export class CLI {
     /**
      * Show command-specific help
      */
-    async showCommandHelp(commandName) {
+    async showCommandHelp(commandPath) {
+        const path = Array.isArray(commandPath) ? commandPath : [commandPath];
+        const topName = path[0];
         // Try sync first, then lazy load
-        let command = getCommand(commandName);
-        if (!command && hasCommand(commandName)) {
-            command = await getCommandAsync(commandName);
+        let command = getCommand(topName);
+        if (!command && hasCommand(topName)) {
+            command = await getCommandAsync(topName);
         }
         if (!command) {
-            this.output.printError(`Unknown command: ${commandName}`);
+            this.output.printError(`Unknown command: ${topName}`);
             return;
         }
+        // Walk the remaining path segments through subcommands/nested
+        // subcommands — mirrors the resolution the dispatcher uses in run() —
+        // so `monomind <command> <subcommand> --help` shows the actual target
+        // (sub)command's own options and examples, not just the parent's list
+        // of subcommands.
+        let target = command;
+        const resolvedNames = [command.name];
+        for (const segment of path.slice(1)) {
+            const next = target.subcommands?.find(sc => sc.name === segment || sc.aliases?.includes(segment));
+            if (!next)
+                break;
+            target = next;
+            resolvedNames.push(next.name);
+        }
         this.output.writeln();
-        this.output.writeln(this.output.bold(`${this.name} ${command.name}`));
-        this.output.writeln(command.description);
+        this.output.writeln(this.output.bold(`${this.name} ${resolvedNames.join(' ')}`));
+        this.output.writeln(target.description);
         this.output.writeln();
         // Subcommands
-        if (command.subcommands && command.subcommands.length > 0) {
+        if (target.subcommands && target.subcommands.length > 0) {
             this.output.writeln(this.output.bold('SUBCOMMANDS:'));
-            for (const sub of command.subcommands) {
+            for (const sub of target.subcommands) {
                 if (sub.hidden)
                     continue;
                 const name = sub.name.padEnd(15);
@@ -335,9 +365,9 @@ export class CLI {
             this.output.writeln();
         }
         // Options
-        if (command.options && command.options.length > 0) {
+        if (target.options && target.options.length > 0) {
             this.output.writeln(this.output.bold('OPTIONS:'));
-            for (const opt of command.options) {
+            for (const opt of target.options) {
                 const flags = opt.short ? `-${opt.short}, --${opt.name}` : `    --${opt.name}`;
                 const required = opt.required ? this.output.error(' (required)') : '';
                 const defaultVal = opt.default !== undefined ? this.output.dim(` [default: ${opt.default}]`) : '';
@@ -346,9 +376,9 @@ export class CLI {
             this.output.writeln();
         }
         // Examples
-        if (command.examples && command.examples.length > 0) {
+        if (target.examples && target.examples.length > 0) {
             this.output.writeln(this.output.bold('EXAMPLES:'));
-            for (const example of command.examples) {
+            for (const example of target.examples) {
                 this.output.writeln(`  ${this.output.dim('$')} ${example.command}`);
                 this.output.writeln(`    ${this.output.dim(example.description)}`);
             }
@@ -392,16 +422,22 @@ export class CLI {
      * Load configuration file
      */
     async loadConfig(configPath) {
+        const { configManager } = await import('./services/config-file-manager.js');
+        // An explicit --config/-c path names an EXACT file — load it directly
+        // instead of directory-searching from its dirname (which previously
+        // discarded the filename the user gave and either loaded an unrelated
+        // monomind.config.json from that directory or found nothing). Failure
+        // to find/parse an explicitly-named config file is a loud error, not a
+        // silent fallback to defaults.
+        if (configPath) {
+            const raw = configManager.loadExact(configPath);
+            return raw;
+        }
         try {
-            const { configManager } = await import('./services/config-file-manager.js');
-            const cwd = configPath
-                ? (await import('path')).dirname(configPath)
-                : process.cwd();
-            const raw = configManager.load(cwd);
+            const raw = configManager.load(process.cwd());
             if (!raw)
                 return undefined;
-            const config = raw;
-            return config;
+            return raw;
         }
         catch (error) {
             // Config loading is optional - don't fail if it doesn't exist

package/packages/@monomind/cli/dist/src/init/claudemd-generator.js

@@ -6,6 +6,32 @@
  * Templates: minimal | standard | full | security | performance | solo
  * All templates use bullet-format rules with imperative keywords for enforceability.
  */
+import { createRequire } from 'module';
+let _availabilityCache = null;
+function detectOptionalPackages() {
+    if (_availabilityCache)
+        return _availabilityCache;
+    const req = createRequire(import.meta.url);
+    const resolvable = (pkg) => {
+        try {
+            req.resolve(pkg);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    _availabilityCache = {
+        hooks: resolvable('@monomind/hooks'),
+        mcp: resolvable('@monomind/mcp'),
+        routing: resolvable('@monomind/routing'),
+        monofence: resolvable('monofence-ai'),
+    };
+    return _availabilityCache;
+}
+function unavailNote(available) {
+    return available ? '' : ' _(unavailable in this install)_';
+}
 // --- Section Generators (each returns enforceable markdown) ---
 function behavioralRules() {
     return `## Behavioral Rules (Always Enforced)
@@ -156,20 +182,25 @@ function executionRules() {
 - When agent results arrive, review ALL results before proceeding`;
 }
 function cliCommandsTable() {
-    return `## V1 CLI Commands
+    const avail = detectOptionalPackages();
+    return `## CLI Commands
 
 ### Core Commands
 
 | Command | Subcommands | Description |
 |---------|-------------|-------------|
-| \`init\` | 4 | Project initialization |
-| \`agent\` | 8 | Agent lifecycle management |
+| \`init\` | 5 | Project initialization |
+| \`agent\` | 7 | Agent lifecycle management |
 | \`swarm\` | 6 | Multi-agent swarm coordination |
-| \`memory\` | 11 | LanceDB memory with ANN search |
-| \`task\` | 6 | Task creation and lifecycle |
-| \`session\` | 7 | Session state management |
-| \`hooks\` | 17 | Self-learning hooks + 12 workers |
-| \`hive-mind\` | 6 | Byzantine fault-tolerant consensus |
+| \`memory\` | 12 | LanceDB memory with ANN search |
+| \`task\` | 5 | Task creation and lifecycle |
+| \`session\` | 6 | Session state management |
+| \`hooks\` | 29 | Self-learning hooks + 15 background workers${unavailNote(avail.hooks)} |
+
+> Note: there is no \`hive-mind\` or \`neural\` CLI command. Hive-mind
+> consensus (byzantine/raft/quorum) is available exclusively via MCP tools
+> (\`hive-mind_*\`), not the CLI. Neural pattern learning was merged into
+> \`hooks intelligence\`.
 
 ### Quick CLI Examples
 
@@ -197,7 +228,8 @@ function agentTypes() {
 \`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\``;
 }
 function hooksSystem() {
-    return `## Hooks System (27 Hooks + 12 Workers)
+    const avail = detectOptionalPackages();
+    return `## Hooks System (29 Hook Subcommands + 15 Background Workers)
 
 ### Essential Hooks
 
@@ -210,7 +242,7 @@ function hooksSystem() {
 | \`intelligence\` | Pattern-learning intelligence system |
 | \`worker\` | Background worker management |
 
-### Background Workers (@monomind/hooks, run in-process)
+### Background Workers (@monomind/hooks, run in-process)${unavailNote(avail.hooks)}
 
 | Worker | Priority | Description |
 |--------|----------|-------------|
@@ -220,9 +252,10 @@ function hooksSystem() {
 | \`consolidate\` | low | Memory consolidation |
 | \`ddd\` | low | DDD progress tracking |
 | \`security\` | high | Secret/vulnerability scan |
+| \`performance\`, \`health\`, \`swarm\`, \`git\`, \`learning\`, \`adr\`, \`patterns\`, \`cache\`, \`progress\` | various | See \`hooks worker list\` for the full 15 |
 
 Metrics-producing workers refresh at session start when output is >6h old.
-
+${avail.hooks ? '' : '\n> \\@monomind/hooks is not resolvable in this install — background workers will fail to load (see `hooks worker list`). This is an install/publish gap, not a project misconfiguration.\n'}
 \`\`\`bash
 npx monomind@latest hooks pre-task --description "[task]"
 npx monomind@latest hooks post-task --task-id "[id]" --success true