monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/dist/src/commands/hive-mind.js

@@ -1,9 +1,9 @@
 /**
  * CLI Hive Mind Command
- * Queen-led consensus-based multi-agent coordination
- *
- * Updated to support --claude flag for launching interactive Claude Code sessions
- * PR: Fix #955 - Implement --claude flag for hive-mind spawn command
+ * Single-process vote-counting coordination for multi-agent decisions.
+ * Consensus strategies (BFT, Raft, Quorum) implement threshold arithmetic
+ * with Ed25519 vote signing — not distributed networking protocols.
+ * Gossip and CRDT strategies are planned but not yet implemented.
  */
 import { output } from '../output.js';
 import { select } from '../prompt.js';
@@ -43,12 +43,15 @@ const initCommand = {
                 default: 'byzantine'
             });
         }
+        // Note: the parser normalizes all flag keys to camelCase (kebab-case keys
+        // like 'max-agents' never land in ctx.flags — only 'maxAgents' does), so
+        // the camelCase form must be read first here.
         const config = {
             topology: topology || 'hierarchical-mesh',
             consensus: consensus || 'byzantine',
-            maxAgents: ctx.flags['max-agents'] || 15,
+            maxAgents: ctx.flags.maxAgents ?? ctx.flags['max-agents'] ?? 15,
             persist: ctx.flags.persist,
-            memoryBackend: ctx.flags['memory-backend'] || 'hybrid'
+            memoryBackend: ctx.flags.memoryBackend || ctx.flags['memory-backend'] || 'hybrid'
         };
         output.writeln();
         output.writeln(output.bold('Initializing Hive Mind'));

package/packages/@monomind/cli/dist/src/commands/hooks-formatting.d.ts

@@ -1,13 +1,9 @@
 /**
  * Display formatting helpers for hooks commands.
- * Extracted from hooks.ts (ARCH-1) — formatIntelligenceStatus and formatWorkerStatus.
+ * Extracted from hooks.ts (ARCH-1) — formatIntelligenceStatus.
  */
 /**
  * Format an intelligence component status string with colour coding.
  */
 export declare function formatIntelligenceStatus(status: string): string;
-/**
- * Format a background worker status string with colour coding.
- */
-export declare function formatWorkerStatus(status: string): string;
 //# sourceMappingURL=hooks-formatting.d.ts.map

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

@@ -1,6 +1,6 @@
 /**
  * Display formatting helpers for hooks commands.
- * Extracted from hooks.ts (ARCH-1) — formatIntelligenceStatus and formatWorkerStatus.
+ * Extracted from hooks.ts (ARCH-1) — formatIntelligenceStatus.
  */
 import { output } from '../output.js';
 /**
@@ -22,21 +22,4 @@ export function formatIntelligenceStatus(status) {
             return status;
     }
 }
-/**
- * Format a background worker status string with colour coding.
- */
-export function formatWorkerStatus(status) {
-    switch (status) {
-        case 'running':
-            return output.highlight(status);
-        case 'completed':
-            return output.success(status);
-        case 'failed':
-            return output.error(status);
-        case 'pending':
-            return output.dim(status);
-        default:
-            return status;
-    }
-}
 //# sourceMappingURL=hooks-formatting.js.map

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

@@ -1,6 +1,6 @@
 /**
  * Hooks Worker Commands
- * Background worker management (12 workers) + Intelligence command
+ * Background worker management (@monomind/hooks workers) + Intelligence command
  * Extracted from hooks.ts to reduce file size.
  */
 import type { Command } from '../types.js';

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

@@ -1,19 +1,34 @@
 /**
  * Hooks Worker Commands
- * Background worker management (12 workers) + Intelligence command
+ * Background worker management (@monomind/hooks workers) + Intelligence command
  * Extracted from hooks.ts to reduce file size.
  */
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { statSync, readFileSync } from 'node:fs';
-import { formatIntelligenceStatus, formatWorkerStatus } from './hooks-formatting.js';
+import { formatIntelligenceStatus } from './hooks-formatting.js';
+import { statusCommand as patternStatusCommand, patternsCommand, trainCommand, predictCommand, } from './neural-core.js';
+import { optimizeCommand, exportCommand } from './neural-optimize.js';
+import { listCommand as registryListCommand, importCommand } from './neural-registry.js';
 // =============================================================================
-// Intelligence subcommand (JS pattern/trajectory logging)
+// Intelligence subcommand (JS pattern/trajectory logging + pattern store)
+// Pattern store subcommands (train, status, patterns, predict, optimize,
+// export, list, import) were merged in from the former `neural` command.
 // =============================================================================
 export const intelligenceCommand = {
     name: 'intelligence',
-    description: 'JS pattern/trajectory logging (stats, pattern-*, trajectory-*)',
+    description: 'JS pattern/trajectory logging and pattern store (train, patterns, predict, optimize, export, list, import)',
+    subcommands: [
+        trainCommand,
+        patternStatusCommand,
+        patternsCommand,
+        predictCommand,
+        optimizeCommand,
+        registryListCommand,
+        exportCommand,
+        importCommand,
+    ],
     options: [
         {
             name: 'mode',
@@ -73,7 +88,10 @@ export const intelligenceCommand = {
     examples: [
         { command: 'monomind hooks intelligence --status', description: 'Show intelligence status' },
         { command: 'monomind hooks intelligence -m real-time', description: 'Enable real-time mode' },
-        { command: 'monomind hooks intelligence --train', description: 'Force training cycle' }
+        { command: 'monomind hooks intelligence --train', description: 'Force training cycle' },
+        { command: 'monomind hooks intelligence patterns --action list', description: 'List stored patterns' },
+        { command: 'monomind hooks intelligence predict -i "implement auth"', description: 'Find similar patterns for a task' },
+        { command: 'monomind hooks intelligence train', description: 'Ingest outcome/edit history into the pattern store' }
     ],
     action: async (ctx) => {
         const mode = ctx.flags.mode || 'balanced';
@@ -390,339 +408,94 @@ export const intelligenceCommand = {
     }
 };
 // =============================================================================
-// Worker Commands (12 Background Workers)
+// Worker Commands (@monomind/hooks WorkerManager)
 // =============================================================================
+// The old worker subcommands (dispatch/status/detect/cancel) dispatched to a
+// simulated in-memory tracker that fronted the deleted worker daemon. The
+// surviving commands run the real @monomind/hooks workers in-process.
 const workerListCommand = {
     name: 'list',
-    description: 'List all 12 background workers with capabilities',
-    options: [
-        { name: 'status', short: 's', type: 'string', description: 'Filter by status (all, running, completed, pending)' },
-        { name: 'active', short: 'a', type: 'boolean', description: 'Show active worker instances' },
-    ],
+    description: 'List all @monomind/hooks background workers',
+    options: [],
     examples: [
         { command: 'monomind hooks worker list', description: 'List all workers' },
-        { command: 'monomind hooks worker list --active', description: 'Show active instances' },
     ],
-    action: async (ctx) => {
-        const spinner = output.createSpinner({ text: 'Loading workers...', spinner: 'dots' });
-        spinner.start();
+    action: async () => {
         try {
-            const result = await callMCPTool('hooks_worker-list', {
-                status: ctx.flags['status'] || 'all',
-                includeActive: ctx.flags['active'] !== false,
-            });
-            spinner.succeed('Workers loaded');
+            const hooks = await import('@monomind/hooks');
+            const workers = Object.values(hooks.WORKER_CONFIGS).map(w => ({
+                name: w.name,
+                description: w.description,
+                priority: hooks.WorkerPriority[w.priority],
+                enabled: w.enabled ? 'yes' : 'no',
+            }));
             output.writeln();
-            output.writeln(output.bold('Background Workers (12 Total)'));
+            output.writeln(output.bold(`Background Workers (${workers.length} Total)`));
             output.writeln();
             output.printTable({
                 columns: [
-                    { key: 'trigger', header: 'Worker', width: 14 },
-                    { key: 'priority', header: 'Priority', width: 10 },
-                    { key: 'estimatedDuration', header: 'Est. Time', width: 10 },
-                    { key: 'description', header: 'Description', width: 40 },
+                    { key: 'name', header: 'Worker', width: 14 },
+                    { key: 'priority', header: 'Priority', width: 12 },
+                    { key: 'enabled', header: 'Enabled', width: 8 },
+                    { key: 'description', header: 'Description', width: 60 },
                 ],
-                data: result.workers.map(w => ({
-                    trigger: output.highlight(w.trigger),
-                    priority: w.priority === 'critical' ? output.error(w.priority) :
-                        w.priority === 'high' ? output.warning(w.priority) :
-                            w.priority,
-                    estimatedDuration: w.estimatedDuration,
-                    description: w.description,
-                })),
+                data: workers,
             });
-            if (ctx.flags['active'] && result.active.count > 0) {
-                output.writeln();
-                output.writeln(output.bold('Active Instances'));
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Worker ID', width: 35 },
-                        { key: 'trigger', header: 'Type', width: 12 },
-                        { key: 'status', header: 'Status', width: 12 },
-                        { key: 'progress', header: 'Progress', width: 10 },
-                    ],
-                    data: result.active.instances.map(w => ({
-                        id: w.id,
-                        trigger: w.trigger,
-                        status: w.status === 'running' ? output.highlight(w.status) :
-                            w.status === 'completed' ? output.success(w.status) :
-                                w.status === 'failed' ? output.error(w.status) : w.status,
-                        progress: `${w.progress}%`,
-                    })),
-                });
-            }
             output.writeln();
-            output.writeln(output.dim('Performance targets:'));
-            output.writeln(output.dim(`  Trigger detection: ${result.performanceTargets.triggerDetection}`));
-            output.writeln(output.dim(`  Worker spawn: ${result.performanceTargets.workerSpawn}`));
-            output.writeln(output.dim(`  Max concurrent: ${result.performanceTargets.maxConcurrent}`));
-            return { success: true, data: result };
+            output.writeln(output.dim('Run a worker: monomind hooks worker run <name>'));
+            return { success: true, data: { workers, total: workers.length } };
         }
         catch (error) {
-            spinner.fail('Failed to load workers');
-            if (error instanceof MCPClientError) {
-                output.printError(`Worker error: ${error.message}`);
-            }
+            output.printError(`Failed to load workers: ${error instanceof Error ? error.message : String(error)}`);
             return { success: false, exitCode: 1 };
         }
     }
 };
-const workerDispatchCommand = {
-    name: 'dispatch',
-    description: 'Dispatch a background worker for analysis/optimization',
+const workerRunCommand = {
+    name: 'run',
+    description: 'Run a background worker once, in-process',
     options: [
-        { name: 'trigger', short: 't', type: 'string', description: 'Worker type (ultralearn, optimize, audit, map, etc.)', required: true },
-        { name: 'context', short: 'c', type: 'string', description: 'Context for the worker (file path, topic)' },
-        { name: 'priority', short: 'p', type: 'string', description: 'Priority (low, normal, high, critical)' },
-        { name: 'sync', short: 's', type: 'boolean', description: 'Wait for completion (synchronous)' },
+        { name: 'name', short: 'n', type: 'string', description: 'Worker name (see: hooks worker list)' },
     ],
     examples: [
-        { command: 'monomind hooks worker dispatch -t optimize -c src/', description: 'Dispatch optimize worker' },
-        { command: 'monomind hooks worker dispatch -t audit -p critical', description: 'Security audit with critical priority' },
-        { command: 'monomind hooks worker dispatch -t testgaps --sync', description: 'Test coverage analysis (sync)' },
+        { command: 'monomind hooks worker run map', description: 'Refresh .monomind/metrics/codebase-map.json' },
+        { command: 'monomind hooks worker run audit', description: 'Refresh .monomind/metrics/security-audit.json' },
+        { command: 'monomind hooks worker run ddd', description: 'Refresh .monomind/metrics/ddd-progress.json' },
     ],
     action: async (ctx) => {
-        const trigger = ctx.flags['trigger'];
-        const context = ctx.flags['context'] || 'default';
-        const priority = ctx.flags['priority'];
-        const background = !ctx.flags['sync'];
-        if (!trigger) {
-            output.printError('--trigger is required');
-            output.writeln('Available triggers: ultralearn, optimize, consolidate, predict, audit, map, preload, deepdive, document, refactor, benchmark, testgaps');
+        const name = ctx.args[0] || ctx.flags['name'];
+        if (!name) {
+            output.printError('Worker name is required: monomind hooks worker run <name>');
+            output.writeln('See available workers: monomind hooks worker list');
             return { success: false, exitCode: 1 };
         }
-        const spinner = output.createSpinner({ text: `Dispatching ${trigger} worker...`, spinner: 'dots' });
+        const spinner = output.createSpinner({ text: `Running ${name} worker...`, spinner: 'dots' });
         spinner.start();
         try {
-            const result = await callMCPTool('hooks_worker-dispatch', {
-                trigger,
-                context,
-                priority,
-                background,
-            });
-            if (!result.success) {
-                spinner.fail(`Failed: ${result.error}`);
+            const hooks = await import('@monomind/hooks');
+            if (!hooks.WORKER_CONFIGS[name]) {
+                spinner.fail(`Unknown worker: ${name}`);
+                output.writeln(`Available workers: ${Object.keys(hooks.WORKER_CONFIGS).join(', ')}`);
                 return { success: false, exitCode: 1 };
             }
-            spinner.succeed(`Worker dispatched: ${result.workerId}`);
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'field', header: 'Field', width: 18 },
-                    { key: 'value', header: 'Value', width: 50 },
-                ],
-                data: [
-                    { field: 'Worker ID', value: output.highlight(result.workerId) },
-                    { field: 'Trigger', value: result.trigger },
-                    { field: 'Context', value: result.context },
-                    { field: 'Priority', value: result.priority },
-                    { field: 'Description', value: result.config.description },
-                    { field: 'Est. Duration', value: result.config.estimatedDuration },
-                    { field: 'Capabilities', value: result.config.capabilities.join(', ') },
-                    { field: 'Status', value: result.status === 'dispatched' ? output.highlight('dispatched (background)') : output.success('completed') },
-                ],
-            });
-            if (background) {
-                output.writeln();
-                output.writeln(output.dim(`Check status: monomind hooks worker status --id ${result.workerId}`));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Worker dispatch failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Dispatch error: ${error.message}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-const workerStatusCommand = {
-    name: 'status',
-    description: 'Get status of workers',
-    options: [
-        { name: 'id', type: 'string', description: 'Specific worker ID to check' },
-        { name: 'all', short: 'a', type: 'boolean', description: 'Include completed workers' },
-    ],
-    examples: [
-        { command: 'monomind hooks worker status', description: 'Show running workers' },
-        { command: 'monomind hooks worker status --id worker_audit_1', description: 'Check specific worker' },
-        { command: 'monomind hooks worker status --all', description: 'Include completed workers' },
-    ],
-    action: async (ctx) => {
-        const workerId = ctx.flags['id'];
-        const includeCompleted = ctx.flags['all'];
-        const spinner = output.createSpinner({ text: 'Checking worker status...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-status', {
-                workerId,
-                includeCompleted,
-            });
+            const manager = hooks.createWorkerManager(process.cwd());
+            const result = await manager.runWorker(name);
             if (!result.success) {
-                spinner.fail(`Failed: ${result.error}`);
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed('Status retrieved');
-            if (result.worker) {
-                output.writeln();
-                output.writeln(output.bold(`Worker: ${result.worker.id}`));
-                output.printTable({
-                    columns: [
-                        { key: 'field', header: 'Field', width: 15 },
-                        { key: 'value', header: 'Value', width: 40 },
-                    ],
-                    data: [
-                        { field: 'Trigger', value: result.worker.trigger },
-                        { field: 'Context', value: result.worker.context },
-                        { field: 'Status', value: formatWorkerStatus(result.worker.status) },
-                        { field: 'Progress', value: `${result.worker.progress}%` },
-                        { field: 'Phase', value: result.worker.phase },
-                        { field: 'Duration', value: `${result.worker.duration}ms` },
-                    ],
-                });
-            }
-            else if (result.workers && result.workers.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Active Workers'));
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Worker ID', width: 35 },
-                        { key: 'trigger', header: 'Type', width: 12 },
-                        { key: 'status', header: 'Status', width: 12 },
-                        { key: 'progress', header: 'Progress', width: 10 },
-                        { key: 'duration', header: 'Duration', width: 12 },
-                    ],
-                    data: result.workers.map(w => ({
-                        id: w.id,
-                        trigger: w.trigger,
-                        status: formatWorkerStatus(w.status),
-                        progress: `${w.progress}%`,
-                        duration: `${w.duration}ms`,
-                    })),
-                });
-                if (result.summary) {
-                    output.writeln();
-                    output.writeln(output.dim(`Total: ${result.summary.total} | Running: ${result.summary.running} | Completed: ${result.summary.completed} | Failed: ${result.summary.failed}`));
-                }
+                spinner.fail(`Worker ${name} failed: ${result.error || 'unknown error'}`);
+                return { success: false, exitCode: 1, data: result };
             }
-            else {
-                output.writeln();
-                output.writeln(output.dim('No active workers'));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Status check failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Status error: ${error.message}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-const workerDetectCommand = {
-    name: 'detect',
-    description: 'Detect worker triggers from prompt text',
-    options: [
-        { name: 'prompt', short: 'p', type: 'string', description: 'Prompt text to analyze', required: true },
-        { name: 'auto-dispatch', short: 'a', type: 'boolean', description: 'Automatically dispatch detected workers' },
-        { name: 'min-confidence', short: 'm', type: 'string', description: 'Minimum confidence threshold (0-1)' },
-    ],
-    examples: [
-        { command: 'monomind hooks worker detect -p "optimize performance"', description: 'Detect triggers in prompt' },
-        { command: 'monomind hooks worker detect -p "security audit" --auto-dispatch', description: 'Detect and dispatch' },
-    ],
-    action: async (ctx) => {
-        const prompt = ctx.flags['prompt'];
-        const autoDispatch = ctx.flags['auto-dispatch'];
-        const minConfidence = parseFloat(ctx.flags['min-confidence'] || '0.5');
-        if (!prompt) {
-            output.printError('--prompt is required');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Analyzing prompt...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-detect', {
-                prompt,
-                autoDispatch,
-                minConfidence,
-            });
-            if (result.detection.detected) {
-                spinner.succeed(`Detected ${result.triggersFound} worker trigger(s)`);
-            }
-            else {
-                spinner.succeed('No worker triggers detected');
-            }
-            output.writeln();
-            output.writeln(output.bold('Detection Results'));
-            output.writeln(`Prompt: ${output.dim(result.prompt)}`);
-            output.writeln(`Confidence: ${(result.detection.confidence * 100).toFixed(0)}%`);
-            if (result.triggerDetails && result.triggerDetails.length > 0) {
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'trigger', header: 'Trigger', width: 14 },
-                        { key: 'priority', header: 'Priority', width: 10 },
-                        { key: 'description', header: 'Description', width: 45 },
-                    ],
-                    data: result.triggerDetails.map(t => ({
-                        trigger: output.highlight(t.trigger),
-                        priority: t.priority,
-                        description: t.description,
-                    })),
-                });
-            }
-            if (result.autoDispatched && result.workerIds) {
-                output.writeln();
-                output.writeln(output.success('Workers auto-dispatched:'));
-                result.workerIds.forEach(id => {
-                    output.writeln(`  - ${id}`);
-                });
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Detection failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Detection error: ${error.message}`);
+            spinner.succeed(`Worker ${name} completed in ${result.duration}ms`);
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-const workerCancelCommand = {
-    name: 'cancel',
-    description: 'Cancel a running worker',
-    options: [
-        { name: 'id', type: 'string', description: 'Worker ID to cancel', required: true },
-    ],
-    examples: [
-        { command: 'monomind hooks worker cancel --id worker_audit_1', description: 'Cancel specific worker' },
-    ],
-    action: async (ctx) => {
-        const workerId = ctx.flags['id'];
-        if (!workerId) {
-            output.printError('--id is required');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: `Cancelling worker ${workerId}...`, spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-cancel', { workerId });
-            if (!result.success) {
-                spinner.fail(`Failed: ${result.error}`);
-                return { success: false, exitCode: 1 };
+            else if (result.data) {
+                output.writeln(output.dim(JSON.stringify(result.data, null, 2)));
             }
-            spinner.succeed(`Worker ${workerId} cancelled`);
             return { success: true, data: result };
         }
         catch (error) {
-            spinner.fail('Cancel failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Cancel error: ${error.message}`);
-            }
+            spinner.fail('Worker run failed');
+            output.printError(error instanceof Error ? error.message : String(error));
             return { success: false, exitCode: 1 };
         }
     }
@@ -730,49 +503,28 @@ const workerCancelCommand = {
 // Worker parent command
 export const workerCommand = {
     name: 'worker',
-    description: 'Background worker management (12 workers for analysis/optimization)',
+    description: 'Background worker management (@monomind/hooks workers, run in-process)',
     subcommands: [
         workerListCommand,
-        workerDispatchCommand,
-        workerStatusCommand,
-        workerDetectCommand,
-        workerCancelCommand,
+        workerRunCommand,
     ],
     options: [],
     examples: [
         { command: 'monomind hooks worker list', description: 'List all workers' },
-        { command: 'monomind hooks worker dispatch -t optimize', description: 'Dispatch optimizer' },
-        { command: 'monomind hooks worker detect -p "test coverage"', description: 'Detect from prompt' },
+        { command: 'monomind hooks worker run map', description: 'Run the codebase map worker' },
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('Background Worker System (12 Workers)'));
+        output.writeln(output.bold('Background Worker System (@monomind/hooks)'));
         output.writeln();
-        output.writeln('Manage and dispatch background workers for analysis and optimization tasks.');
-        output.writeln();
-        output.writeln('Available Workers:');
-        output.printList([
-            `${output.highlight('ultralearn')}   - Deep knowledge acquisition`,
-            `${output.highlight('optimize')}     - Performance optimization`,
-            `${output.highlight('consolidate')} - Memory consolidation`,
-            `${output.highlight('predict')}      - Predictive preloading`,
-            `${output.highlight('audit')}        - Security analysis (critical)`,
-            `${output.highlight('map')}          - Codebase mapping`,
-            `${output.highlight('preload')}      - Resource preloading`,
-            `${output.highlight('deepdive')}     - Deep code analysis`,
-            `${output.highlight('document')}     - Auto-documentation`,
-            `${output.highlight('refactor')}     - Refactoring suggestions`,
-            `${output.highlight('benchmark')}    - Performance benchmarks`,
-            `${output.highlight('testgaps')}     - Test coverage analysis`,
-        ]);
+        output.writeln('Workers run in-process and write their results to .monomind/metrics/.');
+        output.writeln('The metrics-producing workers (ddd, map, audit, optimize, consolidate)');
+        output.writeln('also refresh automatically at session start when their output is stale.');
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
-            `${output.highlight('list')}     - List all workers with capabilities`,
-            `${output.highlight('dispatch')} - Dispatch a worker`,
-            `${output.highlight('status')}   - Check worker status`,
-            `${output.highlight('detect')}   - Detect triggers from prompt`,
-            `${output.highlight('cancel')}   - Cancel a running worker`,
+            `${output.highlight('list')} - List all workers`,
+            `${output.highlight('run')}  - Run a worker once (e.g. hooks worker run map)`,
         ]);
         output.writeln();
         output.writeln('Run "monomind hooks worker <subcommand> --help" for details');

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

@@ -13,24 +13,19 @@ 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 { 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 { neuralCommand } from './neural.js';
 /**
  * All registered commands
  */