monomind 1.18.15 → 2.0.0

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

@@ -1,8 +1,6 @@
 export * from './types.js';
 export { scanDirectory, saveFingerprint, loadFingerprint } from './scanner.js';
 export { CapabilityManager } from './manager.js';
-export { EnrichmentPipeline } from './enrichment.js';
-export type { EnrichmentSummary, EnrichmentStatusReport } from './enrichment.js';
 export { FileWatcher } from './watcher.js';
 export { codeCapability } from './cap-code.js';
 export { documentsCapability } from './cap-documents.js';

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

@@ -1,7 +1,6 @@
 export * from './types.js';
 export { scanDirectory, saveFingerprint, loadFingerprint } from './scanner.js';
 export { CapabilityManager } from './manager.js';
-export { EnrichmentPipeline } from './enrichment.js';
 export { FileWatcher } from './watcher.js';
 export { codeCapability } from './cap-code.js';
 export { documentsCapability } from './cap-documents.js';

package/packages/@monomind/cli/dist/src/commands/agent-lifecycle.js

@@ -6,6 +6,7 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { writeJsonFileAtomic } from '../utils/json-file.js';
 // ─── Shared utilities ────────────────────────────────────────────────────────
 export function updateSwarmActivityMetrics(agentCountDelta) {
     try {
@@ -18,9 +19,6 @@ export function updateSwarmActivityMetrics(agentCountDelta) {
         if (fs.existsSync(activityPath) && fs.statSync(activityPath).size <= 10 * 1024 * 1024) {
             data = JSON.parse(fs.readFileSync(activityPath, 'utf-8'));
         }
-        else {
-            fs.mkdirSync(metricsDir, { recursive: true });
-        }
         const swarm = data.swarm ?? {};
         const currentCount = Math.max(0, swarm.agent_count || 0);
         const newCount = Math.max(0, currentCount + agentCountDelta);
@@ -29,9 +27,7 @@ export function updateSwarmActivityMetrics(agentCountDelta) {
         swarm.coordination_active = newCount > 0;
         data.swarm = swarm;
         data.timestamp = new Date().toISOString();
-        const tmpPath = activityPath + '.tmp';
-        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-        fs.renameSync(tmpPath, activityPath);
+        writeJsonFileAtomic(activityPath, data);
     }
     catch {
         // Non-critical — don't fail the command if metrics update fails

package/packages/@monomind/cli/dist/src/commands/agent-ops.d.ts

@@ -1,9 +1,8 @@
 /**
- * Agent operational commands — metrics, pool, health, logs
+ * Agent operational commands — metrics, pool, health
  */
 import type { Command } from '../types.js';
 export declare const metricsCommand: Command;
 export declare const poolCommand: Command;
 export declare const healthCommand: Command;
-export declare const logsCommand: Command;
 //# sourceMappingURL=agent-ops.d.ts.map

package/packages/@monomind/cli/dist/src/commands/agent-ops.js

@@ -1,5 +1,5 @@
 /**
- * Agent operational commands — metrics, pool, health, logs
+ * Agent operational commands — metrics, pool, health
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
@@ -268,62 +268,4 @@ export const healthCommand = {
         }
     },
 };
-// ─── logs subcommand ─────────────────────────────────────────────────────────
-function formatLogLevel(level) {
-    switch (level) {
-        case 'debug': return output.dim('[DEBUG]');
-        case 'info': return '[INFO] ';
-        case 'warn': return output.warning('[WARN] ');
-        case 'error': return output.error('[ERROR]');
-        default: return `[${level.toUpperCase()}]`;
-    }
-}
-export const logsCommand = {
-    name: 'logs',
-    description: 'Show agent activity logs',
-    options: [
-        { name: 'id', short: 'i', description: 'Agent ID', type: 'string' },
-        { name: 'tail', short: 'n', description: 'Number of recent entries', type: 'number', default: 50 },
-        { name: 'level', short: 'l', description: 'Minimum log level', type: 'string', choices: ['debug', 'info', 'warn', 'error'], default: 'info' },
-        { name: 'follow', short: 'f', description: 'Follow log output', type: 'boolean', default: false },
-        { name: 'since', description: 'Show logs since (e.g., "1h", "30m")', type: 'string' },
-    ],
-    examples: [
-        { command: 'monomind agent logs -i agent-001', description: 'Show agent logs' },
-        { command: 'monomind agent logs -i agent-001 -f', description: 'Follow agent logs' },
-        { command: 'monomind agent logs -l error --since 1h', description: 'Show errors from last hour' },
-    ],
-    action: async (ctx) => {
-        const agentId = ((ctx.args[0] || ctx.flags.id) ?? '').slice(0, 128);
-        const tail = ctx.flags.tail;
-        const level = ctx.flags.level?.slice(0, 32);
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --id or -i');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('agent_logs', { agentId, tail, level, since: ctx.flags.since });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold(`Logs for ${agentId}`));
-            output.writeln(output.dim(`Showing ${result.entries.length} of ${result.total} entries`));
-            output.writeln();
-            for (const entry of result.entries) {
-                const time = new Date(entry.timestamp).toLocaleTimeString();
-                output.writeln(`${output.dim(time)} ${formatLogLevel(entry.level)} ${entry.message}`);
-                if (entry.context && Object.keys(entry.context).length > 0) {
-                    output.writeln(output.dim(`  ${JSON.stringify(entry.context)}`));
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Logs error: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
 //# sourceMappingURL=agent-ops.js.map

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

@@ -4,11 +4,11 @@
  */
 import { output } from '../output.js';
 import { spawnCommand, listCommand, statusCommand, stopCommand } from './agent-lifecycle.js';
-import { metricsCommand, poolCommand, healthCommand, logsCommand } from './agent-ops.js';
+import { metricsCommand, poolCommand, healthCommand } from './agent-ops.js';
 export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
-    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
+    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand],
     options: [],
     examples: [
         { command: 'monomind agent spawn -t coder', description: 'Spawn a coder agent' },
@@ -30,7 +30,6 @@ export const agentCommand = {
             `${output.highlight('metrics')}       - Show agent metrics`,
             `${output.highlight('pool')}          - Manage agent pool`,
             `${output.highlight('health')}        - Show agent health`,
-            `${output.highlight('logs')}          - Show agent logs`,
         ]);
         output.writeln();
         output.writeln('Run "monomind agent <subcommand> --help" for subcommand help');

package/packages/@monomind/cli/dist/src/commands/analyze-diff.js

@@ -236,7 +236,7 @@ export const diffCommand = {
         }
     },
 };
-// Code subcommand (placeholder for future code analysis)
+// Code subcommand
 export const codeCommand = {
     name: 'code',
     description: 'Static code analysis and quality assessment',

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

@@ -7,16 +7,12 @@
  * - Symbol extraction (functions, classes, variables, types)
  * - Cyclomatic complexity scoring
  * - Diff classification and risk assessment
- * - Graph boundaries using MinCut algorithm
- * - Module communities using Louvain algorithm
- * - Circular dependency detection
  *
  * github.com/monoes/monomind
  */
 import type { Command } from '../types.js';
 type AnalyzerModule = any;
 export declare function getASTAnalyzer(): Promise<AnalyzerModule | null>;
-export declare function getGraphAnalyzer(): Promise<AnalyzerModule | null>;
 /**
  * Write analysis output to a file, constraining the path to the current working
  * directory to prevent path traversal attacks via --output /etc/cron.d/x or

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

@@ -7,9 +7,6 @@
  * - Symbol extraction (functions, classes, variables, types)
  * - Cyclomatic complexity scoring
  * - Diff classification and risk assessment
- * - Graph boundaries using MinCut algorithm
- * - Module communities using Louvain algorithm
- * - Circular dependency detection
  *
  * github.com/monoes/monomind
  */
@@ -21,16 +18,10 @@ import { diffCommand, codeCommand } from './analyze-diff.js';
 import { astCommand } from './analyze-ast.js';
 import { complexityAstCommand, symbolsCommand } from './analyze-symbols.js';
 import { importsCommand, depsCommand } from './analyze-imports.js';
-import { boundariesCommand, modulesCommand } from './analyze-boundaries.js';
-import { dependenciesCommand, circularCommand } from './analyze-graph.js';
 // AST analyzer module was never shipped — always falls back to the regex path.
 export async function getASTAnalyzer() {
     return null;
 }
-// Graph analyzer module was never shipped — callers handle the null path.
-export async function getGraphAnalyzer() {
-    return null;
-}
 /**
  * Write analysis output to a file, constraining the path to the current working
  * directory to prevent path traversal attacks via --output /etc/cron.d/x or
@@ -154,7 +145,7 @@ export function fallbackAnalyze(code, filePath) {
 // Main analyze command
 export const analyzeCommand = {
     name: 'analyze',
-    description: 'Code analysis, diff classification, graph boundaries, and change risk assessment',
+    description: 'Code analysis, diff classification, and change risk assessment',
     aliases: ['an'],
     subcommands: [
         diffCommand,
@@ -164,10 +155,6 @@ export const analyzeCommand = {
         complexityAstCommand,
         symbolsCommand,
         importsCommand,
-        boundariesCommand,
-        modulesCommand,
-        dependenciesCommand,
-        circularCommand,
     ],
     options: [
         {
@@ -191,10 +178,6 @@ export const analyzeCommand = {
         { command: 'monomind analyze symbols src/ --type function', description: 'Extract all functions' },
         { command: 'monomind analyze imports src/ --external', description: 'List npm dependencies' },
         { command: 'monomind analyze diff --risk', description: 'Analyze diff with risk assessment' },
-        { command: 'monomind analyze boundaries src/', description: 'Find code boundaries using MinCut' },
-        { command: 'monomind analyze modules src/', description: 'Detect module communities with Louvain' },
-        { command: 'monomind analyze dependencies src/ --format dot', description: 'Export dependency graph as DOT' },
-        { command: 'monomind analyze circular src/', description: 'Find circular dependencies' },
         { command: 'monomind analyze deps --security', description: 'Check dependency vulnerabilities' },
     ],
     action: async (_ctx) => {
@@ -212,10 +195,6 @@ export const analyzeCommand = {
         output.writeln(`  ${output.highlight('complexity')}   Analyze cyclomatic and cognitive complexity`);
         output.writeln(`  ${output.highlight('symbols')}      Extract functions, classes, and types`);
         output.writeln(`  ${output.highlight('imports')}      Analyze import dependencies`);
-        output.writeln(`  ${output.highlight('boundaries')}   Find code boundaries using MinCut algorithm`);
-        output.writeln(`  ${output.highlight('modules')}      Detect module communities using Louvain algorithm`);
-        output.writeln(`  ${output.highlight('dependencies')} Build and export full dependency graph`);
-        output.writeln(`  ${output.highlight('circular')}     Detect circular dependencies in codebase`);
         output.writeln();
         output.writeln(output.bold('AST Analysis Examples:'));
         output.writeln();
@@ -225,13 +204,6 @@ export const analyzeCommand = {
         output.writeln(`  ${output.dim('monomind analyze symbols src/ --type fn')}    # Extract functions`);
         output.writeln(`  ${output.dim('monomind analyze imports src/ --external')}   # Only npm imports`);
         output.writeln();
-        output.writeln(output.bold('Graph Analysis Examples:'));
-        output.writeln();
-        output.writeln(`  ${output.dim('monomind analyze boundaries src/')}            # Find natural code boundaries`);
-        output.writeln(`  ${output.dim('monomind analyze modules src/')}               # Detect module communities`);
-        output.writeln(`  ${output.dim('monomind analyze dependencies -f dot src/')}   # Export to DOT format`);
-        output.writeln(`  ${output.dim('monomind analyze circular src/')}              # Find circular deps`);
-        output.writeln();
         output.writeln(output.bold('Diff Analysis Examples:'));
         output.writeln();
         output.writeln(`  ${output.dim('monomind analyze diff --risk')}              # Risk assessment`);

package/packages/@monomind/cli/dist/src/commands/browse-action.js

@@ -130,8 +130,100 @@ const runSubcommand = {
         { name: 'port', type: 'number', description: 'CDP port', default: 9222 },
     ],
     action: async (ctx) => {
-        output.printInfo('Direct action run is coming soon. Use workflow run to execute actions.');
-        return { success: true };
+        const actionId = ctx.args[0];
+        if (!actionId) {
+            output.printError('Action ID required. Usage: monomind browse action run <action-id>');
+            return { success: false, exitCode: 1 };
+        }
+        const port = ctx.flags.port ?? 9222;
+        const paramsRaw = ctx.flags.params ?? [];
+        const params = {};
+        for (const pair of paramsRaw) {
+            const eq = pair.indexOf('=');
+            if (eq > 0)
+                params[pair.slice(0, eq)] = pair.slice(eq + 1);
+        }
+        const customDir = join(ctx.cwd, '.monomind', 'actions');
+        const filename = actionId.replace(/[^a-z0-9_-]/gi, '_') + '.json';
+        let def;
+        try {
+            def = JSON.parse(await readFile(join(customDir, filename), 'utf8'));
+        }
+        catch {
+            output.printError(`Action not found: ${actionId}. Run "monomind browse action list" to see available actions.`);
+            return { success: false, exitCode: 1 };
+        }
+        output.printInfo(`Running action: ${def.id} (${def.steps.length} steps)`);
+        try {
+            const { connectToTarget, openUrl, clickElement, fillElement, evaluateJs, findBySelector, waitFor } = await import('@monoes/monobrowse');
+            const { client, sessionId } = await connectToTarget(port);
+            const refs = new Map();
+            const interpolate = (s) => s.replace(/\{\{(\w+)\}\}/g, (_, k) => params[k] ?? `{{${k}}}`);
+            for (const step of def.steps) {
+                switch (step.type) {
+                    case 'navigate':
+                        await openUrl(client, sessionId, interpolate(step.url));
+                        output.writeln(output.dim(`  navigate -> ${step.url}`));
+                        break;
+                    case 'find':
+                        for (const sel of step.selectors ?? []) {
+                            const found = await findBySelector(client, sessionId, refs, interpolate(sel)).catch(() => null);
+                            if (found) {
+                                refs.set(step.as, found);
+                                break;
+                            }
+                        }
+                        output.writeln(output.dim(`  find -> ${step.as}`));
+                        break;
+                    case 'click': {
+                        const ref = refs.get(step.target);
+                        if (!ref)
+                            throw new Error(`Element "${step.target}" not found`);
+                        await clickElement(client, sessionId, ref);
+                        output.writeln(output.dim(`  click -> ${step.target}`));
+                        break;
+                    }
+                    case 'type': {
+                        const ref = refs.get(step.target);
+                        if (!ref)
+                            throw new Error(`Element "${step.target}" not found`);
+                        await fillElement(client, sessionId, ref, interpolate(step.text));
+                        output.writeln(output.dim(`  type -> ${step.target}`));
+                        break;
+                    }
+                    case 'wait':
+                        if (step.condition === 'network_idle')
+                            await waitFor(client, sessionId, { load: 'networkidle', timeout: step.timeout });
+                        else if (step.condition === 'selector')
+                            await waitFor(client, sessionId, { selector: step.selector, timeout: step.timeout });
+                        else if (step.condition === 'duration')
+                            await new Promise(r => setTimeout(r, step.timeout ?? 1000));
+                        output.writeln(output.dim(`  wait -> ${step.condition}`));
+                        break;
+                    case 'extract': {
+                        const ref = refs.get(step.target);
+                        if (!ref)
+                            throw new Error(`Element "${step.target}" not found`);
+                        const val = await evaluateJs(client, sessionId, `document.querySelector('[data-ref="${ref.ref}"]')?.textContent`);
+                        output.writeln(output.dim(`  extract -> ${step.as}: ${val}`));
+                        break;
+                    }
+                    case 'condition': {
+                        const result = await evaluateJs(client, sessionId, step.expression);
+                        if (result) {
+                            output.writeln(output.dim('  condition -> true branch'));
+                        }
+                        break;
+                    }
+                }
+            }
+            output.printSuccess(`Action ${def.id} completed successfully.`);
+            return { success: true };
+        }
+        catch (err) {
+            output.printError(`Action failed: ${err.message}`);
+            return { success: false, exitCode: 1 };
+        }
     },
 };
 export const browseActionCommand = {

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

@@ -7,21 +7,21 @@
 import { output } from '../output.js';
 // Get all top-level commands for completions
 const TOP_LEVEL_COMMANDS = [
-    'swarm', 'agent', 'task', 'session', 'config', 'memory', 'workflow',
-    'hive-mind', 'hooks', 'daemon', 'neural', 'security', 'performance',
-    'providers', 'deployment', 'claims', 'embeddings',
+    'swarm', 'agent', 'task', 'session', 'config', 'memory',
+    'hive-mind', 'hooks', 'security', 'performance',
+    'providers', 'embeddings',
     'doctor', 'completions', 'help', 'version'
 ];
 // Swarm subcommands
-const SWARM_SUBCOMMANDS = ['init', 'status', 'scale', 'destroy', 'monitor', 'optimize'];
+const SWARM_SUBCOMMANDS = ['init', 'status', 'scale', 'destroy', 'monitor'];
 // Agent subcommands
 const AGENT_SUBCOMMANDS = ['spawn', 'terminate', 'status', 'list', 'pool', 'health', 'update'];
 // Task subcommands
 const TASK_SUBCOMMANDS = ['create', 'status', 'list', 'complete', 'cancel'];
 // Memory subcommands
-const MEMORY_SUBCOMMANDS = ['store', 'retrieve', 'search', 'list', 'delete', 'stats', 'configure', 'cleanup', 'compress', 'export', 'import'];
+const MEMORY_SUBCOMMANDS = ['store', 'retrieve', 'search', 'list', 'delete', 'stats', 'configure', 'export', 'import'];
 // Hive-mind subcommands
-const HIVE_MIND_SUBCOMMANDS = ['init', 'spawn', 'status', 'task', 'join', 'leave', 'consensus', 'broadcast', 'memory', 'optimize-memory', 'shutdown'];
+const HIVE_MIND_SUBCOMMANDS = ['init', 'spawn', 'status', 'join', 'leave', 'consensus', 'broadcast', 'memory', 'shutdown'];
 // Hooks subcommands
 const HOOKS_SUBCOMMANDS = ['pre-edit', 'post-edit', 'pre-command', 'post-command', 'pre-task', 'post-task', 'route', 'explain', 'pretrain', 'build-agents', 'metrics', 'transfer', 'list', 'intelligence'];
 // Generate bash completion script
@@ -69,20 +69,12 @@ _monomind_completions() {
             COMPREPLY=( $(compgen -W "\${hooks_commands}" -- "\${cur}") )
             return 0
             ;;
-        neural)
-            COMPREPLY=( $(compgen -W "train status patterns predict optimize" -- "\${cur}") )
-            return 0
-            ;;
         security)
-            COMPREPLY=( $(compgen -W "scan cve threats audit secrets" -- "\${cur}") )
+            COMPREPLY=( $(compgen -W "scan cve audit secrets" -- "\${cur}") )
             return 0
             ;;
         performance)
-            COMPREPLY=( $(compgen -W "benchmark profile metrics optimize bottleneck" -- "\${cur}") )
-            return 0
-            ;;
-        deployment|deploy)
-            COMPREPLY=( $(compgen -W "deploy status rollback history environments logs" -- "\${cur}") )
+            COMPREPLY=( $(compgen -W "benchmark profile metrics bottleneck" -- "\${cur}") )
             return 0
             ;;
         claims)
@@ -93,10 +85,6 @@ _monomind_completions() {
             COMPREPLY=( $(compgen -W "generate search compare collections index providers" -- "\${cur}") )
             return 0
             ;;
-        daemon)
-            COMPREPLY=( $(compgen -W "start stop status trigger enable" -- "\${cur}") )
-            return 0
-            ;;
         providers)
             COMPREPLY=( $(compgen -W "list configure test models usage" -- "\${cur}") )
             return 0
@@ -138,12 +126,9 @@ _monomind() {
         'workflow:Workflow automation'
         'hive-mind:Queen-led consensus coordination'
         'hooks:Self-learning automation hooks'
-        'daemon:Background service management'
-        'neural:Neural pattern training'
         'security:Security scanning and CVE detection'
         'performance:Performance profiling'
         'providers:AI provider management'
-        'deployment:Deployment management'
         'claims:Claims-based authorization'
         'embeddings:Vector embeddings'
         'doctor:System diagnostics'
@@ -170,7 +155,6 @@ _monomind() {
                         'scale:Scale agent count'
                         'destroy:Shutdown swarm'
                         'monitor:Real-time monitoring'
-                        'optimize:Optimize topology'
                     )
                     ;;
                 agent)
@@ -202,8 +186,6 @@ _monomind() {
                         'delete:Delete entry'
                         'stats:Show statistics'
                         'configure:Configure backend'
-                        'cleanup:Clean stale data'
-                        'compress:Compress storage'
                         'export:Export to file'
                         'import:Import from file'
                     )
@@ -213,13 +195,11 @@ _monomind() {
                         'init:Initialize hive mind'
                         'spawn:Spawn worker agents'
                         'status:Show hive status'
-                        'task:Submit task'
                         'join:Join agent to hive'
                         'leave:Remove agent'
                         'consensus:Consensus management'
                         'broadcast:Broadcast message'
                         'memory:Shared memory'
-                        'optimize-memory:Optimize patterns'
                         'shutdown:Shutdown hive'
                     )
                     ;;
@@ -241,20 +221,10 @@ _monomind() {
                         'intelligence:Neural intelligence commands'
                     )
                     ;;
-                neural)
-                    subcommands=(
-                        'train:Train neural patterns'
-                        'status:Check neural status'
-                        'patterns:Manage patterns'
-                        'predict:Make predictions'
-                        'optimize:Optimize models'
-                    )
-                    ;;
                 security)
                     subcommands=(
                         'scan:Security scan'
                         'cve:CVE detection'
-                        'threats:Threat modeling'
                         'audit:Security audit'
                         'secrets:Secrets scanning'
                     )
@@ -264,20 +234,9 @@ _monomind() {
                         'benchmark:Run benchmarks'
                         'profile:Profile code'
                         'metrics:Show metrics'
-                        'optimize:Optimize performance'
                         'bottleneck:Find bottlenecks'
                     )
                     ;;
-                deployment|deploy)
-                    subcommands=(
-                        'deploy:Deploy to environment'
-                        'status:Deployment status'
-                        'rollback:Rollback version'
-                        'history:Deployment history'
-                        'environments:List environments'
-                        'logs:View logs'
-                    )
-                    ;;
                 claims)
                     subcommands=(
                         'list:List claims'
@@ -298,15 +257,6 @@ _monomind() {
                         'providers:Embedding providers'
                     )
                     ;;
-                daemon)
-                    subcommands=(
-                        'start:Start daemon'
-                        'stop:Stop daemon'
-                        'status:Daemon status'
-                        'trigger:Trigger event'
-                        'enable:Enable feature'
-                    )
-                    ;;
                 providers)
                     subcommands=(
                         'list:List providers'
@@ -355,17 +305,11 @@ ${HIVE_MIND_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcomm
 # Hooks subcommands
 ${HOOKS_SUBCOMMANDS.map(sub => `complete -c monomind -n "__fish_seen_subcommand_from hooks" -a "${sub}"`).join('\n')}
 
-# Neural subcommands
-complete -c monomind -n "__fish_seen_subcommand_from neural" -a "train status patterns predict optimize"
-
 # Security subcommands
-complete -c monomind -n "__fish_seen_subcommand_from security" -a "scan cve threats audit secrets"
+complete -c monomind -n "__fish_seen_subcommand_from security" -a "scan cve audit secrets"
 
 # Performance subcommands
-complete -c monomind -n "__fish_seen_subcommand_from performance" -a "benchmark profile metrics optimize bottleneck"
-
-# Deployment subcommands
-complete -c monomind -n "__fish_seen_subcommand_from deployment deploy" -a "deploy status rollback history environments logs"
+complete -c monomind -n "__fish_seen_subcommand_from performance" -a "benchmark profile metrics bottleneck"
 
 # Claims subcommands
 complete -c monomind -n "__fish_seen_subcommand_from claims" -a "list check grant revoke roles policies"
@@ -373,9 +317,6 @@ complete -c monomind -n "__fish_seen_subcommand_from claims" -a "list check gran
 # Embeddings subcommands
 complete -c monomind -n "__fish_seen_subcommand_from embeddings" -a "generate search compare collections index providers"
 
-# Daemon subcommands
-complete -c monomind -n "__fish_seen_subcommand_from daemon" -a "start stop status trigger enable"
-
 # Providers subcommands
 complete -c monomind -n "__fish_seen_subcommand_from providers" -a "list configure test models usage"
 `;
@@ -398,14 +339,9 @@ $script:SubCommands = @{
     'hive-mind' = @('${HIVE_MIND_SUBCOMMANDS.join("', '")}')
     'hive' = @('${HIVE_MIND_SUBCOMMANDS.join("', '")}')
     'hooks' = @('${HOOKS_SUBCOMMANDS.join("', '")}')
-    'neural' = @('train', 'status', 'patterns', 'predict', 'optimize')
-    'security' = @('scan', 'cve', 'threats', 'audit', 'secrets')
-    'performance' = @('benchmark', 'profile', 'metrics', 'optimize', 'bottleneck')
-    'deployment' = @('deploy', 'status', 'rollback', 'history', 'environments', 'logs')
-    'deploy' = @('deploy', 'status', 'rollback', 'history', 'environments', 'logs')
-    'claims' = @('list', 'check', 'grant', 'revoke', 'roles', 'policies')
+    'security' = @('scan', 'cve', 'audit', 'secrets')
+    'performance' = @('benchmark', 'profile', 'metrics', 'bottleneck')
     'embeddings' = @('generate', 'search', 'compare', 'collections', 'index', 'providers')
-    'daemon' = @('start', 'stop', 'status', 'trigger', 'enable')
     'providers' = @('list', 'configure', 'test', 'models', 'usage')
 }
 

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

@@ -18,12 +18,6 @@ const initCommand = {
             type: 'boolean',
             default: false
         },
-        {
-            name: 'sparc',
-            description: 'Initialize with SPARC methodology',
-            type: 'boolean',
-            default: false
-        },
         {
             name: 'v1',
             description: 'Initialize v1 configuration',

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.d.ts

@@ -1,11 +1,10 @@
 /**
  * Doctor — project/monomind health checks
- * Config, daemon, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore
+ * Config, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore, worker metrics
  */
 import type { HealthCheck } from './doctor-env-checks.js';
 export type { HealthCheck };
 export declare function checkConfigFile(): Promise<HealthCheck>;
-export declare function checkDaemonStatus(): Promise<HealthCheck>;
 export declare function checkMemoryDatabase(): Promise<HealthCheck>;
 export declare function checkApiKeys(): Promise<HealthCheck>;
 export declare function checkMcpServers(): Promise<HealthCheck>;
@@ -19,7 +18,18 @@ export declare function checkGitignoreCoverage(): Promise<HealthCheck>;
 export declare function checkAgentRegistry(): Promise<HealthCheck>;
 export declare function checkGuidanceGates(): Promise<HealthCheck>;
 /**
- * AutoMem proficiency check — reports memory learning health (arXiv:2607.01224)
+ * Worker metrics freshness — reports the age of the @monomind/hooks worker
+ * output files (written at session start with a 6h staleness gate, or on
+ * demand via `monomind hooks worker run <name>`), so missing/stale worker
+ * output is visible without digging through .monomind/metrics.
+ */
+export declare function checkMetricsFreshness(): Promise<HealthCheck>;
+/**
+ * Surfaces critical findings from the security-audit worker output.
+ */
+export declare function checkSecurityAuditFindings(): Promise<HealthCheck>;
+/**
+ * AutoMem proficiency check — reports memory learning health
  */
 export declare function checkMemoryProficiency(): Promise<HealthCheck>;
 //# sourceMappingURL=doctor-project-checks.d.ts.map