monomind 1.18.15 → 1.19.0

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

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

@@ -5,114 +5,6 @@
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-// Token Optimizer command
-export const tokenOptimizeCommand = {
-    name: 'token-optimize',
-    description: 'Token optimization via memory-based context retrieval (30-50% savings)',
-    options: [
-        { name: 'query', short: 'q', type: 'string', description: 'Query for compact context retrieval' },
-        { name: 'agents', short: 'A', type: 'number', description: 'Agent count for optimal config', default: '6' },
-        { name: 'report', short: 'r', type: 'boolean', description: 'Generate optimization report' },
-        { name: 'stats', short: 's', type: 'boolean', description: 'Show token savings statistics' },
-    ],
-    examples: [
-        { command: 'monomind hooks token-optimize --stats', description: 'Show token savings stats' },
-        { command: 'monomind hooks token-optimize -q "auth patterns"', description: 'Get compact context' },
-        { command: 'monomind hooks token-optimize -A 8 --report', description: 'Config for 8 agents + report' },
-    ],
-    action: async (ctx) => {
-        const query = ctx.flags['query'];
-        const agentCount = parseInt(ctx.flags['agents'] || '6', 10);
-        const showReport = ctx.flags['report'];
-        const showStats = ctx.flags['stats'];
-        const spinner = output.createSpinner({ text: 'Checking memory integration...', spinner: 'dots' });
-        spinner.start();
-        // Inline TokenOptimizer (self-contained, no external imports)
-        const stats = {
-            totalTokensSaved: 0,
-            editsOptimized: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            memoriesRetrieved: 0,
-        };
-        try {
-            spinner.succeed('Memory-based token optimization active');
-            output.writeln();
-            // Anti-drift config (hardcoded optimal values from research)
-            const config = {
-                batchSize: 4,
-                cacheSizeMB: 50,
-                topology: 'hierarchical',
-                expectedSuccessRate: 0.95,
-            };
-            output.printBox(`Anti-Drift Swarm Config\n\n` +
-                `Agents: ${agentCount}\n` +
-                `Topology: ${config.topology}\n` +
-                `Batch Size: ${config.batchSize}\n` +
-                `Cache: ${config.cacheSizeMB}MB\n` +
-                `Success Rate: ${(config.expectedSuccessRate * 100)}%`);
-            if (query) {
-                output.writeln();
-                output.printInfo(`Context retrieval for: "${query}" — use monomind memory search`);
-            }
-            // Simulate some token savings for demo
-            stats.totalTokensSaved += 200;
-            stats.cacheHits = 2;
-            stats.cacheMisses = 1;
-            // Show stats
-            if (showStats || showReport) {
-                output.writeln();
-                const total = stats.cacheHits + stats.cacheMisses;
-                const hitRate = total > 0 ? (stats.cacheHits / total * 100).toFixed(1) : '0';
-                const savings = (stats.totalTokensSaved / 1000 * 0.01).toFixed(2);
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20 },
-                    ],
-                    data: [
-                        { metric: 'Tokens Saved', value: stats.totalTokensSaved.toLocaleString() },
-                        { metric: 'Edits Optimized', value: String(stats.editsOptimized) },
-                        { metric: 'Cache Hit Rate', value: `${hitRate}%` },
-                        { metric: 'Memories Retrieved', value: String(stats.memoriesRetrieved) },
-                        { metric: 'Est. Monthly Savings', value: `$${savings}` },
-                    ],
-                });
-            }
-            // Full report
-            if (showReport) {
-                output.writeln();
-                const total = stats.cacheHits + stats.cacheMisses;
-                const hitRate = total > 0 ? (stats.cacheHits / total * 100).toFixed(1) : '0';
-                const savings = (stats.totalTokensSaved / 1000 * 0.01).toFixed(2);
-                output.writeln(`## Token Optimization Report
-
-| Metric | Value |
-|--------|-------|
-| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |
-| Edits Optimized | ${stats.editsOptimized} |
-| Cache Hit Rate | ${hitRate}% |
-| Memories Retrieved | ${stats.memoriesRetrieved} |
-| Est. Monthly Savings | $${savings} |
-| Memories Retrieved | ${stats.memoriesRetrieved} |`);
-            }
-            return { success: true, data: { config, stats } };
-        }
-        catch (error) {
-            spinner.fail('TokenOptimizer failed');
-            const err = error;
-            output.printError(`Error: ${err.message}`);
-            // Fallback info
-            output.writeln();
-            output.printInfo('Fallback anti-drift config:');
-            output.writeln('  topology: hierarchical');
-            output.writeln('  maxAgents: 8');
-            output.writeln('  strategy: specialized');
-            output.writeln('  batchSize: 4');
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
 // Model Router command - intelligent model selection (haiku/sonnet/opus)
 export const modelRouteCommand = {
     name: 'model-route',
@@ -301,205 +193,6 @@ export const modelStatsCommand = {
         }
     }
 };
-// Teammate Idle command - Agent Teams integration
-export const teammateIdleCommand = {
-    name: 'teammate-idle',
-    description: 'Handle idle teammate in Agent Teams - auto-assign tasks or notify lead',
-    options: [
-        {
-            name: 'auto-assign',
-            short: 'a',
-            description: 'Automatically assign pending tasks to idle teammate',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'check-task-list',
-            short: 'c',
-            description: 'Check shared task list for available work',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'teammate-id',
-            short: 't',
-            description: 'ID of the idle teammate',
-            type: 'string'
-        },
-        {
-            name: 'team-name',
-            description: 'Team name for context',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks teammate-idle --auto-assign true', description: 'Auto-assign tasks to idle teammate' },
-        { command: 'monomind hooks teammate-idle -t worker-1 --check-task-list', description: 'Check tasks for specific teammate' }
-    ],
-    action: async (ctx) => {
-        const autoAssign = ctx.flags['auto-assign'] !== false;
-        const checkTaskList = ctx.flags['check-task-list'] !== false;
-        const teammateId = ctx.flags['teammate-id'];
-        const teamName = ctx.flags['team-name'];
-        if (ctx.flags.format !== 'json') {
-            output.printInfo(`Teammate idle hook triggered${teammateId ? ` for: ${output.highlight(teammateId)}` : ''}`);
-        }
-        try {
-            const result = await callMCPTool('hooks_teammate-idle', {
-                autoAssign,
-                checkTaskList,
-                teammateId,
-                teamName,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            if (result.action === 'assigned' && result.taskAssigned) {
-                output.printSuccess(`Task assigned: ${result.taskAssigned.subject}`);
-                output.printList([
-                    `Task ID: ${result.taskAssigned.taskId}`,
-                    `Priority: ${result.taskAssigned.priority}`,
-                    `Pending tasks remaining: ${result.pendingTasks}`
-                ]);
-            }
-            else if (result.action === 'waiting') {
-                output.printInfo('No pending tasks available - teammate waiting for work');
-            }
-            else {
-                output.printInfo(`Team lead notified: ${result.message}`);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            // Graceful fallback - don't fail hard, just report
-            if (ctx.flags.format === 'json') {
-                output.printJson({ success: true, action: 'waiting', message: 'Teammate idle - no MCP server' });
-            }
-            else {
-                output.printInfo('Teammate idle - awaiting task assignment');
-            }
-            return { success: true };
-        }
-    }
-};
-// Task Completed command - Agent Teams integration
-export const taskCompletedCommand = {
-    name: 'task-completed',
-    description: 'Handle task completion in Agent Teams - train patterns and notify lead',
-    options: [
-        {
-            name: 'task-id',
-            short: 'i',
-            description: 'ID of the completed task',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'train-patterns',
-            short: 'p',
-            description: 'Train neural patterns from successful task',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'notify-lead',
-            short: 'n',
-            description: 'Notify team lead of task completion',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'success',
-            short: 's',
-            description: 'Whether the task succeeded',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'quality',
-            short: 'q',
-            description: 'Quality score (0-1)',
-            type: 'number'
-        },
-        {
-            name: 'teammate-id',
-            short: 't',
-            description: 'ID of the teammate that completed the task',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks task-completed -i task-123 --train-patterns', description: 'Complete task and train patterns' },
-        { command: 'monomind hooks task-completed -i task-456 --notify-lead --quality 0.95', description: 'Complete with quality score' }
-    ],
-    action: async (ctx) => {
-        const taskId = ctx.args[0] || ctx.flags['task-id'];
-        const trainPatterns = ctx.flags['train-patterns'] !== false;
-        const notifyLead = ctx.flags['notify-lead'] !== false;
-        const success = ctx.flags.success !== false;
-        const quality = ctx.flags.quality;
-        const teammateId = ctx.flags['teammate-id'];
-        if (!taskId) {
-            output.printError('Task ID is required. Use --task-id or -i flag.');
-            return { success: false, exitCode: 1 };
-        }
-        if (ctx.flags.format !== 'json') {
-            output.printInfo(`Task completed: ${output.highlight(taskId)}`);
-        }
-        try {
-            const result = await callMCPTool('hooks_task-completed', {
-                taskId,
-                trainPatterns,
-                notifyLead,
-                success,
-                quality,
-                teammateId,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printSuccess(`Task ${taskId} marked complete`);
-            output.writeln();
-            output.writeln(output.bold('Completion Metrics'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Patterns Learned', value: result.patternsLearned },
-                    { metric: 'Quality Score', value: quality ? `${(quality * 100).toFixed(0)}%` : 'N/A' },
-                    { metric: 'Lead Notified', value: result.leadNotified ? 'Yes' : 'No' },
-                    { metric: 'Learning Updates', value: result.metrics?.learningUpdates || 0 }
-                ]
-            });
-            if (result.nextTask) {
-                output.writeln();
-                output.printInfo(`Next available task: ${result.nextTask.subject}`);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            // Graceful fallback
-            if (ctx.flags.format === 'json') {
-                output.printJson({ success: true, taskId, message: 'Task completed - patterns pending' });
-            }
-            else {
-                output.printSuccess(`Task ${taskId} completed`);
-                if (trainPatterns) {
-                    output.printInfo('Pattern training queued for next sync');
-                }
-            }
-            return { success: true };
-        }
-    }
-};
 // Notify subcommand
 export const notifyCommand = {
     name: 'notify',

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

@@ -14,7 +14,7 @@ import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { intelligenceCommand, workerCommand } from './hooks-workers.js';
 import { coverageRouteCommand, coverageSuggestCommand, coverageGapsCommand, statuslineCommand, } from './hooks-coverage-commands.js';
-import { tokenOptimizeCommand, modelRouteCommand, modelOutcomeCommand, modelStatsCommand, teammateIdleCommand, taskCompletedCommand, notifyCommand, } from './hooks-extended-commands.js';
+import { modelRouteCommand, modelOutcomeCommand, modelStatsCommand, notifyCommand, } from './hooks-extended-commands.js';
 import { preEditCommand, postEditCommand, preCommandCommand, postCommandCommand, } from './hooks-core-commands.js';
 import { routeCommand, explainCommand, pretrainCommand, buildAgentsCommand, metricsCommand, transferCommand, listCommand, } from './hooks-routing-commands.js';
 // Pre-task subcommand
@@ -428,8 +428,6 @@ export const hooksCommand = {
         coverageRouteCommand,
         coverageSuggestCommand,
         coverageGapsCommand,
-        // Token optimization
-        tokenOptimizeCommand,
         // Model routing (tiny-dancer integration)
         modelRouteCommand,
         modelOutcomeCommand,
@@ -439,9 +437,6 @@ export const hooksCommand = {
         sessionStartCommand,
         preBashCommand,
         postBashCommand,
-        // Agent Teams integration
-        teammateIdleCommand,
-        taskCompletedCommand,
     ],
     options: [],
     examples: [
@@ -476,19 +471,13 @@ export const hooksCommand = {
             `${output.highlight('transfer')}        - Transfer patterns from another project`,
             `${output.highlight('list')}            - List all registered hooks`,
             `${output.highlight('worker')}          - Background worker management (12 workers)`,
-            `${output.highlight('progress')}        - Check implementation progress`,
             `${output.highlight('statusline')}      - Generate dynamic statusline display`,
             `${output.highlight('coverage-route')}  - Route tasks based on coverage gaps (monovector)`,
             `${output.highlight('coverage-suggest')}- Suggest coverage improvements`,
             `${output.highlight('coverage-gaps')}   - List all coverage gaps with agents`,
-            `${output.highlight('token-optimize')} - Token optimization (30-50% savings)`,
             `${output.highlight('model-route')}    - Route to optimal model (haiku/sonnet/opus)`,
             `${output.highlight('model-outcome')}  - Record model routing outcome`,
             `${output.highlight('model-stats')}    - View model routing statistics`,
-            '',
-            output.bold('Agent Teams:'),
-            `${output.highlight('teammate-idle')}  - Handle idle teammate (auto-assign tasks)`,
-            `${output.highlight('task-completed')} - Handle task completion (train patterns)`
         ]);
         output.writeln();
         output.writeln('Run "monomind hooks <subcommand> --help" for subcommand help');