monomind 1.18.13 → 1.19.0

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

@@ -8,20 +8,20 @@ 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',
+    'hive-mind', 'hooks', 'daemon', 'security', 'performance',
+    'providers', 'claims', '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)
@@ -139,11 +131,9 @@ _monomind() {
         '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 +160,6 @@ _monomind() {
                         'scale:Scale agent count'
                         'destroy:Shutdown swarm'
                         'monitor:Real-time monitoring'
-                        'optimize:Optimize topology'
                     )
                     ;;
                 agent)
@@ -202,8 +191,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 +200,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 +226,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 +239,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'
@@ -355,17 +319,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"
@@ -398,11 +356,8 @@ $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')
+    'security' = @('scan', 'cve', 'audit', 'secrets')
+    'performance' = @('benchmark', 'profile', 'metrics', 'bottleneck')
     'claims' = @('list', 'check', 'grant', 'revoke', 'roles', 'policies')
     'embeddings' = @('generate', 'search', 'compare', 'collections', 'index', 'providers')
     'daemon' = @('start', 'stop', 'status', 'trigger', 'enable')

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

@@ -19,7 +19,7 @@ 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)
+ * AutoMem proficiency check — reports memory learning health
  */
 export declare function checkMemoryProficiency(): Promise<HealthCheck>;
 //# sourceMappingURL=doctor-project-checks.d.ts.map

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

@@ -446,7 +446,7 @@ export async function checkGuidanceGates() {
     }
 }
 /**
- * AutoMem proficiency check — reports memory learning health (arXiv:2607.01224)
+ * AutoMem proficiency check — reports memory learning health
  */
 export async function checkMemoryProficiency() {
     try {

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

@@ -18,8 +18,8 @@ export const TOPOLOGIES = [
 export const CONSENSUS_STRATEGIES = [
     { value: 'byzantine', label: 'Byzantine Fault Tolerant', hint: '2/3 majority, handles malicious actors' },
     { value: 'raft', label: 'Raft', hint: 'Leader-based consensus' },
-    { value: 'gossip', label: 'Gossip', hint: 'Eventually consistent, scalable' },
-    { value: 'crdt', label: 'CRDT', hint: 'Conflict-free replicated data' },
+    { value: 'gossip', label: 'Gossip', hint: 'Eventually consistent, scalable (planned — not yet implemented)' },
+    { value: 'crdt', label: 'CRDT', hint: 'Conflict-free replicated data (planned — not yet implemented)' },
     { value: 'quorum', label: 'Quorum', hint: 'Simple majority voting' }
 ];
 export function groupWorkersByType(workers) {

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

@@ -1,8 +1,6 @@
 /**
- * Hive Mind operational subcommands — status, task, optimize-memory
+ * Hive Mind operational subcommands — status
  */
 import type { Command } from '../types.js';
 export declare const statusCommand: Command;
-export declare const taskCommand: Command;
-export declare const optimizeMemoryCommand: Command;
 //# sourceMappingURL=hive-mind-ops.d.ts.map

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

@@ -1,10 +1,9 @@
 /**
- * Hive Mind operational subcommands — status, task, optimize-memory
+ * Hive Mind operational subcommands — status
  */
 import { output } from '../output.js';
-import { input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { MAX_TASK_DESC_LEN, formatAgentStatus, formatHiveStatus, formatHealth, formatPriority, } from './hive-mind-helpers.js';
+import { formatAgentStatus, formatHiveStatus, formatHealth, } from './hive-mind-helpers.js';
 export const statusCommand = {
     name: 'status',
     description: 'Show hive mind status',
@@ -117,117 +116,4 @@ export const statusCommand = {
         }
     }
 };
-export const taskCommand = {
-    name: 'task',
-    description: 'Submit tasks to the hive',
-    options: [
-        { name: 'description', short: 'd', description: 'Task description', type: 'string' },
-        { name: 'priority', short: 'p', description: 'Task priority', type: 'string', choices: ['low', 'normal', 'high', 'critical'], default: 'normal' },
-        { name: 'require-consensus', short: 'c', description: 'Require consensus for completion', type: 'boolean', default: false },
-        { name: 'timeout', description: 'Task timeout in seconds', type: 'number', default: 300 }
-    ],
-    examples: [
-        { command: 'monomind hive-mind task -d "Implement auth module"', description: 'Submit task' },
-        { command: 'monomind hive-mind task -d "Security review" -p critical -c', description: 'Critical task with consensus' }
-    ],
-    action: async (ctx) => {
-        let description = (ctx.flags.description || ctx.args.join(' ')).slice(0, MAX_TASK_DESC_LEN);
-        if (!description && ctx.interactive) {
-            description = await input({
-                message: 'Task description:',
-                validate: (v) => v.length > 0 || 'Description is required'
-            });
-            description = description.slice(0, MAX_TASK_DESC_LEN);
-        }
-        if (!description) {
-            output.printError('Task description is required');
-            return { success: false, exitCode: 1 };
-        }
-        const priority = ctx.flags.priority;
-        const requireConsensus = ctx.flags['require-consensus'];
-        const timeout = ctx.flags.timeout;
-        output.printInfo('Submitting task to hive...');
-        try {
-            const result = await callMCPTool('hive-mind_task', { description, priority, requireConsensus, timeout });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Task ID: ${result.taskId}`,
-                `Status: ${formatAgentStatus(result.status)}`,
-                `Priority: ${formatPriority(priority)}`,
-                `Assigned: ${result.assignedTo.join(', ')}`,
-                `Consensus: ${result.requiresConsensus ? 'Yes' : 'No'}`,
-                `Est. Time: ${result.estimatedTime}`
-            ].join('\n'), 'Task Submitted');
-            output.writeln();
-            output.printSuccess('Task submitted to hive');
-            output.writeln(output.dim(`  Track with: monomind hive-mind task-status ${result.taskId}`));
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Task submission error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-export const optimizeMemoryCommand = {
-    name: 'optimize-memory',
-    description: 'Optimize hive memory and patterns',
-    options: [
-        { name: 'aggressive', short: 'a', description: 'Aggressive optimization', type: 'boolean', default: false },
-        { name: 'threshold', description: 'Quality threshold for pattern retention', type: 'number', default: 0.7 }
-    ],
-    action: async (ctx) => {
-        const aggressive = ctx.flags.aggressive;
-        const threshold = ctx.flags.threshold;
-        output.printInfo('Optimizing hive memory...');
-        const spinner = output.createSpinner({ text: 'Analyzing patterns...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hive-mind_optimize-memory', { aggressive, qualityThreshold: threshold });
-            spinner.succeed('Memory optimized');
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 20 },
-                    { key: 'before', header: 'Before', width: 15, align: 'right' },
-                    { key: 'after', header: 'After', width: 15, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Patterns', before: result.before.patterns, after: result.after.patterns },
-                    { metric: 'Memory', before: result.before.memory, after: result.after.memory }
-                ]
-            });
-            output.writeln();
-            output.printList([
-                `Patterns removed: ${result.removed}`,
-                `Patterns consolidated: ${result.consolidated}`,
-                `Optimization time: ${result.timeMs}ms`
-            ]);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Optimization failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Optimization error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 //# sourceMappingURL=hive-mind-ops.js.map

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

@@ -10,7 +10,7 @@ import { select } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { TOPOLOGIES, CONSENSUS_STRATEGIES } from './hive-mind-helpers.js';
 import { spawnCommand } from './hive-mind-spawn.js';
-import { statusCommand, taskCommand, optimizeMemoryCommand } from './hive-mind-ops.js';
+import { statusCommand } from './hive-mind-ops.js';
 import { joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, shutdownCommand } from './hive-mind-comms.js';
 const initCommand = {
     name: 'init',
@@ -93,13 +93,12 @@ export const hiveMindCommand = {
     name: 'hive-mind',
     aliases: ['hive'],
     description: 'Queen-led consensus-based multi-agent coordination',
-    subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, optimizeMemoryCommand, shutdownCommand],
+    subcommands: [initCommand, spawnCommand, statusCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, shutdownCommand],
     options: [],
     examples: [
         { command: 'monomind hive-mind init -t hierarchical-mesh', description: 'Initialize hive' },
         { command: 'monomind hive-mind spawn -n 5', description: 'Spawn workers' },
         { command: 'monomind hive-mind spawn --claude -o "Build a feature"', description: 'Launch Claude Code with hive mind' },
-        { command: 'monomind hive-mind task -d "Build feature"', description: 'Submit task' }
     ],
     action: async () => {
         output.writeln();
@@ -112,13 +111,11 @@ export const hiveMindCommand = {
             `${output.highlight('init')}            - Initialize hive mind`,
             `${output.highlight('spawn')}           - Spawn worker agents (use --claude to launch Claude Code)`,
             `${output.highlight('status')}          - Show hive status`,
-            `${output.highlight('task')}            - Submit task to hive`,
             `${output.highlight('join')}            - Join an agent to the hive`,
             `${output.highlight('leave')}           - Remove an agent from the hive`,
             `${output.highlight('consensus')}       - Manage consensus proposals`,
             `${output.highlight('broadcast')}       - Broadcast message to workers`,
             `${output.highlight('memory')}          - Access shared memory`,
-            `${output.highlight('optimize-memory')} - Optimize patterns and memory`,
             `${output.highlight('shutdown')}        - Shutdown the hive`
         ]);
         output.writeln();

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

@@ -54,7 +54,8 @@ export const statuslineCommand = {
                     try {
                         const stats = fs.statSync(dbPath);
                         const sizeKB = stats.size / 1024;
-                        patterns = Math.floor(sizeKB / 2);
+                        // Estimate: ~2KB per pattern entry on average
+                        patterns = Math.floor(sizeKB / 2); // estimatedPatterns — derived from file size, not counted
                         sessions = Math.max(1, Math.floor(patterns / 10));
                         trajectories = Math.floor(patterns / 5);
                         break;
@@ -275,7 +276,7 @@ export const statuslineCommand = {
                 try {
                     const stats = fs.statSync(dbPath);
                     memoryStats.dbSizeKB = Math.round(stats.size / 1024);
-                    memoryStats.vectorCount = Math.floor(memoryStats.dbSizeKB / 2);
+                    memoryStats.vectorCount = Math.floor(memoryStats.dbSizeKB / 2); // estimated from file size
                     memoryStats.hasHnsw = memoryStats.vectorCount > 100;
                     break;
                 }
@@ -298,7 +299,7 @@ export const statuslineCommand = {
                                 memoryStats.dbSizeKB += Math.round(fileStat.size / 1024);
                             }
                         }
-                        memoryStats.vectorCount = Math.floor(memoryStats.dbSizeKB / 2);
+                        memoryStats.vectorCount = Math.floor(memoryStats.dbSizeKB / 2); // estimated from file size
                         memoryStats.hasHnsw = memoryStats.vectorCount > 100;
                         if (memoryStats.vectorCount > 0)
                             break;
@@ -349,7 +350,7 @@ export const statuslineCommand = {
                 try {
                     const files = fs.readdirSync(fullPath, { recursive: true });
                     testStats.testFiles = files.filter((f) => /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(f)).length;
-                    testStats.testCases = testStats.testFiles * 28;
+                    testStats.testCases = testStats.testFiles * 28; // rough estimate (~28 cases/file avg), not counted
                 }
                 catch { /* ignore */ }
             }
@@ -373,7 +374,7 @@ export const statuslineCommand = {
         }
         else if (progress.patternsLearned > 0) {
             const patternsK = progress.patternsLearned >= 1000 ? `${(progress.patternsLearned / 1000).toFixed(1)}k` : String(progress.patternsLearned);
-            perfIndicator = `${c.brightYellow}📚 ${patternsK} patterns${c.reset}`;
+            perfIndicator = `${c.brightYellow}📚 ~${patternsK} patterns (est.)${c.reset}`;
         }
         const line1 = `${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar(progress.domainsCompleted, progress.totalDomains)}  ` +
             `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset}    ` +
@@ -400,9 +401,9 @@ export const statuslineCommand = {
         const sizeDisplay = memoryStats.dbSizeKB >= 1024 ? `${(memoryStats.dbSizeKB / 1024).toFixed(1)}MB` : `${memoryStats.dbSizeKB}KB`;
         const hnswIndicator = memoryStats.hasHnsw ? `${c.brightGreen}⚡${c.reset}` : '';
         const line4 = `${c.brightCyan}📊 LanceDB${c.reset}    ` +
-            `${c.cyan}Vectors${c.reset} ${vectorColor}●${memoryStats.vectorCount}${hnswIndicator}${c.reset}  ${c.dim}│${c.reset}  ` +
+            `${c.cyan}Vectors${c.reset} ${vectorColor}●~${memoryStats.vectorCount}${hnswIndicator}${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisplay}${c.reset}  ${c.dim}│${c.reset}  ` +
-            `${c.cyan}Tests${c.reset} ${testColor}●${testStats.testFiles}${c.reset} ${c.dim}(${testStats.testCases} cases)${c.reset}  ${c.dim}│${c.reset}  ` +
+            `${c.cyan}Tests${c.reset} ${testColor}●${testStats.testFiles}${c.reset} ${c.dim}(~${testStats.testCases} est.)${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}MCP${c.reset} ${mcpColor}●${mcpStats.enabled}/${mcpStats.total}${c.reset}`;
         output.writeln(header);
         output.writeln(separator);

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

@@ -138,7 +138,7 @@ export const coverageGapsCommand = {
             return { success: true, data: result };
         }
         try {
-            const result = await callMCPTool('hooks_coverage-gaps', { threshold, groupByAgent });
+            const result = await callMCPTool('coverage_gaps', { threshold, groupByAgent });
             spinner.stop();
             const gaps = criticalOnly
                 ? result.gaps.filter(g => g.gapType === 'critical')

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

@@ -150,7 +150,7 @@ export const coverageRouteCommand = {
             return { success: true, data: result };
         }
         try {
-            const result = await callMCPTool('hooks_coverage-route', { task, threshold, useMonovector });
+            const result = await callMCPTool('coverage_route', { task, threshold, useMonovector });
             spinner.stop();
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
@@ -337,7 +337,7 @@ export const coverageSuggestCommand = {
             return { success: true, data: result };
         }
         try {
-            const result = await callMCPTool('hooks_coverage-suggest', { path: targetPath, threshold, limit });
+            const result = await callMCPTool('coverage_suggest', { path: targetPath, threshold, limit });
             spinner.stop();
             if (ctx.flags.format === 'json') {
                 output.printJson(result);

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

@@ -4,11 +4,8 @@
  * Extracted from hooks.ts to reduce file size.
  */
 import type { Command } from '../types.js';
-export declare const tokenOptimizeCommand: Command;
 export declare const modelRouteCommand: Command;
 export declare const modelOutcomeCommand: Command;
 export declare const modelStatsCommand: Command;
-export declare const teammateIdleCommand: Command;
-export declare const taskCompletedCommand: Command;
 export declare const notifyCommand: Command;
 //# sourceMappingURL=hooks-extended-commands.d.ts.map